Page MenuHomeHEPForge
Files F3521822

No OneTemporary
Actions

View Options

This file is larger than 256 KB, so syntax highlighting was skipped.
Index: trunk/ChangeLog
===================================================================
--- trunk/ChangeLog (revision 8482)
+++ trunk/ChangeLog (revision 8483)
@@ -1,2175 +1,2178 @@
ChangeLog -- Summary of changes to the WHIZARD package
Use svn log to see detailed changes.
Version 3.0.0_beta+
+2021-02-25
+ Enable VAMP and VAMP2 channel equivalences for NLO integrations
+
2021-02-04
Bug fix if user does not set a prefix at configuration
2020-12-10
Generalize NLO calculations to non-CMS lab frames
2020-12-08
Bug fix in expanded p-wave form factor for top threshold
2020-12-06
Patch for macOS Big Sur shared library handling due to libtool;
the patch also demands gcc/gfortran 11.0/10.3/9.4/8.5
2020-12-04
O'Mega only inserts non-vanishing couplings from UFO models
2020-11-21
Bug fix for fractional hypercharges in UFO models
2020-11-11
Enable PYTHIA6 settings for eh collisions (enable-pythia6_eh)
2020-11-09
Correct flavor assignment for NLO fixed-order events
2020-11-05
Bug fix for ISR handler not working with unstable particles
2020-10-08
Bug fix in LHAPDF interface for photon PDFs
2020-10-07
Bug fix for structure function setup with asymmetric beams
2020-10-02
Python/Cython layer for WHIZARD API
2020-09-30
Allow mismatches of Python and name attributes in UFO models
2020-09-26
Support for negative PDG particles from certain UFO models
2020-09-24
Allow for QNUMBERS blocks in BSM SLHA files
2020-09-22
Full support for compilation with clang(++) on Darwin/macOS
More documentation in the manual
Minor clean-ups
2020-09-16
Bug fix enables reading LCIO events with LCIO v2.15+
##################################################################
2020-09-16
RELEASE: version 2.8.5
2020-09-11
Bug fix for H->tau tau transverse polarization with PYTHIA6
(thanks to Junping Tian / Akiya Miyamoto)
2020-09-09
Fix a long standing bug (since 2.0) in the calculation of color
factors when particles of different color were combined in a
particle class. NB: O'Mega never produced a wrong number,
it only declared all processes as invalid.
2020-09-08
Enable Openloops matrix element equivalences for optimization
2020-09-02
Compatibility fix for PYTHIA v8.301+ interface
2020-09-01
Support exclusive jet clustering in ee for Fastjet interface
##################################################################
2020-08-30
RELEASE: version 3.0.0_beta
2020-08-27
Major revision of NLO distributions and events for
processes with structure functions:
- Use parton momenta/flavors (instead of beams) for events
- Bug fix for Lorentz boosts and Lorentz frames of momenta
- Bug fix: apply cuts to virtual NLO component in correct frame
- Correctly assign ISR radiation momenta in data structures
- Refactoring on quantum numbers for NLO event data structures
- Functional tests for hadron collider NLO distributions
- many minor bug fixes regarding NLO hadron collider physics
2020-08-11
Bug fix for linking problem with OpenMPI
2020-08-07
New WHIZARD API: WHIZARD can be externally linked as a
library, added examples for Fortran, C, C++ programs
##################################################################
2020-07-08
RELEASE: version 2.8.4
2020-07-07
Bug fix: steering of UFO Majorana models from WHIZARD
##################################################################
2020-07-06
Combined integration also for hadron collider processes at NLO
2020-07-05
Bug fix: correctly steer e+e- FastJet clustering algorithms
Major revision of NLO differential distributions and events:
- Correctly assign quantum numbers to NLO fixed-order events
- Correctly assign weights to NLO fixed-order events for
combined simulation
- Cut all NLO fixed-order subevents in event groups individually
- Only allow "sigma" normalization for NLO fixed-order events
- Use correct PDF setup for NLO counter events
- Several technical fixes and updates of the NLO testsuite
##################################################################
2020-07-03
RELEASE: version 2.8.3
2020-07-02
Feature-complete UFO implementation for Majorana fermions
2020-06-22
Running width scheme supported for O'Mega matrix elements
2020-06-20
Adding H-s-s coupling to SM_Higgs(_CKM) models
2020-06-17
Completion of ILC 2->6 fermion extended test suite
2020-06-15
Bug fix: PYTHIA6/Tauola, correctly assign tau spins for stau decays
2020-06-09
Bug fix: correctly update calls for additional VAMP/2 iterations
Bug fix: correct assignment for tau spins from PYTHIA6 interface
2020-06-04
Bug fix: cascades2 tree merge with empty subtree(s)
2020-05-31
Switch $epa_mode for different EPA implementations
2020-05-26
Bug fix: spin information transferred for resonance histories
2020-04-13
HepMC: correct weighted events for non-xsec event normalizations
2020-04-04
Improved HepMC3 interface: HepMC3 Root/RootTree interface
2020-03-24
ISR: Fix on-shell kinematics for events with ?isr_handler=true
(set ?isr_handler_keep_mass=false for old behavior)
2020-03-11
Beam masses are correctly passed to hard matrix element for CIRCE2
EPA with polarized beams: double-counting corrected
##################################################################
2020-03-03
RELEASE: version 3.0.0_alpha
2020-02-25
Bug fix: Scale and alphas can be retrieved from internal event format to
external formats
2020-02-17
Bug fix: ?keep_failed_events now forces output of actual event data
Bug fix: particle-set reconstruction (rescanning events w/o radiation)
2020-01-28
Bug fix for left-over EPA parameter epa_e_max (replaced by epa_q_max)
2020-01-23
Bug fix for real components of NLO QCD 2->1 processes
2020-01-22
Bug fix: correct random number sequencing during parallel MPI event
generation with rng_stream
2020-01-21
Consistent distribution of events during parallel MPI event generation
2020-01-20
Bug fix for configure setup for automake v1.16+
2020-01-18
General SLHA parameter files for UFO models supported
2020-01-08
Bug fix: correctly register RECOLA processes with flavor sums
2019-12-19
Support for UFO customized propagators
O'Mega unit tests for fermion-number violating interactions
2019-12-10
For distribution building: check for graphviz/dot
version 2.40 or newer
2019-11-21
Bug fix: alternate setups now work correctly
Infrastructure for accessing alpha_QED event-by-event
Guard against tiny numbers that break ASCII event output
Enable inverse hyperbolic functions as SINDARIN observables
Remove old compiler bug workarounds
2019-11-20
Allow quoted -e argument, implemented -f option
2019-11-19
Bug fix: resonance histories now work also with UFO models
Fix in numerical precision of ASCII VAMP2 grids
2019-11-06
Add squared matrix elements to the LCIO event header
2019-11-05
Do not include RNG state in MD5 sum for CIRCE1/2
2019-11-04
Full CIRCE2 ILC 250 and 500 GeV beam spectra added
Minor update on LCIO event header information
2019-10-30
NLO QCD for final states completed
When using Openloops, v2.1.1+ mandatory
2019-10-25
Binary grid files for VAMP2 integrator
##################################################################
2019-10-24
RELEASE: version 2.8.2
2019-10-20
Bug fix for HepMC linker flags
2019-10-19
Support for spin-2 particles from UFO files
2019-09-27
LCIO event format allows rescan and alternate weights
2019-09-24
Compatibility fix for OCaml v4.08.0+
##################################################################
2019-09-21
RELEASE: version 2.8.1
2019-09-19
Carriage return characters in UFO models can be parsed
Mathematica symbols in UFO models possible
Unused/undefined parameters in UFO models handled
2019-09-13
New extended NLO test suite for ee and pp processes
2019-09-09
Photon isolation (separation of perturbative and fragmentation
part a la Frixione)
2019-09-05
Major progress on NLO QCD for hadron collisions:
- correctly assign flavor structures for alpha regions
- fix crossing of particles for initial state splittings
- correct assignment for PDF factors for real subtractions
- fix kinematics for collinear splittings
- bug fix for integrated virtual subtraction terms
2019-09-03
b and c jet selection in cuts and analysis
2019-08-27
Support for Intel MPI
2019-08-20
Complete (preliminary) HepMC3 support (incl.
backwards HepMC2 write/read mode)
2019-08-08
Bug fix: handle carriage returns in UFO files (non-Unix OS)
##################################################################
2019-08-07
RELEASE: version 2.8.0
2019-07-31
Complete WHIZARD UFO interface:
- general Lorentz structures
- matrix element support for general color factors
- missing features: Majorana fermions and SLHA
2019-07-20
Make WHIZARD compatible with OCaml 4.08.0+
2019-07-19
Fix version testing for LHAPDF 6.2.3 and newer
Minimal required OCaml version is now 4.02.3.
2019-04-18
Correctly generate ordered FKS tuples for alpha regions
from all possible underlying Born processes
2019-04-08
Extended O'Mega/Recola matrix element test suite
2019-03-29
Correct identical particle symmetry factors for FKS subtraction
2019-03-28
Correct assertion of spin-correlated matrix
elements for hadron collisions
2019-03-27
Bug fix for cut-off parameter delta_i for
collinear plus/minus regions
##################################################################
2019-03-27
RELEASE: version 2.7.1
2019-02-19
Further infrastructure for HepMC3 interface (v3.01.00)
2019-02-07
Explicit configure option for using debugging options
Bug fix for performance by removing unnecessary debug operations
2019-01-29
Bug fix for DGLAP remnants with cut-off parameter delta_i
2019-01-24
Radiative decay neu2 -> neu1 A added to MSSM_Hgg model
##################################################################
2019-01-21
RELEASE: version 2.7.0
2018-12-18
Support RECOLA for integrated und unintegrated subtractions
2018-12-11
FCNC top-up sector in model SM_top_anom
2018-12-05
Use libtirpc instead of SunRPC on Arch Linux etc.
2018-11-30
Display rescaling factor for weighted event samples with cuts
2018-11-29
Reintroduce check against different masses in flavor sums
Bug fix for wrong couplings in the Littlest Higgs model(s)
2018-11-22
Bug fix for rescanning events with beam structure
2018-11-09
Major refactoring of internal process data
2018-11-02
PYTHIA8 interface
2018-10-29
Flat phase space parametrization with RAMBO (on diet) implemented
2018-10-17
Revise extended test suite
2018-09-27
Process container for RECOLA processes
2018-09-15
Fixes by M. Berggren for PYTHIA6 interface
2018-09-14
First fixes after HepForge modernization
##################################################################
2018-08-23
RELEASE: version 2.6.4
2018-08-09
Infrastructure to check colored subevents
2018-07-10
Infrastructure for running WHIZARD in batch mode
2018-07-04
MPI available from distribution tarball
2018-06-03
Support Intel Fortran Compiler under MAC OS X
2018-05-07
FKS slicing parameter delta_i (initial state) implementend
2018-05-03
Refactor structure function assignment for NLO
2018-05-02
FKS slicing parameter xi_cut, delta_0 implemented
2018-04-20
Workspace subdirectory for process integration (grid/phs files)
Packing/unpacking of files at job end/start
Exporting integration results from scan loops
2018-04-13
Extended QCD NLO test suite
2018-04-09
Bug fix for Higgs Singlet Extension model
2018-04-06
Workspace subdirectory for process generation and compilation
--job-id option for creating job-specific names
2018-03-20
Bug fix for color flow matching in hadron collisions
with identical initial state quarks
2018-03-08
Structure functions quantum numbers correctly assigned for NLO
2018-02-24
Configure setup includes 'pgfortran' and 'flang'
2018-02-21
Include spin-correlated matrix elements in interactions
2018-02-15
Separate module for QED ISR structure functions
##################################################################
2018-02-10
RELEASE: version 2.6.3
2018-02-08
Improvements in memory management for PS generation
2018-01-31
Partial refactoring: quantum number assigment NLO
Initial-state QCD splittings for hadron collisions
2018-01-25
Bug fix for weighted events with VAMP2
2018-01-17
Generalized interface for Recola versions 1.3+ and 2.1+
2018-01-15
Channel equivalences also for VAMP2 integrator
2018-01-12
Fix for OCaml compiler 4.06 (and newer)
2017-12-19
RECOLA matrix elements with flavor sums can be integrated
2017-12-18
Bug fix for segmentation fault in empty resonance histories
2017-12-16
Fixing a bug in PYTHIA6 PYHEPC routine by omitting CMShowers
from transferral between PYTHIA and WHIZARD event records
2017-12-15
Event index for multiple processes in event file correct
##################################################################
2017-12-13
RELEASE: version 2.6.2
2017-12-07
User can set offset in event numbers
2017-11-29
Possibility to have more than one RECOLA process in one file
2017-11-23
Transversal/mixed (and unitarized) dim-8 operators
2017-11-16
epa_q_max replaces epa_e_max (trivial factor 2)
2017-11-15
O'Mega matrix element compilation silent now
2017-11-14
Complete expanded P-wave form factor for top threshold
2017-11-10
Incoming particles can be accessed in SINDARIN
2017-11-08
Improved handling of resonance insertion, additional parameters
2017-11-04
Added Higgs-electron coupling (SM_Higgs)
##################################################################
2017-11-03
RELEASE: version 2.6.1
2017-10-20
More than 5 NLO components possible at same time
2017-10-19
Gaussian cutoff for shower resonance matching
2017-10-12
Alternative (more efficient) method to generate
phase space file
2017-10-11
Bug fix for shower resonance histories for processes
with multiple components
2017-09-25
Bug fix for process libraries in shower resonance histories
2017-09-21
Correctly generate pT distribution for EPA remnants
2017-09-20
Set branching ratios for unstable particles also by hand
2017-09-14
Correctly generate pT distribution for ISR photons
##################################################################
2017-09-08
RELEASE: version 2.6.0
2017-09-05
Bug fix for initial state NLO QCD flavor structures
Real and virtual NLO QCD hadron collider processes
work with internal interactions
2017-09-04
Fully validated MPI integration and event generation
2017-09-01
Resonance histories for shower: full support
Bug fix in O'Mega model constraints
O'Mega allows to output a parsable form of the DAG
2017-08-24
Resonance histories in events for transferral
to parton shower (e.g. in ee -> jjjj)
2017-08-01
Alpha version of HepMC v3 interface
(not yet really functional)
2017-07-31
Beta version for RECOLA OLP support
2017-07-06
Radiation generator fix for LHC processes
2017-06-30
Fix bug for NLO with structure
functions and/or polarization
2017-06-23
Collinear limit for QED corrections works
2017-06-17
POWHEG grids generated already during integration
2017-06-12
Soft limit for QED corrections works
2017-05-16
Beta version of full MPI parallelization (VAMP2)
Check consistency of POWHEG grid files
Logfile config-summary.log for configure summary
2017-05-12
Allow polarization in top threshold
2017-05-09
Minimal demand automake 1.12.2
Silent rules for make procedures
2017-05-07
Major fix for POWHEG damping
Correctly initialize FKS ISR phasespace
##################################################################
2017-05-06
RELEASE: version 2.5.0
2017-05-05
Full UFO support (SM-like models)
Fixed-beam ISR FKS phase space
2017-04-26
QED splittings in radiation generator
2017-04-10
Retire deprecated O'Mega vertex cache files
##################################################################
2017-03-24
RELEASE: version 2.4.1
2017-03-16
Distinguish resonance charge in phase space channels
Keep track of resonance histories in phase space
Complex mass scheme default for OpenLoops amplitudes
2017-03-13
Fix helicities for polarized OpenLoops calculations
2017-03-09
Possibility to advance RNG state in rng_stream
2017-03-04
General setup for partitioning real emission
phase space
2017-03-06
Bug fix on rescan command for converting event files
2017-02-27
Alternative multi-channel VEGAS implementation
VAMP2: serial backbone for MPI setup
Smoothstep top threshold matching
2017-02-25
Single-beam structure function with
s-channel mapping supported
Safeguard against invalid process libraries
2017-02-16
Radiation generator for photon emission
2017-02-10
Fixes for NLO QCD processes (color correlations)
2017-01-16
LCIO variable takes precedence over LCIO_DIR
2017-01-13
Alternative random number generator
rng_stream (cf. L'Ecuyer et al.)
2017-01-01
Fix for multi-flavor BLHA tree
matrix elements
2016-12-31
Grid path option for VAMP grids
2016-12-28
Alpha version of Recola OLP support
2016-12-27
Dalitz plots for FKS phase space
2016-12-14
NLO multi-flavor events possible
2016-12-09
LCIO event header information added
2016-12-02
Alpha version of RECOLA interface
Bug fix for generator status in LCIO
##################################################################
2016-11-28
RELEASE: version 2.4.0
2016-11-24
Bug fix for OpenLoops interface: EW scheme
is set by WHIZARD
Bug fixes for top threshold implementation
2016-11-11
Refactoring of dispatching
2016-10-18
Bug fix for LCIO output
2016-10-10
First implementation for collinear soft terms
2016-10-06
First full WHIZARD models from UFO files
2016-10-05
WHIZARD does not support legacy gcc 4.7.4 any longer
2016-09-30
Major refactoring of process core and NLO components
2016-09-23
WHIZARD homogeneous entity: discarding subconfigures
for CIRCE1/2, O'Mega, VAMP subpackages; these are
reconstructable by script projectors
2016-09-06
Introduce main configure summary
2016-08-26
Fix memory leak in event generation
##################################################################
2016-08-25
RELEASE: version 2.3.1
2016-08-19
Bug fix for EW-scheme dependence of gluino propagators
2016-08-01
Beta version of complex mass scheme support
2016-07-26
Fix bug in POWHEG damping for the matching
##################################################################
2016-07-21
RELEASE: version 2.3.0
2016-07-20
UFO file support (alpha version) in O'Mega
2016-07-13
New (more) stable of WHIZARD GUI
Support for EW schemes for OpenLoops
Factorized NLO top decays for threshold model
2016-06-15
Passing factorization scale to PYTHIA6
Adding charge and neutral observables
2016-06-14
Correcting angular distribution/tweaked kinematics in
non-collinear structure functions splittings
2016-05-10
Include (Fortran) TAUOLA/PHOTOS for tau decays via PYTHIA6
(backwards validation of LC CDR/TDR samples)
2016-04-27
Within OpenLoops virtuals: support for Collier library
2016-04-25
O'Mega vertex tables only loaded at first usage
2016-04-21
New CJ15 PDF parameterizations added
2016-04-21
Support for hadron collisions at NLO QCD
2016-04-05
Support for different (parameter) schemes in model files
2016-03-31
Correct transferral of lifetime/vertex from PYTHIA/TAUOLA
into the event record
2016-03-21
New internal implementation of polarization
via Bloch vectors, remove pointer constructions
2016-03-13
Extension of cascade syntax for processes:
exclude propagators/vertices etc. possible
2016-02-24
Full support for OpenLoops QCD NLO matrix
elements, inclusion in test suite
2016-02-12
Substantial progress on QCD NLO support
2016-02-02
Automated resonance mapping for FKS subtraction
2015-12-17
New BSM model WZW for diphoton resonances
##################################################################
2015-11-22
RELEASE: version 2.2.8
2015-11-21
Bug fix for fixed-order NLO events
2015-11-20
Anomalous FCNC top-charm vertices
2015-11-19
StdHEP output via HEPEVT/HEPEV4 supported
2015-11-18
Full set of electroweak dim-6 operators included
2015-10-22
Polarized one-loop amplitudes supported
2015-10-21
Fixes for event formats for showered events
2015-10-14
Callback mechanism for event output
2015-09-22
Bypass matrix elements in pure event sample rescans
StdHep frozen final version v5.06.01 included internally
2015-09-21
configure option --with-precision to
demand 64bit, 80bit, or 128bit Fortran
and bind C precision types
2015-09-07
More extensive tests of NLO
infrastructure and POWHEG matching
2015-09-01
NLO decay infrastructure
User-defined squared matrix elements
Inclusive FastJet algorithm plugin
Numerical improvement for small boosts
##################################################################
2015-08-11
RELEASE: version 2.2.7
2015-08-10
Infrastructure for damped POWHEG
Massive emitters in POWHEG
Born matrix elements via BLHA
GoSam filters via SINDARIN
Minor running coupling bug fixes
Fixed-order NLO events
2015-08-06
CT14 PDFs included (LO, NLO, NNLL)
2015-07-07
Revalidation of ILC WHIZARD-PYTHIA event chain
Extended test suite for showered events
Alpha version of massive FSR for POWHEG
2015-06-09
Fix memory leak in interaction for long cascades
Catch mismatch between beam definition and CIRCE2 spectrum
2015-06-08
Automated POWHEG matching: beta version
Infrastructure for GKS matching
Alpha version of fixed-order NLO events
CIRCE2 polarization averaged spectra with
explicitly polarized beams
2015-05-12
Abstract matching type: OO structure for matching/merging
2015-05-07
Bug fix in event record WHIZARD-PYTHIA6 transferral
Gaussian beam spectra for lepton colliders
##################################################################
2015-05-02
RELEASE: version 2.2.6
2015-05-01
Models for (unitarized) tensor resonances in VBS
2015-04-28
Bug fix in channel weights for event generation.
2015-04-18
Improved event record transfer WHIZARD/PYTHIA6
2015-03-19
POWHEG matching: alpha version
##################################################################
2015-02-27
RELEASE: version 2.2.5
2015-02-26
Abstract types for quantum numbers
2015-02-25
Read-in of StdHEP events, self-tests
2015-02-22
Bug fix for mother-daughter relations in
showered/hadronized events
2015-02-20
Projection on polarization in intermediate states
2015-02-13
Correct treatment of beam remnants in
event formats (also LC remnants)
##################################################################
2015-02-06
RELEASE: version 2.2.4
2015-02-06
Bug fix in event output
2015-02-05
LCIO event format supported
2015-01-30
Including state matrices in WHIZARD's internal IO
Versioning for WHIZARD's internal IO
Libtool update from 2.4.3 to 2.4.5
LCIO event output (beta version)
2015-01-27
Progress on NLO integration
Fixing a bug for multiple processes in a single
event file when using beam event files
2015-01-19
Bug fix for spin correlations evaluated in the rest
frame of the mother particle
2015-01-17
Regression fix for statically linked processes
from SARAH and FeynRules
2015-01-10
NLO: massive FKS emitters supported (experimental)
2015-01-06
MMHT2014 PDF sets included
2015-01-05
Handling mass degeneracies in auto_decays
2014-12-19
Fixing bug in rescan of event files
##################################################################
2014-11-30
RELEASE: version 2.2.3
2014-11-29
Beta version of LO continuum/NLL-threshold
matched top threshold model for e+e- physics
2014-11-28
More internal refactoring: disentanglement of module
dependencies
2014-11-21
OVM: O'Mega Virtual Machine, bytecode instructions
instead of compiled Fortran code
2014-11-01
Higgs Singlet extension model included
2014-10-18
Internal restructuring of code; half-way
WHIZARD main code file disassembled
2014-07-09
Alpha version of NLO infrastructure
##################################################################
2014-07-06
RELEASE: version 2.2.2
2014-07-05
CIRCE2: correlated LC beam spectra and
GuineaPig Interface to LC machine parameters
2014-07-01
Reading LHEF for decayed/factorized/showered/
hadronized events
2014-06-25
Configure support for GoSAM/Ninja/Form/QGraf
2014-06-22
LHAPDF6 interface
2014-06-18
Module for automatic generation of
radiation and loop infrastructure code
2014-06-11
Improved internal directory structure
##################################################################
2014-06-03
RELEASE: version 2.2.1
2014-05-30
Extensions of internal PDG arrays
2014-05-26
FastJet interface
2014-05-24
CJ12 PDFs included
2014-05-20
Regression fix for external models (via SARAH
or FeynRules)
##################################################################
2014-05-18
RELEASE: version 2.2.0
2014-04-11
Multiple components: inclusive process definitions,
syntax: process A + B + ...
2014-03-13
Improved PS mappings for e+e- ISR
ILC TDR and CLIC spectra included in CIRCE1
2014-02-23
New models: AltH w\ Higgs for exclusion purposes,
SM_rx for Dim 6-/Dim-8 operators, SSC for
general strong interactions (w/ Higgs), and
NoH_rx (w\ Higgs)
2014-02-14
Improved s-channel mapping, new on-shell
production mapping (e.g. Drell-Yan)
2014-02-03
PRE-RELEASE: version 2.2.0_beta
2014-01-26
O'Mega: Feynman diagram generation possible (again)
2013-12-16
HOPPET interface for b parton matching
2013-11-15
PRE-RELEASE: version 2.2.0_alpha-4
2013-10-27
LHEF standards 1.0/2.0/3.0 implemented
2013-10-15
PRE-RELEASE: version 2.2.0_alpha-3
2013-10-02
PRE-RELEASE: version 2.2.0_alpha-2
2013-09-25
PRE-RELEASE: version 2.2.0_alpha-1
2013-09-12
PRE-RELEASE: version 2.2.0_alpha
2013-09-03
General 2HDM implemented
2013-08-18
Rescanning/recalculating events
2013-06-07
Reconstruction of complete event
from 4-momenta possible
2013-05-06
Process library stacks
2013-05-02
Process stacks
2013-04-29
Single-particle phase space module
2013-04-26
Abstract interface for random
number generator
2013-04-24
More object-orientation on modules
Midpoint-rule integrator
2013-04-05
Object-oriented integration and
event generation
2013-03-12
Processes recasted object-oriented:
MEs, scales, structure functions
First infrastructure for general Lorentz
structures
2013-01-17
Object-orientated reworking of library and
process core, more variable internal structure,
unit tests
2012-12-14
Update Pythia version to 6.4.27
2012-12-04
Fix the phase in HAZ vertices
2012-11-21
First O'Mega unit tests, some infrastructure
2012-11-13
Bug fix in anom. HVV Lorentz structures
##################################################################
2012-09-18
RELEASE: version 2.1.1
2012-09-11
Model MSSM_Hgg with Hgg and HAA vertices
2012-09-10
First version of implementation of multiple
interactions in WHIZARD
2012-09-05
Infrastructure for internal CKKW matching
2012-09-02
C, C++, Python API
2012-07-19
Fixing particle numbering in HepMC format
##################################################################
2012-06-15
RELEASE: version 2.1.0
2012-06-14
Analytical and kT-ordered shower officially
released
PYTHIA interface officially released
2012-05-09
Intrisince PDFs can be used for showering
2012-05-04
Anomalous Higgs couplings a la hep-ph/9902321
##################################################################
2012-03-19
RELEASE: version 2.0.7
2012-03-15
Run IDs are available now
More event variables in analysis
Modified raw event format (compatibility mode exists)
2012-03-12
Bug fix in decay-integration order
MLM matching steered completely internally now
2012-03-09
Special phase space mapping for narrow resonances
decaying to 4-particle final states with far off-shell
intermediate states
Running alphas from PDF collaborations with
builtin PDFs
2012-02-16
Bug fix in cascades decay infrastructure
2012-02-04
WHIZARD documentation compatible with TeXLive 2011
2012-02-01
Bug fix in FeynRules interface with --prefix flag
2012-01-29
Bug fix with name clash of O'Mega variable names
2012-01-27
Update internal PYTHIA to version 6.4.26
Bug fix in LHEF output
2012-01-21
Catching stricter automake 1.11.2 rules
2011-12-23
Bug fix in decay cascade setup
2011-12-20
Bug fix in helicity selection rules
2011-12-16
Accuracy goal reimplemented
2011-12-14
WHIZARD compatible with TeXLive 2011
2011-12-09
Option --user-target added
##################################################################
2011-12-07
RELEASE: version 2.0.6
2011-12-07
Bug fixes in SM_top_anom
Added missing entries to HepMC format
2011-12-06
Allow to pass options to O'Mega
Bug fix for HEPEVT block for showered/hadronized events
2011-12-01
Reenabled user plug-in for external code for
cuts, structure functions, routines etc.
2011-11-29
Changed model SM_Higgs for Higgs phenomenology
2011-11-25
Supporting a Y, (B-L) Z' model
2011-11-23
Make WHIZARD compatible for MAC OS X Lion/XCode 4
2011-09-25
WHIZARD paper published: Eur.Phys.J. C71 (2011) 1742
2011-08-16
Model SM_QCD: QCD with one EW insertion
2011-07-19
Explicit output channel for dvips avoids printing
2011-07-10
Test suite for WHIZARD unit tests
2011-07-01
Commands for matrix element tests
More OpenMP parallelization of kinematics
Added unit tests
2011-06-23
Conversion of CIRCE2 from F77 to F90, major
clean-up
2011-06-14
Conversion of CIRCE1 from F77 to F90
2011-06-10
OpenMP parallelization of channel kinematics
(by Matthias Trudewind)
2011-05-31
RELEASE: version 1.97
2011-05-24
Minor bug fixes: update grids and elsif statement.
##################################################################
2011-05-10
RELEASE: version 2.0.5
2011-05-09
Fixed bug in final state flavor sums
Minor improvements on phase-space setup
2011-05-05
Minor bug fixes
2011-04-15
WHIZARD as a precompiled 64-bit binary available
2011-04-06
Wall clock instead of cpu time for time estimates
2011-04-05
Major improvement on the phase space setup
2011-04-02
OpenMP parallelization for helicity loop in O'Mega
matrix elements
2011-03-31
Tools for relocating WHIZARD and use in batch
environments
2011-03-29
Completely static builds possible, profiling options
2011-03-28
Visualization of integration history
2011-03-27
Fixed broken K-matrix implementation
2011-03-23
Including the GAMELAN manual in the distribution
2011-01-26
WHIZARD analysis can handle hadronized event files
2011-01-17
MSTW2008 and CT10 PDF sets included
2010-12-23
Inclusion of NMSSM with Hgg couplings
2010-12-21
Advanced options for integration passes
2010-11-16
WHIZARD supports CTEQ6 and possibly other PDFs
directly; data files included in the distribution
##################################################################
2010-10-26
RELEASE: version 2.0.4
2010-10-06
Bug fix in MSSM implementation
2010-10-01
Update to libtool 2.4
2010-09-29
Support for anomalous top couplings (form factors etc.)
Bug fix for running gauge Yukawa SUSY couplings
2010-09-28
RELEASE: version 1.96
2010-09-21
Beam remnants and pT spectra for lepton collider re-enabled
Restructuring subevt class
2010-09-16
Shower and matching are disabled by default
PYTHIA as a conditional on these two options
2010-09-14
Possibility to read in beam spectra re-enabled (e.g. Guinea
Pig)
2010-09-13
Energy scan as (pseudo-) structure functions re-implemented
2010-09-10
CIRCE2 included again in WHIZARD 2 and validated
2010-09-02
Re-implementation of asymmetric beam energies and collision
angles, e-p collisions work, inclusion of a HERA DIS test
case
##################################################################
2010-10-18
RELEASE: version 2.0.3
2010-08-08
Bug in CP-violating anomalous triple TGCs fixed
2010-08-06
Solving backwards compatibility problem with O'Caml 3.12.0
2010-07-12
Conserved quantum numbers speed up O'Mega code generation
2010-07-07
Attaching full ISR/FSR parton shower and MPI/ISR
module
Added SM model containing Hgg, HAA, HAZ vertices
2010-07-02
Matching output available as LHEF and STDHEP
2010-06-30
Various bug fixes, missing files, typos
2010-06-26
CIRCE1 completely re-enabled
Chaining structure functions supported
2010-06-25
Partial support for conserved quantum numbers in
O'Mega
2010-06-21
Major upgrade of the graphics package: error bars,
smarter SINDARIN steering, documentation, and all that...
2010-06-17
MLM matching with PYTHIA shower included
2010-06-16
Added full CIRCE1 and CIRCE2 versions including
full documentation and miscellanea to the trunk
2010-06-12
User file management supported, improved variable
and command structure
2010-05-24
Improved handling of variables in local command lists
2010-05-20
PYTHIA interface re-enabled
2010-05-19
ASCII file formats for interfacing ROOT and gnuplot in
data analysis
##################################################################
2010-05-18
RELEASE: version 2.0.2
2010-05-14
Reimplementation of visualization of phase space
channels
Minor bug fixes
2010-05-12
Improved phase space - elimination of redundancies
2010-05-08
Interface for polarization completed: polarized beams etc.
2010-05-06
Full quantum numbers appear in process log
Integration results are usable as user variables
Communication with external programs
2010-05-05
Split module commands into commands, integration,
simulation modules
2010-05-04
FSR+ISR for the first time connected to the WHIZARD 2 core
##################################################################
2010-04-25
RELEASE: version 2.0.1
2010-04-23
Automatic compile and integrate if simulate is called
Minor bug fixes in O'Mega
2010-04-21
Checkpointing for event generation
Flush statements to use WHIZARD inside a pipe
2010-04-20
Reimplementation of signal handling in WGIZARD 2.0
2010-04-19
VAMP is now a separately configurable and installable unit of
WHIZARD, included VAMP self-checks
Support again compilation in quadruple precision
2010-04-06
Allow for logarithmic plots in GAMELAN, reimplement the
possibility to set the number of bins
2010-04-15
Improvement on time estimates for event generation
##################################################################
2010-04-12
RELEASE: version 2.0.0
2010-04-09
Per default, the code for the amplitudes is subdivided to allow
faster compiler optimization
More advanced and unified and straightforward command language
syntax
Final bug fixes
2010-04-07
Improvement on SINDARIN syntax; printf, sprintf function
thorugh a C interface
2010-04-05
Colorizing DAGs instead of model vertices: speed boost
in colored code generation
2010-03-31
Generalized options for normalization of weighted and
unweighted events
Grid and weight histories added again to log files
Weights can be used in analyses
2010-03-28
Cascade decays completely implemented including color and
spin correlations
2010-03-07
Added new WHIZARD header with logo
2010-03-05
Removed conflict in O'Mega amplitudes between flavour sums
and cascades
StdHEP interface re-implemented
2010-03-03
RELEASE: version 2.0.0rc3
Several bug fixes for preventing abuse in input files
OpenMP support for amplitudes
Reimplementation of WHIZARD 1 HEPEVT ASCII event formats
FeynRules interface successfully passed MSSM test
2010-02-26
Eliminating ghost gluons from multi-gluon amplitudes
2010-02-25
RELEASE: version 1.95
HEPEVT format from WHIZARD 1 re-implemented in WHIZARD 2
2010-02-23
Running alpha_s implemented in the FeynRules interface
2010-02-19
MSSM (semi-) automatized self-tests finalized
2010-02-17
RELEASE: version 1.94
2010-02-16
Closed memory corruption in WHIZARD 1
Fixed problems of old MadGraph and CompHep drivers
with modern compilers
Uncolored vertex selection rules for colored amplitudes in
O'Mega
2010-02-15
Infrastructure for color correlation computation in O'Mega
finished
Forbidden processes are warned about, but treated as non-fatal
2010-02-14
Color correlation computation in O'Mega finalized
2010-02-10
Improving phase space mappings for identical particles in
initial and final states
Introduction of more extended multi-line error message
2010-02-08
First O'Caml code for computation of color correlations in
O'Mega
2010-02-07
First MLM matching with e+ e- -> jets
##################################################################
2010-02-06
RELEASE: version 2.0.0rc2
2010-02-05
Reconsidered the Makefile structure and more extended tests
Catch a crash between WHIZARD and O'Mega for forbidden processes
Tensor products of arbitrary color structures in jet definitions
2010-02-04
Color correlation computation in O'Mega finalized
##################################################################
2010-02-03
RELEASE: version 2.0.0rc1
##################################################################
2010-01-31
Reimplemented numerical helicity selection rules
Phase space functionality of version 1 restored and improved
2009-12-05
NMSSM validated with FeynRules in WHIZARD 1 (Felix Braam)
2009-12-04
RELEASE: version 2.0.0alpha
##################################################################
2009-04-16
RELEASE: version 1.93
2009-04-15
Clean-up of Makefiles and configure scripts
Reconfiguration of BSM model implementation
extended supersymmetric models
2008-12-23
New model NMSSM (Felix Braam)
SLHA2 added
Bug in LHAPDF interface fixed
2008-08-16
Bug fixed in K matrix implementation
Gravitino option in the MSSM added
2008-03-20
Improved color and flavor sums
##################################################################
2008-03-12
RELEASE: version 1.92
LHEF (Les Houches Event File) format added
Fortran 2003 command-line interface (if supported by the compiler)
Automated interface to colored models
More bug fixes and workarounds for compiler compatibility
##################################################################
2008-03-06
RELEASE: version 1.91
New model K-matrix (resonances and anom. couplings in WW scattering)
EWA spectrum
Energy-scan pseudo spectrum
Preliminary parton shower module (only from final-state quarks)
Cleanup and improvements of configure process
Improvements for O'Mega parameter files
Quadruple precision works again
More plotting options: lines, symbols, errors
Documentation with PDF bookmarks enabled
Various bug fixes
2007-11-29
New model UED
##################################################################
2007-11-23
RELEASE: version 1.90
O'Mega now part of the WHIZARD tree
Madgraph/CompHEP disabled by default (but still usable)
Support for LHAPDF (preliminary)
Added new models: SMZprime, SM_km, Template
Improved compiler recognition and compatibility
Minor bug fixes
##################################################################
2006-06-15
RELEASE: version 1.51
Support for anomaly-type Higgs couplings (to gluon and photon/Z)
Support for spin 3/2 and spin 2
New models: Little Higgs (4 versions), toy models for extra dimensions
and gravitinos
Fixes to the whizard.nw source documentation to run through LaTeX
Intel 9.0 bug workaround (deallocation of some arrays)
2006-05-15
O'Mega RELEASE: version 0.11
merged JRR's O'Mega extensions
##################################################################
2006-02-07
RELEASE: version 1.50
To avoid confusion: Mention outdated manual example in BUGS file
O'Mega becomes part of the WHIZARD generator
2006-02-02 [bug fix update]
Bug fix: spurious error when writing event files for weighted events
Bug fix: 'r' option for omega produced garbage for some particle names
Workaround for ifort90 bug (crash when compiling whizard_event)
Workaround for ifort90 bug (crash when compiling hepevt_common)
2006-01-27
Added process definition files for MSSM 2->2 processes
Included beam recoil for EPA (T.Barklow)
Updated STDHEP byte counts (for STDHEP 5.04.02)
Fixed STDHEP compatibility (avoid linking of incomplete .so libs)
Fixed issue with comphep requiring Xlibs on Opteron
Fixed issue with ifort 8.x on Opteron (compiling 'signal' interface)
Fixed color-flow code: was broken for omega with option 'c' and 'w'
Workaround hacks for g95 compatibility
2005-11-07
O'Mega RELEASE: version 0.10
O'Mega, merged JRR's and WK's color hack for WHiZard
O'Mega, EXPERIMENTAL: cache fusion tables (required for colors
a la JRR/WK)
O'Mega, make JRR's MSSM official
##################################################################
2005-10-25
RELEASE: version 1.43
Minor fixes in MSSM couplings (Higgs/3rd gen squarks).
This should be final, since the MSSM results agree now completely
with Madgraph and Sherpa
User-defined lower and upper limits for split event file count
Allow for counters (events, bytes) exceeding $2^{31}$
Revised checksum treatment and implementation (now MD5)
Bug fix: missing process energy scale in raw event file
##################################################################
2005-09-30
RELEASE: version 1.42
Graphical display of integration history ('make history')
Allow for switching off signals even if supported (configure option)
2005-09-29
Revised phase space generation code, in particular for flavor sums
Negative cut and histogram codes use initial beams instead of
initial parton momenta. This allows for computing, e.g., E_miss
Support constant-width and zero-width options for O'Mega
Width options now denoted by w:X (X=f,c,z). f option obsolescent
Bug fix: colorized code: flipped indices could screw up result
Bug fix: O'Mega with 'c' and 'w:f' option together (still some problem)
Bug fix: dvips on systems where dvips defaults to lpr
Bug fix: integer overflow if too many events are requested
2005-07-29
Allow for 2 -> 1 processes (if structure functions are on)
2005-07-26
Fixed and expanded the 'test' matrix element:
Unit matrix element with option 'u' / default: normalized phase space
##################################################################
2005-07-15
RELEASE: version 1.41
Bug fix: no result for particle decay processes with width=0
Bug fix: line breaks in O'Mega files with color decomposition
2005-06-02
New self-tests (make test-QED / test-QCD / test-SM)
check lists of 2->2 processes
Bug fix: HELAS calling convention for wwwwxx and jwwwxx (4W-Vertex)
2005-05-25
Revised Makefile structure
Eliminated obsolete references to ISAJET/SUSY (superseded by SLHA)
2005-05-19
Support for color in O'Mega (using color flow decomposition)
New model QCD
Parameter file changes that correspond to replaced SM module in O'Mega
Bug fixes in MSSM (O'Mega) parameter file
2005-05-18
New event file formats, useful for LHC applications:
ATHENA and Les Houches Accord (external fragmentation)
Naive (i.e., leading 1/N) color factor now implemented both for
incoming and outgoing partons
2005-01-26
include missing HELAS files for bundle
pgf90 compatibility issues [note: still internal error in pgf90]
##################################################################
2004-12-13
RELEASE: version 1.40
compatibility fix: preprocessor marks in helas code now commented out
minor bug fix: format string in madgraph source
2004-12-03
support for arbitray beam energies and directions
allow for pT kick in structure functions
bug fix: rounding error could result in zero cross section
(compiler-dependent)
2004-10-07
simulate decay processes
list fraction (of total width/cross section) instead of efficiency
in process summary
new cut/analysis parameters AA, AAD, CTA: absolute polar angle
2004-10-04
Replaced Madgraph I by Madgraph II. Main improvement: model no
longer hardcoded
introduced parameter reset_seed_each_process (useful for debugging)
bug fix: color initialization for some processes was undefined
2004-09-21
don't compile unix_args module if it is not required
##################################################################
2004-09-20
RELEASE: version 1.30
g95 compatibility issues resolved
some (irrelevant) memory leaks closed
removed obsolete warning in circe1
manual update (essentially) finished
2004-08-03
O'Mega RELEASE: version 0.9
O'Mega, src/trie.mli, src/trie.ml: make interface compatible with
the O'Caml 3.08 library (remains compatible with older
versions). Implementation of unused functions still
incomplete.
2004-07-26
minor fixes and improvements in make process
2004-06-29
workarounds for new Intel compiler bugs ...
no rebuild of madgraph/comphep executables after 'make clean'
bug fix in phase space routine:
wrong energy for massive initial particles
bug fix in (new) model interface: name checks for antiparticles
pre-run checks for comphep improved
ww-strong model file extended
Model files particle name fixes, chep SM vertices included
2004-06-22
O'Mega RELEASE: version 0.8
O'Mega MSSM: sign of W+/W-/A and W+/W-/Z couplings
2004-05-05
Fixed bug in PDFLIB interface: p+pbar was initialized as p+p (ThO)
NAG compiler: set number of continuation lines to 200 as default
Extended format for cross section summary; appears now in whizard.out
Fixed 'bundle' feature
2004-04-28
Fixed compatibility with revised O'Mega SM_ac model
Fixed problem with x=0 or x=1 when calling PDFLIB (ThO)
Fixed bug in comphep module: Vtb was overlooked
##################################################################
2004-04-15
RELEASE: version 1.28
Fixed bug: Color factor was missing for O'Mega processes with
four quarks and more
Manual partially updated
2004-04-08
Support for grid files in binary format
New default value show_histories=F (reduce output file size)
Revised phase space switches: removed annihilation_lines,
removed s_channel_resonance, changed meaning of
extra_off_shell_lines, added show_deleted_channels
Bug fixed which lead to omission of some phase space channels
Color flow guessed only if requested by guess_color_flow
2004-03-10
New model interface: Only one model name specified in whizard.prc
All model-dependent files reside in conf/models (modellib removed)
2004-03-03
Support for input/output in SUSY Les Houches Accord format
Split event files if requested
Support for overall time limit
Support for CIRCE and CIRCE2 generator mode
Support for reading beam events from file
2004-02-05
Fixed compiler problems with Intel Fortran 7.1 and 8.0
Support for catching signals
##################################################################
2003-08-06
RELEASE: version 1.27
User-defined PDF libraries as an alternative to the standard PDFLIB
2003-07-23
Revised phase space module: improved mappings for massless particles,
equivalences of phase space channels are exploited
Improved mapping for PDF (hadron colliders)
Madgraph module: increased max number of color flows from 250 to 1000
##################################################################
2003-06-23
RELEASE: version 1.26
CIRCE2 support
Fixed problem with 'TC' integer kind [Intel compiler complained]
2003-05-28
Support for drawing histograms of grids
Bug fixes for MSSM definitions
##################################################################
2003-05-22
RELEASE: version 1.25
Experimental MSSM support with ISAJET interface
Improved capabilities of generating/analyzing weighted events
Optional drawing phase space diagrams using FeynMF
##################################################################
2003-01-31
RELEASE: version 1.24
A few more fixes and workarounds (Intel and Lahey compiler)
2003-01-15
Fixes and workarounds needed for WHIZARD to run with Intel compiler
Command-line option interface for the Lahey compiler
Bug fix: problem with reading whizard.phs
##################################################################
2002-12-10
RELEASE: version 1.23
Command-line options (on some systems)
Allow for initial particles in the event record, ordered:
[beams, initials] - [remnants] - outgoing partons
Support for PYTHIA 6.2: Les Houches external process interface
String pythia_parameters can be up to 1000 characters long
Select color flow states in (internal) analysis
Bug fix in color flow content of raw event files
Support for transversal polarization of fermion beams
Cut codes: PHI now for absolute azimuthal angle, DPHI for distance
'Test' matrix elements optionally respect polarization
User-defined code can be inserted for spectra, structure functions
and fragmentation
Time limits can be specified for adaptation and simulation
User-defined file names and file directory
Initial weights in input file no longer supported
Bug fix in MadGraph (wave function counter could overflow)
Bug fix: Gamelan (graphical analysis) was not built if noweb absent
##################################################################
2002-03-16
RELEASE: version 1.22
Allow for beam remnants in the event record
2002-03-01
Handling of aliases in whizard.prc fixed (aliases are whole tokens)
2002-02-28
Optimized phase space handling routines
(total execution time reduced by 20-60%, depending on process)
##################################################################
2002-02-26
RELEASE: version 1.21
Fixed ISR formula (ISR was underestimated in previous versions).
New version includes ISR in leading-log approximation up to
third order. Parameter ISR_sqrts renamed to ISR_scale.
##################################################################
2002-02-19
RELEASE: version 1.20
New process-generating method 'test' (dummy matrix element)
Compatibility with autoconf 2.50 and current O'Mega version
2002-02-05
Prevent integration channels from being dropped (optionally)
New internal mapping for structure functions improves performance
Old whizard.phx file deleted after recompiling (could cause trouble)
2002-01-24
Support for user-defined cuts and matrix element reweighting
STDHEP output now written by write_events_format=20 (was 3)
2002-01-16
Improved structure function handling; small changes in user interface:
new parameter structured_beams in &process_input
parameter fixed_energy in &beam_input removed
Support for multiple initial states
Eta-phi (cone) cut possible (hadron collider applications)
Fixed bug: Whizard library was not always recompiled when necessary
Fixed bug: Default cuts were insufficient in some cases
Fixed bug: Unusable phase space mappings generated in some cases
2001-12-06
Reorganized document source
2001-12-05
Preliminary CIRCE2 support (no functionality yet)
2001-11-27
Intel compiler support (does not yet work because of compiler bugs)
New cut and analysis mode cos-theta* and related
Fixed circular jetset_interface dependency warning
Some broadcast routines removed (parallel support disabled anyway)
Minor shifts in cleanup targets (Makefiles)
Modified library search, check for pdflib8*
2001-08-06
Fixed bug: I/O unit number could be undefined when reading phase space
Fixed bug: Unitialized variable could cause segfault when
event generation was disabled
Fixed bug: Undefined subroutine in CIRCE replacement module
Enabled feature: TGCs in O'Mega (not yet CompHEP!) matrix elements
(CompHEP model sm-GF #5, O'Mega model SM_ac)
Fixed portability issue: Makefile did rely on PWD environment variable
Fixed portability issue: PYTHIA library search ambiguity resolved
2001-08-01
Default whizard.prc and whizard.in depend on activated modules
Fixed bug: TEX=latex was not properly enabled when making plots
2001-07-20
Fixed output settings in PERL script calls
Cache enabled in various configure checks
2001-07-13
Support for multiple processes in a single WHIZARD run. The
integrations are kept separate, but the generated events are mixed
The whizard.evx format has changed (incompatible), including now
the color flow information for PYTHIA fragmentation
Output files are now process-specific, except for the event file
Phase space file whizard.phs (if present) is used only as input,
program-generated phase space is now in whizard.phx
2001-07-10
Bug fix: Undefined parameters in parameters_SM_ac.f90 removed
2001-07-04
Bug fix: Compiler options for the case OMEGA is disabled
Small inconsistencies in whizard.out format fixed
2001-07-01
Workaround for missing PDFLIB dummy routines in PYTHIA library
##################################################################
2001-06-30
RELEASE: version 1.13
Default path /cern/pro/lib in configure script
2001-06-20
New fragmentation option: Interface for PYTHIA with full color flow
information, beam remnants etc.
2001-06-18
Severe bug fixed in madgraph interface: 3-gluon coupling was missing
Enabled color flow information in madgraph
2001-06-11
VAMP interface module rewritten
Revised output format: Multiple VAMP iterations count as one WHIZARD
iteration in integration passes 1 and 3
Improved message and error handling
Bug fix in VAMP: handle exceptional cases in rebinning_weights
2001-05-31
new parameters for grid adaptation: accuracy_goal and efficiency_goal
##################################################################
2001-05-29
RELEASE: version 1.12
bug fixes (compilation problems): deleted/modified unused functions
2001-05-16
diagram selection improved and documented
2001-05-06
allow for disabling packages during configuration
2001-05-03
slight changes in whizard.out format; manual extended
##################################################################
2001-04-20
RELEASE: version 1.11
fixed some configuration and compilation problems (PDFLIB etc.)
2001-04-18
linked PDFLIB: support for quark/gluon structure functions
2001-04-05
parameter interface written by PERL script
SM_ac model file: fixed error in continuation line
2001-03-13
O'Mega, O'Caml 3.01: incompatible changes
O'Mega, src/trie.mli: add covariance annotation to T.t
This breaks O'Caml 3.00, but is required for O'Caml 3.01.
O'Mega, many instances: replace `sig include Module.T end' by
`Module.T', since the bug is fixed in O'Caml 3.01
2001-02-28
O'Mega, src/model.mli:
new field Model.vertices required for model functors, will
retire Model.fuse2, Model.fuse3, Model.fusen soon.
##################################################################
2001-03-27
RELEASE: version 1.10
reorganized the modules as libraries
linked PYTHIA: support for parton fragmentation
2000-12-14
fixed some configuration problems (if noweb etc. are absent)
##################################################################
2000-12-01
RELEASE of first public version: version 1.00beta
Index: trunk/src/whizard-core/whizard.nw
===================================================================
--- trunk/src/whizard-core/whizard.nw (revision 8482)
+++ trunk/src/whizard-core/whizard.nw (revision 8483)
@@ -1,29181 +1,29174 @@
% -*- ess-noweb-default-code-mode: f90-mode; noweb-default-code-mode: f90-mode; -*-
% WHIZARD main code as NOWEB source
\includemodulegraph{whizard-core}
\chapter{Integration and Simulation}
@
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{User-controlled File I/O}
The SINDARIN language includes commands that write output to file (input may
be added later). We identify files by their name, and manage the unit
internally. We need procedures for opening, closing, and printing files.
<<[[user_files.f90]]>>=
<<File header>>
module user_files
<<Use strings>>
use io_units
use diagnostics
use ifiles
use analysis
<<Standard module head>>
<<User files: public>>
<<User files: types>>
<<User files: interfaces>>
contains
<<User files: procedures>>
end module user_files
@ %def user_files
@
\subsection{The file type}
This is a type that describes an open user file and its properties. The entry
is part of a doubly-linked list.
<<User files: types>>=
type :: file_t
private
type(string_t) :: name
integer :: unit = -1
logical :: reading = .false.
logical :: writing = .false.
type(file_t), pointer :: prev => null ()
type(file_t), pointer :: next => null ()
end type file_t
@ %def file_t
@ The initializer opens the file.
<<User files: procedures>>=
subroutine file_init (file, name, action, status, position)
type(file_t), intent(out) :: file
type(string_t), intent(in) :: name
character(len=*), intent(in) :: action, status, position
file%unit = free_unit ()
file%name = name
open (unit = file%unit, file = char (file%name), &
action = action, status = status, position = position)
select case (action)
case ("read")
file%reading = .true.
case ("write")
file%writing = .true.
case ("readwrite")
file%reading = .true.
file%writing = .true.
end select
end subroutine file_init
@ %def file_init
@ The finalizer closes it.
<<User files: procedures>>=
subroutine file_final (file)
type(file_t), intent(inout) :: file
close (unit = file%unit)
file%unit = -1
end subroutine file_final
@ %def file_final
@ Check if a file is open with correct status.
<<User files: procedures>>=
function file_is_open (file, action) result (flag)
logical :: flag
type(file_t), intent(in) :: file
character(*), intent(in) :: action
select case (action)
case ("read")
flag = file%reading
case ("write")
flag = file%writing
case ("readwrite")
flag = file%reading .and. file%writing
case default
call msg_bug ("Checking file '" // char (file%name) &
// "': illegal action specifier")
end select
end function file_is_open
@ %def file_is_open
@ Return the unit number of a file for direct access. It should be checked
first whether the file is open.
<<User files: procedures>>=
function file_get_unit (file) result (unit)
integer :: unit
type(file_t), intent(in) :: file
unit = file%unit
end function file_get_unit
@ %def file_get_unit
@ Write to the file. Error if in wrong mode. If there is no string, just
write an empty record. If there is a string, respect the [[advancing]]
option.
<<User files: procedures>>=
subroutine file_write_string (file, string, advancing)
type(file_t), intent(in) :: file
type(string_t), intent(in), optional :: string
logical, intent(in), optional :: advancing
if (file%writing) then
if (present (string)) then
if (present (advancing)) then
if (advancing) then
write (file%unit, "(A)") char (string)
else
write (file%unit, "(A)", advance="no") char (string)
end if
else
write (file%unit, "(A)") char (string)
end if
else
write (file%unit, *)
end if
else
call msg_error ("Writing to file: File '" // char (file%name) &
// "' is not open for writing.")
end if
end subroutine file_write_string
@ %def file_write
@ Write a whole ifile, line by line.
<<User files: procedures>>=
subroutine file_write_ifile (file, ifile)
type(file_t), intent(in) :: file
type(ifile_t), intent(in) :: ifile
type(line_p) :: line
call line_init (line, ifile)
do while (line_is_associated (line))
call file_write_string (file, line_get_string_advance (line))
end do
end subroutine file_write_ifile
@ %def file_write_ifile
@ Write an analysis object (or all objects) to an open file.
<<User files: procedures>>=
subroutine file_write_analysis (file, tag)
type(file_t), intent(in) :: file
type(string_t), intent(in), optional :: tag
if (file%writing) then
if (present (tag)) then
call analysis_write (tag, unit = file%unit)
else
call analysis_write (unit = file%unit)
end if
else
call msg_error ("Writing analysis to file: File '" // char (file%name) &
// "' is not open for writing.")
end if
end subroutine file_write_analysis
@ %def file_write_analysis
@
\subsection{The file list}
We maintain a list of all open files and their attributes. The list must be
doubly-linked because we may delete entries.
<<User files: public>>=
public :: file_list_t
<<User files: types>>=
type :: file_list_t
type(file_t), pointer :: first => null ()
type(file_t), pointer :: last => null ()
end type file_list_t
@ %def file_list_t
@ There is no initialization routine, but a finalizer which deletes all:
<<User files: public>>=
public :: file_list_final
<<User files: procedures>>=
subroutine file_list_final (file_list)
type(file_list_t), intent(inout) :: file_list
type(file_t), pointer :: current
do while (associated (file_list%first))
current => file_list%first
file_list%first => current%next
call file_final (current)
deallocate (current)
end do
file_list%last => null ()
end subroutine file_list_final
@ %def file_list_final
@ Find an entry in the list. Return null pointer on failure.
<<User files: procedures>>=
function file_list_get_file_ptr (file_list, name) result (current)
type(file_t), pointer :: current
type(file_list_t), intent(in) :: file_list
type(string_t), intent(in) :: name
current => file_list%first
do while (associated (current))
if (current%name == name) return
current => current%next
end do
end function file_list_get_file_ptr
@ %def file_list_get_file_ptr
@ Check if a file is open, public version:
<<User files: public>>=
public :: file_list_is_open
<<User files: procedures>>=
function file_list_is_open (file_list, name, action) result (flag)
logical :: flag
type(file_list_t), intent(in) :: file_list
type(string_t), intent(in) :: name
character(len=*), intent(in) :: action
type(file_t), pointer :: current
current => file_list_get_file_ptr (file_list, name)
if (associated (current)) then
flag = file_is_open (current, action)
else
flag = .false.
end if
end function file_list_is_open
@ %def file_list_is_open
@ Return the unit number for a file. It should be checked first whether the
file is open.
<<User files: public>>=
public :: file_list_get_unit
<<User files: procedures>>=
function file_list_get_unit (file_list, name) result (unit)
integer :: unit
type(file_list_t), intent(in) :: file_list
type(string_t), intent(in) :: name
type(file_t), pointer :: current
current => file_list_get_file_ptr (file_list, name)
if (associated (current)) then
unit = file_get_unit (current)
else
unit = -1
end if
end function file_list_get_unit
@ %def file_list_get_unit
@ Append a new file entry, i.e., open this file. Error if it is
already open.
<<User files: public>>=
public :: file_list_open
<<User files: procedures>>=
subroutine file_list_open (file_list, name, action, status, position)
type(file_list_t), intent(inout) :: file_list
type(string_t), intent(in) :: name
character(len=*), intent(in) :: action, status, position
type(file_t), pointer :: current
if (.not. associated (file_list_get_file_ptr (file_list, name))) then
allocate (current)
call msg_message ("Opening file '" // char (name) // "' for output")
call file_init (current, name, action, status, position)
if (associated (file_list%last)) then
file_list%last%next => current
current%prev => file_list%last
else
file_list%first => current
end if
file_list%last => current
else
call msg_error ("Opening file: File '" // char (name) &
// "' is already open.")
end if
end subroutine file_list_open
@ %def file_list_open
@ Delete a file entry, i.e., close this file. Error if it is not open.
<<User files: public>>=
public :: file_list_close
<<User files: procedures>>=
subroutine file_list_close (file_list, name)
type(file_list_t), intent(inout) :: file_list
type(string_t), intent(in) :: name
type(file_t), pointer :: current
current => file_list_get_file_ptr (file_list, name)
if (associated (current)) then
if (associated (current%prev)) then
current%prev%next => current%next
else
file_list%first => current%next
end if
if (associated (current%next)) then
current%next%prev => current%prev
else
file_list%last => current%prev
end if
call msg_message ("Closing file '" // char (name) // "' for output")
call file_final (current)
deallocate (current)
else
call msg_error ("Closing file: File '" // char (name) &
// "' is not open.")
end if
end subroutine file_list_close
@ %def file_list_close
@ Write a string to file. Error if it is not open.
<<User files: public>>=
public :: file_list_write
<<User files: interfaces>>=
interface file_list_write
module procedure file_list_write_string
module procedure file_list_write_ifile
end interface
<<User files: procedures>>=
subroutine file_list_write_string (file_list, name, string, advancing)
type(file_list_t), intent(in) :: file_list
type(string_t), intent(in) :: name
type(string_t), intent(in), optional :: string
logical, intent(in), optional :: advancing
type(file_t), pointer :: current
current => file_list_get_file_ptr (file_list, name)
if (associated (current)) then
call file_write_string (current, string, advancing)
else
call msg_error ("Writing to file: File '" // char (name) &
// "'is not open.")
end if
end subroutine file_list_write_string
subroutine file_list_write_ifile (file_list, name, ifile)
type(file_list_t), intent(in) :: file_list
type(string_t), intent(in) :: name
type(ifile_t), intent(in) :: ifile
type(file_t), pointer :: current
current => file_list_get_file_ptr (file_list, name)
if (associated (current)) then
call file_write_ifile (current, ifile)
else
call msg_error ("Writing to file: File '" // char (name) &
// "'is not open.")
end if
end subroutine file_list_write_ifile
@ %def file_list_write
@ Write an analysis object or all objects to data file. Error if it is not
open. If the file name is empty, write to standard output.
<<User files: public>>=
public :: file_list_write_analysis
<<User files: procedures>>=
subroutine file_list_write_analysis (file_list, name, tag)
type(file_list_t), intent(in) :: file_list
type(string_t), intent(in) :: name
type(string_t), intent(in), optional :: tag
type(file_t), pointer :: current
if (name == "") then
if (present (tag)) then
call analysis_write (tag)
else
call analysis_write
end if
else
current => file_list_get_file_ptr (file_list, name)
if (associated (current)) then
call file_write_analysis (current, tag)
else
call msg_error ("Writing analysis to file: File '" // char (name) &
// "' is not open.")
end if
end if
end subroutine file_list_write_analysis
@ %def file_list_write_analysis
@
\clearpage
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{Runtime data}
<<[[rt_data.f90]]>>=
<<File header>>
module rt_data
<<Use kinds>>
<<Use strings>>
use io_units
use format_utils, only: write_separator
use format_defs, only: FMT_19, FMT_12
use system_dependencies
use diagnostics
use os_interface
use lexers
use parser
use models
use subevents
use pdg_arrays
use variables, only: var_list_t
use process_libraries
use prclib_stacks
use prc_core, only: helicity_selection_t
use beam_structures
use event_base, only: event_callback_t
use user_files
use process_stacks
use iterations
<<Standard module head>>
<<RT data: public>>
<<RT data: types>>
contains
<<RT data: procedures>>
end module rt_data
@ %def rt_data
@
\subsection{Strategy for models and variables}
The program manages its data via a main [[rt_data_t]] object. During program
flow, various commands create and use local [[rt_data_t]] objects. Those
transient blocks contain either pointers to global object or local copies
which are deleted after use.
Each [[rt_data_t]] object contains a variable list component. This lists
holds (local copies of) all kinds of intrinsic or user-defined variables. The
variable list is linked to the variable list contained in the local process
library. This, in turn, is linked to the variable list of the [[rt_data_t]]
context, and so on.
A variable lookup will thus be recursively delegated to the linked variable
lists, until a match is found. When modifying a variable which is not yet
local, the program creates a local copy and uses this afterwards. Thus, when
the local [[rt_data_t]] object is deleted, the context value is recovered.
Models are kept in a model list which is separate from the variable list.
Otherwise, they are treated in a similar manner: the local list is linked to
the context model list. Model lookup is thus recursively delegated. When a
model or any part of it is modified, the model is copied to the local
[[rt_data_t]] object, so the context model is not modified. Commands such as
[[integrate]] will create their own copy of the current model (and of the
current variable list) at the point where they are executed.
When a model is encountered for the first time, it is read from file. The
reading is automatically delegated to the global context. Thus, this master
copy survives until the main [[rt_data_t]] object is deleted, at program
completion.
If there is a currently active model, its variable list is linked to the main
variable list. Variable lookups will then start from the model variable
list. When the current model is switched, the new active model will get this
link instead. Consequently, a change to the current model is kept as long as
this model has a local copy; it survives local model switches. On the other
hand, a parameter change in the current model doesn't affect any other model,
even if the parameter name is identical.
@
\subsection{Container for parse nodes}
The runtime data set contains a bunch of parse nodes (chunks of code
that have not been compiled into evaluation trees but saved for later
use). We collect them here.
This implementation has the useful effect that an assignment between two
objects of this type will establish a pointer-target relationship for
all components.
<<RT data: types>>=
type :: rt_parse_nodes_t
type(parse_node_t), pointer :: cuts_lexpr => null ()
type(parse_node_t), pointer :: scale_expr => null ()
type(parse_node_t), pointer :: fac_scale_expr => null ()
type(parse_node_t), pointer :: ren_scale_expr => null ()
type(parse_node_t), pointer :: weight_expr => null ()
type(parse_node_t), pointer :: selection_lexpr => null ()
type(parse_node_t), pointer :: reweight_expr => null ()
type(parse_node_t), pointer :: analysis_lexpr => null ()
type(parse_node_p), dimension(:), allocatable :: alt_setup
contains
<<RT data: rt parse nodes: TBP>>
end type rt_parse_nodes_t
@ %def rt_parse_nodes_t
@ Clear individual components. The parse nodes are nullified. No
finalization needed since the pointer targets are part of the global
parse tree.
<<RT data: rt parse nodes: TBP>>=
procedure :: clear => rt_parse_nodes_clear
<<RT data: procedures>>=
subroutine rt_parse_nodes_clear (rt_pn, name)
class(rt_parse_nodes_t), intent(inout) :: rt_pn
type(string_t), intent(in) :: name
select case (char (name))
case ("cuts")
rt_pn%cuts_lexpr => null ()
case ("scale")
rt_pn%scale_expr => null ()
case ("factorization_scale")
rt_pn%fac_scale_expr => null ()
case ("renormalization_scale")
rt_pn%ren_scale_expr => null ()
case ("weight")
rt_pn%weight_expr => null ()
case ("selection")
rt_pn%selection_lexpr => null ()
case ("reweight")
rt_pn%reweight_expr => null ()
case ("analysis")
rt_pn%analysis_lexpr => null ()
end select
end subroutine rt_parse_nodes_clear
@ %def rt_parse_nodes_clear
@ Output for the parse nodes.
<<RT data: rt parse nodes: TBP>>=
procedure :: write => rt_parse_nodes_write
<<RT data: procedures>>=
subroutine rt_parse_nodes_write (object, unit)
class(rt_parse_nodes_t), intent(in) :: object
integer, intent(in), optional :: unit
integer :: u, i
u = given_output_unit (unit)
call wrt ("Cuts", object%cuts_lexpr)
call write_separator (u)
call wrt ("Scale", object%scale_expr)
call write_separator (u)
call wrt ("Factorization scale", object%fac_scale_expr)
call write_separator (u)
call wrt ("Renormalization scale", object%ren_scale_expr)
call write_separator (u)
call wrt ("Weight", object%weight_expr)
call write_separator (u, 2)
call wrt ("Event selection", object%selection_lexpr)
call write_separator (u)
call wrt ("Event reweighting factor", object%reweight_expr)
call write_separator (u)
call wrt ("Event analysis", object%analysis_lexpr)
if (allocated (object%alt_setup)) then
call write_separator (u, 2)
write (u, "(1x,A,':')") "Alternative setups"
do i = 1, size (object%alt_setup)
call write_separator (u)
call wrt ("Commands", object%alt_setup(i)%ptr)
end do
end if
contains
subroutine wrt (title, pn)
character(*), intent(in) :: title
type(parse_node_t), intent(in), pointer :: pn
if (associated (pn)) then
write (u, "(1x,A,':')") title
call write_separator (u)
call parse_node_write_rec (pn, u)
else
write (u, "(1x,A,':',1x,A)") title, "[undefined]"
end if
end subroutine wrt
end subroutine rt_parse_nodes_write
@ %def rt_parse_nodes_write
@ Screen output for individual components. (This should eventually be more
condensed, currently we print the internal representation tree.)
<<RT data: rt parse nodes: TBP>>=
procedure :: show => rt_parse_nodes_show
<<RT data: procedures>>=
subroutine rt_parse_nodes_show (rt_pn, name, unit)
class(rt_parse_nodes_t), intent(in) :: rt_pn
type(string_t), intent(in) :: name
integer, intent(in), optional :: unit
type(parse_node_t), pointer :: pn
integer :: u
u = given_output_unit (unit)
select case (char (name))
case ("cuts")
pn => rt_pn%cuts_lexpr
case ("scale")
pn => rt_pn%scale_expr
case ("factorization_scale")
pn => rt_pn%fac_scale_expr
case ("renormalization_scale")
pn => rt_pn%ren_scale_expr
case ("weight")
pn => rt_pn%weight_expr
case ("selection")
pn => rt_pn%selection_lexpr
case ("reweight")
pn => rt_pn%reweight_expr
case ("analysis")
pn => rt_pn%analysis_lexpr
end select
if (associated (pn)) then
write (u, "(A,1x,A,1x,A)") "Expression:", char (name), "(parse tree):"
call parse_node_write_rec (pn, u)
else
write (u, "(A,1x,A,A)") "Expression:", char (name), ": [undefined]"
end if
end subroutine rt_parse_nodes_show
@ %def rt_parse_nodes_show
@
\subsection{The data type}
This is a big data container which contains everything that is used and
modified during the command flow. A local copy of this can be used to
temporarily override defaults. The data set is transparent.
<<RT data: public>>=
public :: rt_data_t
<<RT data: types>>=
type :: rt_data_t
type(lexer_t), pointer :: lexer => null ()
type(rt_data_t), pointer :: context => null ()
type(string_t), dimension(:), allocatable :: export
type(var_list_t) :: var_list
type(iterations_list_t) :: it_list
type(os_data_t) :: os_data
type(model_list_t) :: model_list
type(model_t), pointer :: model => null ()
logical :: model_is_copy = .false.
type(model_t), pointer :: preload_model => null ()
type(model_t), pointer :: fallback_model => null ()
type(prclib_stack_t) :: prclib_stack
type(process_library_t), pointer :: prclib => null ()
type(beam_structure_t) :: beam_structure
type(rt_parse_nodes_t) :: pn
type(process_stack_t) :: process_stack
type(string_t), dimension(:), allocatable :: sample_fmt
class(event_callback_t), allocatable :: event_callback
type(file_list_t), pointer :: out_files => null ()
logical :: quit = .false.
integer :: quit_code = 0
type(string_t) :: logfile
logical :: nlo_fixed_order = .false.
logical, dimension(0:5) :: selected_nlo_parts = .false.
integer, dimension(:), allocatable :: nlo_component
contains
<<RT data: rt data: TBP>>
end type rt_data_t
@ %def rt_data_t
@
\subsection{Output}
<<RT data: rt data: TBP>>=
procedure :: write => rt_data_write
<<RT data: procedures>>=
subroutine rt_data_write (object, unit, vars, pacify)
class(rt_data_t), intent(in) :: object
integer, intent(in), optional :: unit
type(string_t), dimension(:), intent(in), optional :: vars
logical, intent(in), optional :: pacify
integer :: u, i
u = given_output_unit (unit)
call write_separator (u, 2)
write (u, "(1x,A)") "Runtime data:"
if (object%get_n_export () > 0) then
call write_separator (u, 2)
write (u, "(1x,A)") "Exported objects and variables:"
call write_separator (u)
call object%write_exports (u)
end if
if (present (vars)) then
if (size (vars) /= 0) then
call write_separator (u, 2)
write (u, "(1x,A)") "Selected variables:"
call write_separator (u)
call object%write_vars (u, vars)
end if
else
call write_separator (u, 2)
if (associated (object%model)) then
call object%model%write_var_list (u, follow_link=.true.)
else
call object%var_list%write (u, follow_link=.true.)
end if
end if
if (object%it_list%get_n_pass () > 0) then
call write_separator (u, 2)
write (u, "(1x)", advance="no")
call object%it_list%write (u)
end if
if (associated (object%model)) then
call write_separator (u, 2)
call object%model%write (u)
end if
call object%prclib_stack%write (u)
call object%beam_structure%write (u)
call write_separator (u, 2)
call object%pn%write (u)
if (allocated (object%sample_fmt)) then
call write_separator (u)
write (u, "(1x,A)", advance="no") "Event sample formats = "
do i = 1, size (object%sample_fmt)
if (i > 1) write (u, "(A,1x)", advance="no") ","
write (u, "(A)", advance="no") char (object%sample_fmt(i))
end do
write (u, "(A)")
end if
call write_separator (u)
write (u, "(1x,A)", advance="no") "Event callback:"
if (allocated (object%event_callback)) then
call object%event_callback%write (u)
else
write (u, "(1x,A)") "[undefined]"
end if
call object%process_stack%write (u, pacify)
write (u, "(1x,A,1x,L1)") "quit :", object%quit
write (u, "(1x,A,1x,I0)") "quit_code:", object%quit_code
call write_separator (u, 2)
write (u, "(1x,A,1x,A)") "Logfile :", "'" // trim (char (object%logfile)) // "'"
call write_separator (u, 2)
end subroutine rt_data_write
@ %def rt_data_write
@ Write only selected variables.
<<RT data: rt data: TBP>>=
procedure :: write_vars => rt_data_write_vars
<<RT data: procedures>>=
subroutine rt_data_write_vars (object, unit, vars)
class(rt_data_t), intent(in), target :: object
integer, intent(in), optional :: unit
type(string_t), dimension(:), intent(in) :: vars
type(var_list_t), pointer :: var_list
integer :: u, i
u = given_output_unit (unit)
var_list => object%get_var_list_ptr ()
do i = 1, size (vars)
associate (var => vars(i))
if (var_list%contains (var, follow_link=.true.)) then
call var_list%write_var (var, unit = u, &
follow_link = .true., defined=.true.)
end if
end associate
end do
end subroutine rt_data_write_vars
@ %def rt_data_write_vars
@ Write only the model list.
<<RT data: rt data: TBP>>=
procedure :: write_model_list => rt_data_write_model_list
<<RT data: procedures>>=
subroutine rt_data_write_model_list (object, unit)
class(rt_data_t), intent(in) :: object
integer, intent(in), optional :: unit
integer :: u
u = given_output_unit (unit)
call object%model_list%write (u)
end subroutine rt_data_write_model_list
@ %def rt_data_write_model_list
@ Write only the library stack.
<<RT data: rt data: TBP>>=
procedure :: write_libraries => rt_data_write_libraries
<<RT data: procedures>>=
subroutine rt_data_write_libraries (object, unit, libpath)
class(rt_data_t), intent(in) :: object
integer, intent(in), optional :: unit
logical, intent(in), optional :: libpath
integer :: u
u = given_output_unit (unit)
call object%prclib_stack%write (u, libpath)
end subroutine rt_data_write_libraries
@ %def rt_data_write_libraries
@ Write only the beam data.
<<RT data: rt data: TBP>>=
procedure :: write_beams => rt_data_write_beams
<<RT data: procedures>>=
subroutine rt_data_write_beams (object, unit)
class(rt_data_t), intent(in) :: object
integer, intent(in), optional :: unit
integer :: u
u = given_output_unit (unit)
call write_separator (u, 2)
call object%beam_structure%write (u)
call write_separator (u, 2)
end subroutine rt_data_write_beams
@ %def rt_data_write_beams
@ Write only the process and event expressions.
<<RT data: rt data: TBP>>=
procedure :: write_expr => rt_data_write_expr
<<RT data: procedures>>=
subroutine rt_data_write_expr (object, unit)
class(rt_data_t), intent(in) :: object
integer, intent(in), optional :: unit
integer :: u
u = given_output_unit (unit)
call write_separator (u, 2)
call object%pn%write (u)
call write_separator (u, 2)
end subroutine rt_data_write_expr
@ %def rt_data_write_expr
@ Write only the process stack.
<<RT data: rt data: TBP>>=
procedure :: write_process_stack => rt_data_write_process_stack
<<RT data: procedures>>=
subroutine rt_data_write_process_stack (object, unit)
class(rt_data_t), intent(in) :: object
integer, intent(in), optional :: unit
call object%process_stack%write (unit)
end subroutine rt_data_write_process_stack
@ %def rt_data_write_process_stack
@
<<RT data: rt data: TBP>>=
procedure :: write_var_descriptions => rt_data_write_var_descriptions
<<RT data: procedures>>=
subroutine rt_data_write_var_descriptions (rt_data, unit, ascii_output)
class(rt_data_t), intent(in) :: rt_data
integer, intent(in), optional :: unit
logical, intent(in), optional :: ascii_output
integer :: u
logical :: ao
u = given_output_unit (unit)
ao = .false.; if (present (ascii_output)) ao = ascii_output
call rt_data%var_list%write (u, follow_link=.true., &
descriptions=.true., ascii_output=ao)
end subroutine rt_data_write_var_descriptions
@ %def rt_data_write_var_descriptions
@
<<RT data: rt data: TBP>>=
procedure :: show_description_of_string => rt_data_show_description_of_string
<<RT data: procedures>>=
subroutine rt_data_show_description_of_string (rt_data, string, &
unit, ascii_output)
class(rt_data_t), intent(in) :: rt_data
type(string_t), intent(in) :: string
integer, intent(in), optional :: unit
logical, intent(in), optional :: ascii_output
integer :: u
logical :: ao
u = given_output_unit (unit)
ao = .false.; if (present (ascii_output)) ao = ascii_output
call rt_data%var_list%write_var (string, unit=u, follow_link=.true., &
defined=.false., descriptions=.true., ascii_output=ao)
end subroutine rt_data_show_description_of_string
@ %def rt_data_show_description_of_string
@
\subsection{Clear}
The [[clear]] command can remove the contents of various subobjects.
The objects themselves should stay.
<<RT data: rt data: TBP>>=
procedure :: clear_beams => rt_data_clear_beams
<<RT data: procedures>>=
subroutine rt_data_clear_beams (global)
class(rt_data_t), intent(inout) :: global
call global%beam_structure%final_sf ()
call global%beam_structure%final_pol ()
call global%beam_structure%final_mom ()
end subroutine rt_data_clear_beams
@ %def rt_data_clear_beams
@
\subsection{Initialization}
Initialize runtime data. This defines special variables such as
[[sqrts]], and should be done only for the instance that is actually
global. Local copies will inherit the special variables.
We link the global variable list to the process stack variable list,
so the latter is always available (and kept global).
<<RT data: rt data: TBP>>=
procedure :: global_init => rt_data_global_init
<<RT data: procedures>>=
subroutine rt_data_global_init (global, paths, logfile)
class(rt_data_t), intent(out), target :: global
type(paths_t), intent(in), optional :: paths
type(string_t), intent(in), optional :: logfile
integer :: seed
call global%os_data%init (paths)
if (present (logfile)) then
global%logfile = logfile
else
global%logfile = ""
end if
allocate (global%out_files)
call system_clock (seed)
call global%var_list%init_defaults (seed, paths)
call global%init_pointer_variables ()
call global%process_stack%init_var_list (global%var_list)
end subroutine rt_data_global_init
@ %def rt_data_global_init
@
\subsection{Local copies}
This is done at compile time when a local copy of runtime data is
needed: Link the variable list and initialize all derived parameters.
This allows for synchronizing them with local variable changes without
affecting global data.
Also re-initialize pointer variables, so they point to local copies of
their targets.
<<RT data: rt data: TBP>>=
procedure :: local_init => rt_data_local_init
<<RT data: procedures>>=
subroutine rt_data_local_init (local, global, env)
class(rt_data_t), intent(inout), target :: local
type(rt_data_t), intent(in), target :: global
integer, intent(in), optional :: env
local%context => global
call local%process_stack%link (global%process_stack)
call local%process_stack%init_var_list (local%var_list)
call local%process_stack%link_var_list (global%var_list)
call local%var_list%append_string (var_str ("$model_name"), &
var_str (""), intrinsic=.true.)
call local%init_pointer_variables ()
local%fallback_model => global%fallback_model
local%os_data = global%os_data
local%logfile = global%logfile
call local%model_list%link (global%model_list)
local%model => global%model
if (associated (local%model)) then
call local%model%link_var_list (local%var_list)
end if
if (allocated (global%event_callback)) then
allocate (local%event_callback, source = global%event_callback)
end if
end subroutine rt_data_local_init
@ %def rt_data_local_init
@ These variables point to objects which get local copies:
<<RT data: rt data: TBP>>=
procedure :: init_pointer_variables => rt_data_init_pointer_variables
<<RT data: procedures>>=
subroutine rt_data_init_pointer_variables (local)
class(rt_data_t), intent(inout), target :: local
logical, target, save :: known = .true.
call local%var_list%append_string_ptr (var_str ("$fc"), &
local%os_data%fc, known, intrinsic=.true., &
description=var_str('This string variable gives the ' // &
'\ttt{Fortran} compiler used within \whizard. It can ' // &
'only be accessed, not set by the user. (cf. also ' // &
'\ttt{\$fcflags}, \ttt{\$fclibs})'))
call local%var_list%append_string_ptr (var_str ("$fcflags"), &
local%os_data%fcflags, known, intrinsic=.true., &
description=var_str('This string variable gives the ' // &
'compiler flags for the \ttt{Fortran} compiler used ' // &
'within \whizard. It can only be accessed, not set by ' // &
'the user. (cf. also \ttt{\$fc}, \ttt{\$fclibs})'))
call local%var_list%append_string_ptr (var_str ("$fclibs"), &
local%os_data%fclibs, known, intrinsic=.true., &
description=var_str('This string variable gives the ' // &
'linked libraries for the \ttt{Fortran} compiler used ' // &
'within \whizard. It can only be accessed, not set by ' // &
'the user. (cf. also \ttt{\$fc}, \ttt{\$fcflags})'))
end subroutine rt_data_init_pointer_variables
@ %def rt_data_init_pointer_variables
@ This is done at execution time: Copy data, transfer pointers.
[[local]] has intent(inout) because its local variable list has
already been prepared by the previous routine.
To be pedantic, the local pointers to model and library should point
to the entries in the local copies. (However, as long as these are
just shallow copies with identical content, this is actually
irrelevant.)
The process library and process stacks behave as global objects. The
copies of the process library and process stacks should be shallow
copies, so the contents stay identical. Since objects may be pushed
on the stack in the local environment, upon restoring the global
environment, we should reverse the assignment. Then the added stack
elements will end up on the global stack. (This should be
reconsidered in a parallel environment.)
<<RT data: rt data: TBP>>=
procedure :: activate => rt_data_activate
<<RT data: procedures>>=
subroutine rt_data_activate (local)
class(rt_data_t), intent(inout), target :: local
class(rt_data_t), pointer :: global
global => local%context
if (associated (global)) then
local%lexer => global%lexer
call global%copy_globals (local)
local%os_data = global%os_data
local%logfile = global%logfile
if (associated (global%prclib)) then
local%prclib => &
local%prclib_stack%get_library_ptr (global%prclib%get_name ())
end if
call local%import_values ()
call local%process_stack%link (global%process_stack)
local%it_list = global%it_list
local%beam_structure = global%beam_structure
local%pn = global%pn
if (allocated (local%sample_fmt)) deallocate (local%sample_fmt)
if (allocated (global%sample_fmt)) then
allocate (local%sample_fmt (size (global%sample_fmt)), &
source = global%sample_fmt)
end if
local%out_files => global%out_files
local%model => global%model
local%model_is_copy = .false.
else if (.not. associated (local%model)) then
local%model => local%preload_model
local%model_is_copy = .false.
end if
if (associated (local%model)) then
call local%model%link_var_list (local%var_list)
call local%var_list%set_string (var_str ("$model_name"), &
local%model%get_name (), is_known = .true.)
else
call local%var_list%set_string (var_str ("$model_name"), &
var_str (""), is_known = .false.)
end if
end subroutine rt_data_activate
@ %def rt_data_activate
@ Restore the previous state of data, without actually finalizing the local
environment. We also clear the local process stack. Some local modifications
(model list and process library stack) are communicated to the global context,
if there is any.
If the [[keep_local]] flag is set, we want to retain current settings in
the local environment. In particular, we create an instance of the currently
selected model (which thus becomes separated from the model library!).
The local variables are also kept.
<<RT data: rt data: TBP>>=
procedure :: deactivate => rt_data_deactivate
<<RT data: procedures>>=
subroutine rt_data_deactivate (local, global, keep_local)
class(rt_data_t), intent(inout), target :: local
class(rt_data_t), intent(inout), optional, target :: global
logical, intent(in), optional :: keep_local
type(string_t) :: local_model, local_scheme
logical :: same_model, delete
delete = .true.; if (present (keep_local)) delete = .not. keep_local
if (present (global)) then
if (associated (global%model) .and. associated (local%model)) then
local_model = local%model%get_name ()
if (global%model%has_schemes ()) then
local_scheme = local%model%get_scheme ()
same_model = &
global%model%matches (local_model, local_scheme)
else
same_model = global%model%matches (local_model)
end if
else
same_model = .false.
end if
if (delete) then
call local%process_stack%clear ()
call local%unselect_model ()
call local%unset_values ()
else if (associated (local%model)) then
call local%ensure_model_copy ()
end if
if (.not. same_model .and. associated (global%model)) then
if (global%model%has_schemes ()) then
call msg_message ("Restoring model '" // &
char (global%model%get_name ()) // "', scheme '" // &
char (global%model%get_scheme ()) // "'")
else
call msg_message ("Restoring model '" // &
char (global%model%get_name ()) // "'")
end if
end if
if (associated (global%model)) then
call global%model%link_var_list (global%var_list)
end if
call global%restore_globals (local)
else
call local%unselect_model ()
end if
end subroutine rt_data_deactivate
@ %def rt_data_deactivate
@ This imports the global objects for which local modifications
should be kept. Currently, this is only the process library stack.
<<RT data: rt data: TBP>>=
procedure :: copy_globals => rt_data_copy_globals
<<RT data: procedures>>=
subroutine rt_data_copy_globals (global, local)
class(rt_data_t), intent(in) :: global
class(rt_data_t), intent(inout) :: local
local%prclib_stack = global%prclib_stack
end subroutine rt_data_copy_globals
@ %def rt_data_copy_globals
@ This restores global objects for which local modifications
should be kept. May also modify (remove) the local objects.
<<RT data: rt data: TBP>>=
procedure :: restore_globals => rt_data_restore_globals
<<RT data: procedures>>=
subroutine rt_data_restore_globals (global, local)
class(rt_data_t), intent(inout) :: global
class(rt_data_t), intent(inout) :: local
global%prclib_stack = local%prclib_stack
call local%handle_exports (global)
end subroutine rt_data_restore_globals
@ %def rt_data_restore_globals
@
\subsection{Exported objects}
Exported objects are transferred to the global state when a local environment
is closed. (For the top-level global data set, there is no effect.)
The current implementation handles only the [[results]] object, which resolves
to the local process stack. The stack elements are appended to the global
stack without modification, the local stack becomes empty.
Write names of objects to be exported:
<<RT data: rt data: TBP>>=
procedure :: write_exports => rt_data_write_exports
<<RT data: procedures>>=
subroutine rt_data_write_exports (rt_data, unit)
class(rt_data_t), intent(in) :: rt_data
integer, intent(in), optional :: unit
integer :: u, i
u = given_output_unit (unit)
do i = 1, rt_data%get_n_export ()
write (u, "(A)") char (rt_data%export(i))
end do
end subroutine rt_data_write_exports
@ %def rt_data_write_exports
@ The number of entries in the export list.
<<RT data: rt data: TBP>>=
procedure :: get_n_export => rt_data_get_n_export
<<RT data: procedures>>=
function rt_data_get_n_export (rt_data) result (n)
class(rt_data_t), intent(in) :: rt_data
integer :: n
if (allocated (rt_data%export)) then
n = size (rt_data%export)
else
n = 0
end if
end function rt_data_get_n_export
@ %def rt_data_get_n_export
@ Return a specific export
@ Append new names to the export list. If a duplicate occurs, do not transfer
it.
<<RT data: rt data: TBP>>=
procedure :: append_exports => rt_data_append_exports
<<RT data: procedures>>=
subroutine rt_data_append_exports (rt_data, export)
class(rt_data_t), intent(inout) :: rt_data
type(string_t), dimension(:), intent(in) :: export
logical, dimension(:), allocatable :: mask
type(string_t), dimension(:), allocatable :: tmp
integer :: i, j, n
if (.not. allocated (rt_data%export)) allocate (rt_data%export (0))
n = size (rt_data%export)
allocate (mask (size (export)), source=.false.)
do i = 1, size (export)
mask(i) = all (export(i) /= rt_data%export) &
.and. all (export(i) /= export(:i-1))
end do
if (count (mask) > 0) then
allocate (tmp (n + count (mask)))
tmp(1:n) = rt_data%export(:)
j = n
do i = 1, size (export)
if (mask(i)) then
j = j + 1
tmp(j) = export(i)
end if
end do
call move_alloc (from=tmp, to=rt_data%export)
end if
end subroutine rt_data_append_exports
@ %def rt_data_append_exports
@ Transfer export-objects from the [[local]] rt data to the [[global]] rt
data, as far as supported.
<<RT data: rt data: TBP>>=
procedure :: handle_exports => rt_data_handle_exports
<<RT data: procedures>>=
subroutine rt_data_handle_exports (local, global)
class(rt_data_t), intent(inout), target :: local
class(rt_data_t), intent(inout), target :: global
type(string_t) :: export
integer :: i
if (local%get_n_export () > 0) then
do i = 1, local%get_n_export ()
export = local%export(i)
select case (char (export))
case ("results")
call msg_message ("Exporting integration results &
&to outer environment")
call local%transfer_process_stack (global)
case default
call msg_bug ("handle exports: '" &
// char (export) // "' unsupported")
end select
end do
end if
end subroutine rt_data_handle_exports
@ %def rt_data_handle_exports
@ Export the process stack. One-by-one, take the last process from the local
stack and push it on the global stack. Also handle the corresponding result
variables: append if the process did not exist yet in the global stack,
otherwise update.
TODO: result variables do not work that way yet, require initialization in the
global variable list.
<<RT data: rt data: TBP>>=
procedure :: transfer_process_stack => rt_data_transfer_process_stack
<<RT data: procedures>>=
subroutine rt_data_transfer_process_stack (local, global)
class(rt_data_t), intent(inout), target :: local
class(rt_data_t), intent(inout), target :: global
type(process_entry_t), pointer :: process
type(string_t) :: process_id
do
call local%process_stack%pop_last (process)
if (.not. associated (process)) exit
process_id = process%get_id ()
call global%process_stack%push (process)
call global%process_stack%fill_result_vars (process_id)
call global%process_stack%update_result_vars &
(process_id, global%var_list)
end do
end subroutine rt_data_transfer_process_stack
@ %def rt_data_transfer_process_stack
@
\subsection{Finalization}
Finalizer for the variable list and the structure-function list.
This is done only for the global RT dataset; local copies contain
pointers to this and do not need a finalizer.
<<RT data: rt data: TBP>>=
procedure :: final => rt_data_global_final
<<RT data: procedures>>=
subroutine rt_data_global_final (global)
class(rt_data_t), intent(inout) :: global
call global%process_stack%final ()
call global%prclib_stack%final ()
call global%model_list%final ()
call global%var_list%final (follow_link=.false.)
if (associated (global%out_files)) then
call file_list_final (global%out_files)
deallocate (global%out_files)
end if
end subroutine rt_data_global_final
@ %def rt_data_global_final
@ The local copy needs a finalizer for the variable list, which consists
of local copies. This finalizer is called only when the local
environment is finally discarded. (Note that the process stack should
already have been cleared after execution, which can occur many times
for the same local environment.)
<<RT data: rt data: TBP>>=
procedure :: local_final => rt_data_local_final
<<RT data: procedures>>=
subroutine rt_data_local_final (local)
class(rt_data_t), intent(inout) :: local
call local%process_stack%clear ()
call local%model_list%final ()
call local%var_list%final (follow_link=.false.)
end subroutine rt_data_local_final
@ %def rt_data_local_final
@
\subsection{Model Management}
Read a model, so it becomes available for activation. No variables or model
copies, this is just initialization.
If this is a local environment, the model will be automatically read into the
global context.
<<RT data: rt data: TBP>>=
procedure :: read_model => rt_data_read_model
<<RT data: procedures>>=
subroutine rt_data_read_model (global, name, model, scheme)
class(rt_data_t), intent(inout) :: global
type(string_t), intent(in) :: name
type(string_t), intent(in), optional :: scheme
type(model_t), pointer, intent(out) :: model
type(string_t) :: filename
filename = name // ".mdl"
call global%model_list%read_model &
(name, filename, global%os_data, model, scheme)
end subroutine rt_data_read_model
@ %def rt_data_read_model
@ Read a UFO model. Create it on the fly if necessary.
<<RT data: rt data: TBP>>=
procedure :: read_ufo_model => rt_data_read_ufo_model
<<RT data: procedures>>=
subroutine rt_data_read_ufo_model (global, name, model, ufo_path)
class(rt_data_t), intent(inout) :: global
type(string_t), intent(in) :: name
type(model_t), pointer, intent(out) :: model
type(string_t), intent(in), optional :: ufo_path
type(string_t) :: filename
filename = name // ".ufo.mdl"
call global%model_list%read_model &
(name, filename, global%os_data, model, ufo=.true., ufo_path=ufo_path)
end subroutine rt_data_read_ufo_model
@ %def rt_data_read_ufo_model
@ Initialize the fallback model. This model is used
whenever the current model does not describe all physical particles
(hadrons, mainly). It is not supposed to be modified, and the pointer
should remain linked to this model.
<<RT data: rt data: TBP>>=
procedure :: init_fallback_model => rt_data_init_fallback_model
<<RT data: procedures>>=
subroutine rt_data_init_fallback_model (global, name, filename)
class(rt_data_t), intent(inout) :: global
type(string_t), intent(in) :: name, filename
call global%model_list%read_model &
(name, filename, global%os_data, global%fallback_model)
end subroutine rt_data_init_fallback_model
@ %def rt_data_init_fallback_model
@
Activate a model: assign the current-model pointer and set the model name in
the variable list. If necessary, read the model from file. Link the global
variable list to the model variable list.
<<RT data: rt data: TBP>>=
procedure :: select_model => rt_data_select_model
<<RT data: procedures>>=
subroutine rt_data_select_model (global, name, scheme, ufo, ufo_path)
class(rt_data_t), intent(inout), target :: global
type(string_t), intent(in) :: name
type(string_t), intent(in), optional :: scheme
logical, intent(in), optional :: ufo
type(string_t), intent(in), optional :: ufo_path
logical :: same_model, ufo_model
ufo_model = .false.; if (present (ufo)) ufo_model = ufo
if (associated (global%model)) then
same_model = global%model%matches (name, scheme, ufo)
else
same_model = .false.
end if
if (.not. same_model) then
global%model => global%model_list%get_model_ptr (name, scheme, ufo)
if (.not. associated (global%model)) then
if (ufo_model) then
call global%read_ufo_model (name, global%model, ufo_path)
else
call global%read_model (name, global%model)
end if
global%model_is_copy = .false.
else if (associated (global%context)) then
global%model_is_copy = &
global%model_list%model_exists (name, scheme, ufo, &
follow_link=.false.)
else
global%model_is_copy = .false.
end if
end if
if (associated (global%model)) then
call global%model%link_var_list (global%var_list)
call global%var_list%set_string (var_str ("$model_name"), &
name, is_known = .true.)
if (global%model%is_ufo_model ()) then
call msg_message ("Switching to model '" // char (name) // "' " &
// "(generated from UFO source)")
else if (global%model%has_schemes ()) then
call msg_message ("Switching to model '" // char (name) // "', " &
// "scheme '" // char (global%model%get_scheme ()) // "'")
else
call msg_message ("Switching to model '" // char (name) // "'")
end if
else
call global%var_list%set_string (var_str ("$model_name"), &
var_str (""), is_known = .false.)
end if
end subroutine rt_data_select_model
@ %def rt_data_select_model
@
Remove the model link. Do not unset the model name variable, because
this may unset the variable in a parent [[rt_data]] object (via linked
var lists).
<<RT data: rt data: TBP>>=
procedure :: unselect_model => rt_data_unselect_model
<<RT data: procedures>>=
subroutine rt_data_unselect_model (global)
class(rt_data_t), intent(inout), target :: global
if (associated (global%model)) then
global%model => null ()
global%model_is_copy = .false.
end if
end subroutine rt_data_unselect_model
@ %def rt_data_unselect_model
@
Create a copy of the currently selected model and append it to the local model
list. The model pointer is redirected to the copy.
(Not applicable for the global model list, those models will be
modified in-place.)
<<RT data: rt data: TBP>>=
procedure :: ensure_model_copy => rt_data_ensure_model_copy
<<RT data: procedures>>=
subroutine rt_data_ensure_model_copy (global)
class(rt_data_t), intent(inout), target :: global
if (associated (global%context)) then
if (.not. global%model_is_copy) then
call global%model_list%append_copy (global%model, global%model)
global%model_is_copy = .true.
call global%model%link_var_list (global%var_list)
end if
end if
end subroutine rt_data_ensure_model_copy
@ %def rt_data_ensure_model_copy
@
Modify a model variable. The update mechanism will ensure that the model
parameter set remains consistent. This has to take place in a local copy
of the current model. If there is none yet, create one.
<<RT data: rt data: TBP>>=
procedure :: model_set_real => rt_data_model_set_real
<<RT data: procedures>>=
subroutine rt_data_model_set_real (global, name, rval, verbose, pacified)
class(rt_data_t), intent(inout), target :: global
type(string_t), intent(in) :: name
real(default), intent(in) :: rval
logical, intent(in), optional :: verbose, pacified
call global%ensure_model_copy ()
call global%model%set_real (name, rval, verbose, pacified)
end subroutine rt_data_model_set_real
@ %def rt_data_model_set_real
@
Modify particle properties. This has to take place in a local copy
of the current model. If there is none yet, create one.
<<RT data: rt data: TBP>>=
procedure :: modify_particle => rt_data_modify_particle
<<RT data: procedures>>=
subroutine rt_data_modify_particle &
(global, pdg, polarized, stable, decay, &
isotropic_decay, diagonal_decay, decay_helicity)
class(rt_data_t), intent(inout), target :: global
integer, intent(in) :: pdg
logical, intent(in), optional :: polarized, stable
logical, intent(in), optional :: isotropic_decay, diagonal_decay
integer, intent(in), optional :: decay_helicity
type(string_t), dimension(:), intent(in), optional :: decay
call global%ensure_model_copy ()
if (present (polarized)) then
if (polarized) then
call global%model%set_polarized (pdg)
else
call global%model%set_unpolarized (pdg)
end if
end if
if (present (stable)) then
if (stable) then
call global%model%set_stable (pdg)
else if (present (decay)) then
call global%model%set_unstable &
(pdg, decay, isotropic_decay, diagonal_decay, decay_helicity)
else
call msg_bug ("Setting particle unstable: missing decay processes")
end if
end if
end subroutine rt_data_modify_particle
@ %def rt_data_modify_particle
@
\subsection{Managing Variables}
Return a pointer to the currently active variable list. If there is no model,
this is the global variable list. If there is one, it is the model variable
list, which should be linked to the former.
<<RT data: rt data: TBP>>=
procedure :: get_var_list_ptr => rt_data_get_var_list_ptr
<<RT data: procedures>>=
function rt_data_get_var_list_ptr (global) result (var_list)
class(rt_data_t), intent(in), target :: global
type(var_list_t), pointer :: var_list
if (associated (global%model)) then
var_list => global%model%get_var_list_ptr ()
else
var_list => global%var_list
end if
end function rt_data_get_var_list_ptr
@ %def rt_data_get_var_list_ptr
@ Initialize a local variable: append it to the current variable list. No
initial value, yet.
<<RT data: rt data: TBP>>=
procedure :: append_log => rt_data_append_log
procedure :: append_int => rt_data_append_int
procedure :: append_real => rt_data_append_real
procedure :: append_cmplx => rt_data_append_cmplx
procedure :: append_subevt => rt_data_append_subevt
procedure :: append_pdg_array => rt_data_append_pdg_array
procedure :: append_string => rt_data_append_string
<<RT data: procedures>>=
subroutine rt_data_append_log (local, name, lval, intrinsic, user)
class(rt_data_t), intent(inout) :: local
type(string_t), intent(in) :: name
logical, intent(in), optional :: lval
logical, intent(in), optional :: intrinsic, user
call local%var_list%append_log (name, lval, &
intrinsic = intrinsic, user = user)
end subroutine rt_data_append_log
subroutine rt_data_append_int (local, name, ival, intrinsic, user)
class(rt_data_t), intent(inout) :: local
type(string_t), intent(in) :: name
integer, intent(in), optional :: ival
logical, intent(in), optional :: intrinsic, user
call local%var_list%append_int (name, ival, &
intrinsic = intrinsic, user = user)
end subroutine rt_data_append_int
subroutine rt_data_append_real (local, name, rval, intrinsic, user)
class(rt_data_t), intent(inout) :: local
type(string_t), intent(in) :: name
real(default), intent(in), optional :: rval
logical, intent(in), optional :: intrinsic, user
call local%var_list%append_real (name, rval, &
intrinsic = intrinsic, user = user)
end subroutine rt_data_append_real
subroutine rt_data_append_cmplx (local, name, cval, intrinsic, user)
class(rt_data_t), intent(inout) :: local
type(string_t), intent(in) :: name
complex(default), intent(in), optional :: cval
logical, intent(in), optional :: intrinsic, user
call local%var_list%append_cmplx (name, cval, &
intrinsic = intrinsic, user = user)
end subroutine rt_data_append_cmplx
subroutine rt_data_append_subevt (local, name, pval, intrinsic, user)
class(rt_data_t), intent(inout) :: local
type(string_t), intent(in) :: name
type(subevt_t), intent(in), optional :: pval
logical, intent(in) :: intrinsic, user
call local%var_list%append_subevt (name, &
intrinsic = intrinsic, user = user)
end subroutine rt_data_append_subevt
subroutine rt_data_append_pdg_array (local, name, aval, intrinsic, user)
class(rt_data_t), intent(inout) :: local
type(string_t), intent(in) :: name
type(pdg_array_t), intent(in), optional :: aval
logical, intent(in), optional :: intrinsic, user
call local%var_list%append_pdg_array (name, aval, &
intrinsic = intrinsic, user = user)
end subroutine rt_data_append_pdg_array
subroutine rt_data_append_string (local, name, sval, intrinsic, user)
class(rt_data_t), intent(inout) :: local
type(string_t), intent(in) :: name
type(string_t), intent(in), optional :: sval
logical, intent(in), optional :: intrinsic, user
call local%var_list%append_string (name, sval, &
intrinsic = intrinsic, user = user)
end subroutine rt_data_append_string
@ %def rt_data_append_log
@ %def rt_data_append_int
@ %def rt_data_append_real
@ %def rt_data_append_cmplx
@ %def rt_data_append_subevt
@ %def rt_data_append_pdg_array
@ %def rt_data_append_string
@ Import values for all local variables, given a global context environment
where these variables are defined.
<<RT data: rt data: TBP>>=
procedure :: import_values => rt_data_import_values
<<RT data: procedures>>=
subroutine rt_data_import_values (local)
class(rt_data_t), intent(inout) :: local
type(rt_data_t), pointer :: global
global => local%context
if (associated (global)) then
call local%var_list%import (global%var_list)
end if
end subroutine rt_data_import_values
@ %def rt_data_import_values
@ Unset all variable values.
<<RT data: rt data: TBP>>=
procedure :: unset_values => rt_data_unset_values
<<RT data: procedures>>=
subroutine rt_data_unset_values (global)
class(rt_data_t), intent(inout) :: global
call global%var_list%undefine (follow_link=.false.)
end subroutine rt_data_unset_values
@ %def rt_data_unset_values
@ Set a variable. (Not a model variable, these are handled separately.) We
can assume that the variable has been initialized.
<<RT data: rt data: TBP>>=
procedure :: set_log => rt_data_set_log
procedure :: set_int => rt_data_set_int
procedure :: set_real => rt_data_set_real
procedure :: set_cmplx => rt_data_set_cmplx
procedure :: set_subevt => rt_data_set_subevt
procedure :: set_pdg_array => rt_data_set_pdg_array
procedure :: set_string => rt_data_set_string
<<RT data: procedures>>=
subroutine rt_data_set_log &
(global, name, lval, is_known, force, verbose)
class(rt_data_t), intent(inout) :: global
type(string_t), intent(in) :: name
logical, intent(in) :: lval
logical, intent(in) :: is_known
logical, intent(in), optional :: force, verbose
call global%var_list%set_log (name, lval, is_known, &
force=force, verbose=verbose)
end subroutine rt_data_set_log
subroutine rt_data_set_int &
(global, name, ival, is_known, force, verbose)
class(rt_data_t), intent(inout) :: global
type(string_t), intent(in) :: name
integer, intent(in) :: ival
logical, intent(in) :: is_known
logical, intent(in), optional :: force, verbose
call global%var_list%set_int (name, ival, is_known, &
force=force, verbose=verbose)
end subroutine rt_data_set_int
subroutine rt_data_set_real &
(global, name, rval, is_known, force, verbose, pacified)
class(rt_data_t), intent(inout) :: global
type(string_t), intent(in) :: name
real(default), intent(in) :: rval
logical, intent(in) :: is_known
logical, intent(in), optional :: force, verbose, pacified
call global%var_list%set_real (name, rval, is_known, &
force=force, verbose=verbose, pacified=pacified)
end subroutine rt_data_set_real
subroutine rt_data_set_cmplx &
(global, name, cval, is_known, force, verbose, pacified)
class(rt_data_t), intent(inout) :: global
type(string_t), intent(in) :: name
complex(default), intent(in) :: cval
logical, intent(in) :: is_known
logical, intent(in), optional :: force, verbose, pacified
call global%var_list%set_cmplx (name, cval, is_known, &
force=force, verbose=verbose, pacified=pacified)
end subroutine rt_data_set_cmplx
subroutine rt_data_set_subevt &
(global, name, pval, is_known, force, verbose)
class(rt_data_t), intent(inout) :: global
type(string_t), intent(in) :: name
type(subevt_t), intent(in) :: pval
logical, intent(in) :: is_known
logical, intent(in), optional :: force, verbose
call global%var_list%set_subevt (name, pval, is_known, &
force=force, verbose=verbose)
end subroutine rt_data_set_subevt
subroutine rt_data_set_pdg_array &
(global, name, aval, is_known, force, verbose)
class(rt_data_t), intent(inout) :: global
type(string_t), intent(in) :: name
type(pdg_array_t), intent(in) :: aval
logical, intent(in) :: is_known
logical, intent(in), optional :: force, verbose
call global%var_list%set_pdg_array (name, aval, is_known, &
force=force, verbose=verbose)
end subroutine rt_data_set_pdg_array
subroutine rt_data_set_string &
(global, name, sval, is_known, force, verbose)
class(rt_data_t), intent(inout) :: global
type(string_t), intent(in) :: name
type(string_t), intent(in) :: sval
logical, intent(in) :: is_known
logical, intent(in), optional :: force, verbose
call global%var_list%set_string (name, sval, is_known, &
force=force, verbose=verbose)
end subroutine rt_data_set_string
@ %def rt_data_set_log
@ %def rt_data_set_int
@ %def rt_data_set_real
@ %def rt_data_set_cmplx
@ %def rt_data_set_subevt
@ %def rt_data_set_pdg_array
@ %def rt_data_set_string
@ Return the value of a variable, assuming that the type is correct.
<<RT data: rt data: TBP>>=
procedure :: get_lval => rt_data_get_lval
procedure :: get_ival => rt_data_get_ival
procedure :: get_rval => rt_data_get_rval
procedure :: get_cval => rt_data_get_cval
procedure :: get_pval => rt_data_get_pval
procedure :: get_aval => rt_data_get_aval
procedure :: get_sval => rt_data_get_sval
<<RT data: procedures>>=
function rt_data_get_lval (global, name) result (lval)
logical :: lval
class(rt_data_t), intent(in), target :: global
type(string_t), intent(in) :: name
type(var_list_t), pointer :: var_list
var_list => global%get_var_list_ptr ()
lval = var_list%get_lval (name)
end function rt_data_get_lval
function rt_data_get_ival (global, name) result (ival)
integer :: ival
class(rt_data_t), intent(in), target :: global
type(string_t), intent(in) :: name
type(var_list_t), pointer :: var_list
var_list => global%get_var_list_ptr ()
ival = var_list%get_ival (name)
end function rt_data_get_ival
function rt_data_get_rval (global, name) result (rval)
real(default) :: rval
class(rt_data_t), intent(in), target :: global
type(string_t), intent(in) :: name
type(var_list_t), pointer :: var_list
var_list => global%get_var_list_ptr ()
rval = var_list%get_rval (name)
end function rt_data_get_rval
function rt_data_get_cval (global, name) result (cval)
complex(default) :: cval
class(rt_data_t), intent(in), target :: global
type(string_t), intent(in) :: name
type(var_list_t), pointer :: var_list
var_list => global%get_var_list_ptr ()
cval = var_list%get_cval (name)
end function rt_data_get_cval
function rt_data_get_aval (global, name) result (aval)
type(pdg_array_t) :: aval
class(rt_data_t), intent(in), target :: global
type(string_t), intent(in) :: name
type(var_list_t), pointer :: var_list
var_list => global%get_var_list_ptr ()
aval = var_list%get_aval (name)
end function rt_data_get_aval
function rt_data_get_pval (global, name) result (pval)
type(subevt_t) :: pval
class(rt_data_t), intent(in), target :: global
type(string_t), intent(in) :: name
type(var_list_t), pointer :: var_list
var_list => global%get_var_list_ptr ()
pval = var_list%get_pval (name)
end function rt_data_get_pval
function rt_data_get_sval (global, name) result (sval)
type(string_t) :: sval
class(rt_data_t), intent(in), target :: global
type(string_t), intent(in) :: name
type(var_list_t), pointer :: var_list
var_list => global%get_var_list_ptr ()
sval = var_list%get_sval (name)
end function rt_data_get_sval
@ %def rt_data_get_lval
@ %def rt_data_get_ival
@ %def rt_data_get_rval
@ %def rt_data_get_cval
@ %def rt_data_get_pval
@ %def rt_data_get_aval
@ %def rt_data_get_sval
@ Return true if the variable exists in the global list.
<<RT data: rt data: TBP>>=
procedure :: contains => rt_data_contains
<<RT data: procedures>>=
function rt_data_contains (global, name) result (lval)
logical :: lval
class(rt_data_t), intent(in), target :: global
type(string_t), intent(in) :: name
type(var_list_t), pointer :: var_list
var_list => global%get_var_list_ptr ()
lval = var_list%contains (name)
end function rt_data_contains
@ %def rt_data_contains
@ Return true if the value of the variable is known.
<<RT data: rt data: TBP>>=
procedure :: is_known => rt_data_is_known
<<RT data: procedures>>=
function rt_data_is_known (global, name) result (lval)
logical :: lval
class(rt_data_t), intent(in), target :: global
type(string_t), intent(in) :: name
type(var_list_t), pointer :: var_list
var_list => global%get_var_list_ptr ()
lval = var_list%is_known (name)
end function rt_data_is_known
@ %def rt_data_is_known
@
\subsection{Further Content}
Add a library (available via a pointer of type [[prclib_entry_t]]) to
the stack and update the pointer and variable list to the current
library. The pointer association of [[prclib_entry]] will be discarded.
<<RT data: rt data: TBP>>=
procedure :: add_prclib => rt_data_add_prclib
<<RT data: procedures>>=
subroutine rt_data_add_prclib (global, prclib_entry)
class(rt_data_t), intent(inout) :: global
type(prclib_entry_t), intent(inout), pointer :: prclib_entry
call global%prclib_stack%push (prclib_entry)
call global%update_prclib (global%prclib_stack%get_first_ptr ())
end subroutine rt_data_add_prclib
@ %def rt_data_add_prclib
@ Given a pointer to a process library, make this the currently active
library.
<<RT data: rt data: TBP>>=
procedure :: update_prclib => rt_data_update_prclib
<<RT data: procedures>>=
subroutine rt_data_update_prclib (global, lib)
class(rt_data_t), intent(inout) :: global
type(process_library_t), intent(in), target :: lib
global%prclib => lib
if (global%var_list%contains (&
var_str ("$library_name"), follow_link = .false.)) then
call global%var_list%set_string (var_str ("$library_name"), &
global%prclib%get_name (), is_known=.true.)
else
call global%var_list%append_string ( &
var_str ("$library_name"), global%prclib%get_name (), &
intrinsic = .true.)
end if
end subroutine rt_data_update_prclib
@ %def rt_data_update_prclib
@
\subsection{Miscellaneous}
The helicity selection data are distributed among several parameters. Here,
we collect them in a single record.
<<RT data: rt data: TBP>>=
procedure :: get_helicity_selection => rt_data_get_helicity_selection
<<RT data: procedures>>=
function rt_data_get_helicity_selection (rt_data) result (helicity_selection)
class(rt_data_t), intent(in) :: rt_data
type(helicity_selection_t) :: helicity_selection
associate (var_list => rt_data%var_list)
helicity_selection%active = var_list%get_lval (&
var_str ("?helicity_selection_active"))
if (helicity_selection%active) then
helicity_selection%threshold = var_list%get_rval (&
var_str ("helicity_selection_threshold"))
helicity_selection%cutoff = var_list%get_ival (&
var_str ("helicity_selection_cutoff"))
end if
end associate
end function rt_data_get_helicity_selection
@ %def rt_data_get_helicity_selection
@ Show the beam setup: beam structure and relevant global variables.
<<RT data: rt data: TBP>>=
procedure :: show_beams => rt_data_show_beams
<<RT data: procedures>>=
subroutine rt_data_show_beams (rt_data, unit)
class(rt_data_t), intent(in) :: rt_data
integer, intent(in), optional :: unit
type(string_t) :: s
integer :: u
u = given_output_unit (unit)
associate (beams => rt_data%beam_structure, var_list => rt_data%var_list)
call beams%write (u)
if (.not. beams%asymmetric () .and. beams%get_n_beam () == 2) then
write (u, "(2x,A," // FMT_19 // ",1x,'GeV')") "sqrts =", &
var_list%get_rval (var_str ("sqrts"))
end if
if (beams%contains ("pdf_builtin")) then
s = var_list%get_sval (var_str ("$pdf_builtin_set"))
if (s /= "") then
write (u, "(2x,A,1x,3A)") "PDF set =", '"', char (s), '"'
else
write (u, "(2x,A,1x,A)") "PDF set =", "[undefined]"
end if
end if
if (beams%contains ("lhapdf")) then
s = var_list%get_sval (var_str ("$lhapdf_dir"))
if (s /= "") then
write (u, "(2x,A,1x,3A)") "LHAPDF dir =", '"', char (s), '"'
end if
s = var_list%get_sval (var_str ("$lhapdf_file"))
if (s /= "") then
write (u, "(2x,A,1x,3A)") "LHAPDF file =", '"', char (s), '"'
write (u, "(2x,A,1x,I0)") "LHAPDF member =", &
var_list%get_ival (var_str ("lhapdf_member"))
else
write (u, "(2x,A,1x,A)") "LHAPDF file =", "[undefined]"
end if
end if
if (beams%contains ("lhapdf_photon")) then
s = var_list%get_sval (var_str ("$lhapdf_dir"))
if (s /= "") then
write (u, "(2x,A,1x,3A)") "LHAPDF dir =", '"', char (s), '"'
end if
s = var_list%get_sval (var_str ("$lhapdf_photon_file"))
if (s /= "") then
write (u, "(2x,A,1x,3A)") "LHAPDF file =", '"', char (s), '"'
write (u, "(2x,A,1x,I0)") "LHAPDF member =", &
var_list%get_ival (var_str ("lhapdf_member"))
write (u, "(2x,A,1x,I0)") "LHAPDF scheme =", &
var_list%get_ival (&
var_str ("lhapdf_photon_scheme"))
else
write (u, "(2x,A,1x,A)") "LHAPDF file =", "[undefined]"
end if
end if
if (beams%contains ("isr")) then
write (u, "(2x,A," // FMT_19 // ")") "ISR alpha =", &
var_list%get_rval (var_str ("isr_alpha"))
write (u, "(2x,A," // FMT_19 // ")") "ISR Q max =", &
var_list%get_rval (var_str ("isr_q_max"))
write (u, "(2x,A," // FMT_19 // ")") "ISR mass =", &
var_list%get_rval (var_str ("isr_mass"))
write (u, "(2x,A,1x,I0)") "ISR order =", &
var_list%get_ival (var_str ("isr_order"))
write (u, "(2x,A,1x,L1)") "ISR recoil =", &
var_list%get_lval (var_str ("?isr_recoil"))
write (u, "(2x,A,1x,L1)") "ISR energy cons. =", &
var_list%get_lval (var_str ("?isr_keep_energy"))
end if
if (beams%contains ("epa")) then
write (u, "(2x,A," // FMT_19 // ")") "EPA alpha =", &
var_list%get_rval (var_str ("epa_alpha"))
write (u, "(2x,A," // FMT_19 // ")") "EPA x min =", &
var_list%get_rval (var_str ("epa_x_min"))
write (u, "(2x,A," // FMT_19 // ")") "EPA Q min =", &
var_list%get_rval (var_str ("epa_q_min"))
write (u, "(2x,A," // FMT_19 // ")") "EPA Q max =", &
var_list%get_rval (var_str ("epa_q_max"))
write (u, "(2x,A," // FMT_19 // ")") "EPA mass =", &
var_list%get_rval (var_str ("epa_mass"))
write (u, "(2x,A,1x,L1)") "EPA recoil =", &
var_list%get_lval (var_str ("?epa_recoil"))
write (u, "(2x,A,1x,L1)") "EPA energy cons. =", &
var_list%get_lval (var_str ("?epa_keep_energy"))
end if
if (beams%contains ("ewa")) then
write (u, "(2x,A," // FMT_19 // ")") "EWA x min =", &
var_list%get_rval (var_str ("ewa_x_min"))
write (u, "(2x,A," // FMT_19 // ")") "EWA Pt max =", &
var_list%get_rval (var_str ("ewa_pt_max"))
write (u, "(2x,A," // FMT_19 // ")") "EWA mass =", &
var_list%get_rval (var_str ("ewa_mass"))
write (u, "(2x,A,1x,L1)") "EWA recoil =", &
var_list%get_lval (var_str ("?ewa_recoil"))
write (u, "(2x,A,1x,L1)") "EWA energy cons. =", &
var_list%get_lval (var_str ("ewa_keep_energy"))
end if
if (beams%contains ("circe1")) then
write (u, "(2x,A,1x,I0)") "CIRCE1 version =", &
var_list%get_ival (var_str ("circe1_ver"))
write (u, "(2x,A,1x,I0)") "CIRCE1 revision =", &
var_list%get_ival (var_str ("circe1_rev"))
s = var_list%get_sval (var_str ("$circe1_acc"))
write (u, "(2x,A,1x,A)") "CIRCE1 acceler. =", char (s)
write (u, "(2x,A,1x,I0)") "CIRCE1 chattin. =", &
var_list%get_ival (var_str ("circe1_chat"))
write (u, "(2x,A," // FMT_19 // ")") "CIRCE1 sqrts =", &
var_list%get_rval (var_str ("circe1_sqrts"))
write (u, "(2x,A," // FMT_19 // ")") "CIRCE1 epsil. =", &
var_list%get_rval (var_str ("circe1_eps"))
write (u, "(2x,A,1x,L1)") "CIRCE1 phot. 1 =", &
var_list%get_lval (var_str ("?circe1_photon1"))
write (u, "(2x,A,1x,L1)") "CIRCE1 phot. 2 =", &
var_list%get_lval (var_str ("?circe1_photon2"))
write (u, "(2x,A,1x,L1)") "CIRCE1 generat. =", &
var_list%get_lval (var_str ("?circe1_generate"))
write (u, "(2x,A,1x,L1)") "CIRCE1 mapping =", &
var_list%get_lval (var_str ("?circe1_map"))
write (u, "(2x,A," // FMT_19 // ")") "CIRCE1 map. slope =", &
var_list%get_rval (var_str ("circe1_mapping_slope"))
write (u, "(2x,A,1x,L1)") "CIRCE recoil photon =", &
var_list%get_lval (var_str ("?circe1_with_radiation"))
end if
if (beams%contains ("circe2")) then
s = var_list%get_sval (var_str ("$circe2_design"))
write (u, "(2x,A,1x,A)") "CIRCE2 design =", char (s)
s = var_list%get_sval (var_str ("$circe2_file"))
write (u, "(2x,A,1x,A)") "CIRCE2 file =", char (s)
write (u, "(2x,A,1x,L1)") "CIRCE2 polarized =", &
var_list%get_lval (var_str ("?circe2_polarized"))
end if
if (beams%contains ("gaussian")) then
write (u, "(2x,A,1x," // FMT_12 // ")") "Gaussian spread 1 =", &
var_list%get_rval (var_str ("gaussian_spread1"))
write (u, "(2x,A,1x," // FMT_12 // ")") "Gaussian spread 2 =", &
var_list%get_rval (var_str ("gaussian_spread2"))
end if
if (beams%contains ("beam_events")) then
s = var_list%get_sval (var_str ("$beam_events_file"))
write (u, "(2x,A,1x,A)") "Beam events file =", char (s)
write (u, "(2x,A,1x,L1)") "Beam events EOF warn =", &
var_list%get_lval (var_str ("?beam_events_warn_eof"))
end if
end associate
end subroutine rt_data_show_beams
@ %def rt_data_show_beams
@ Return the collision energy as determined by the current beam
settings. Without beam setup, this is the [[sqrts]] variable.
If the value is meaningless for a setup, the function returns zero.
<<RT data: rt data: TBP>>=
procedure :: get_sqrts => rt_data_get_sqrts
<<RT data: procedures>>=
function rt_data_get_sqrts (rt_data) result (sqrts)
class(rt_data_t), intent(in) :: rt_data
real(default) :: sqrts
sqrts = rt_data%var_list%get_rval (var_str ("sqrts"))
end function rt_data_get_sqrts
@ %def rt_data_get_sqrts
@ For testing purposes, the [[rt_data_t]] contents can be pacified to
suppress numerical fluctuations in (constant) test matrix elements.
<<RT data: rt data: TBP>>=
procedure :: pacify => rt_data_pacify
<<RT data: procedures>>=
subroutine rt_data_pacify (rt_data, efficiency_reset, error_reset)
class(rt_data_t), intent(inout) :: rt_data
logical, intent(in), optional :: efficiency_reset, error_reset
type(process_entry_t), pointer :: process
process => rt_data%process_stack%first
do while (associated (process))
call process%pacify (efficiency_reset, error_reset)
process => process%next
end do
end subroutine rt_data_pacify
@ %def rt_data_pacify
@
<<RT data: rt data: TBP>>=
procedure :: set_event_callback => rt_data_set_event_callback
<<RT data: procedures>>=
subroutine rt_data_set_event_callback (global, callback)
class(rt_data_t), intent(inout) :: global
class(event_callback_t), intent(in) :: callback
if (allocated (global%event_callback)) deallocate (global%event_callback)
allocate (global%event_callback, source = callback)
end subroutine rt_data_set_event_callback
@ %def rt_data_set_event_callback
@
<<RT data: rt data: TBP>>=
procedure :: has_event_callback => rt_data_has_event_callback
procedure :: get_event_callback => rt_data_get_event_callback
<<RT data: procedures>>=
function rt_data_has_event_callback (global) result (flag)
class(rt_data_t), intent(in) :: global
logical :: flag
flag = allocated (global%event_callback)
end function rt_data_has_event_callback
function rt_data_get_event_callback (global) result (callback)
class(rt_data_t), intent(in) :: global
class(event_callback_t), allocatable :: callback
if (allocated (global%event_callback)) then
allocate (callback, source = global%event_callback)
end if
end function rt_data_get_event_callback
@ %def rt_data_has_event_callback
@ %def rt_data_get_event_callback
@ Force system-dependent objects to well-defined values. Some of the
variables are locked and therefore must be addressed directly.
This is, of course, only required for testing purposes. In principle,
the [[real_specimen]] variables could be set to their values in
[[rt_data_t]], but this depends on the precision again, so we set
them to some dummy values.
<<RT data: public>>=
public :: fix_system_dependencies
<<RT data: procedures>>=
subroutine fix_system_dependencies (global)
class(rt_data_t), intent(inout), target :: global
type(var_list_t), pointer :: var_list
var_list => global%get_var_list_ptr ()
call var_list%set_log (var_str ("?omega_openmp"), &
.false., is_known = .true., force=.true.)
call var_list%set_log (var_str ("?openmp_is_active"), &
.false., is_known = .true., force=.true.)
call var_list%set_int (var_str ("openmp_num_threads_default"), &
1, is_known = .true., force=.true.)
call var_list%set_int (var_str ("openmp_num_threads"), &
1, is_known = .true., force=.true.)
call var_list%set_int (var_str ("real_range"), &
307, is_known = .true., force=.true.)
call var_list%set_int (var_str ("real_precision"), &
15, is_known = .true., force=.true.)
call var_list%set_real (var_str ("real_epsilon"), &
1.e-16_default, is_known = .true., force=.true.)
call var_list%set_real (var_str ("real_tiny"), &
1.e-300_default, is_known = .true., force=.true.)
global%os_data%fc = "Fortran-compiler"
global%os_data%fcflags = "Fortran-flags"
global%os_data%fclibs = "Fortran-libs"
end subroutine fix_system_dependencies
@ %def fix_system_dependencies
@
<<RT data: public>>=
public :: show_description_of_string
<<RT data: procedures>>=
subroutine show_description_of_string (string)
type(string_t), intent(in) :: string
type(rt_data_t), target :: global
call global%global_init ()
call global%show_description_of_string (string, ascii_output=.true.)
end subroutine show_description_of_string
@ %def show_description_of_string
@
<<RT data: public>>=
public :: show_tex_descriptions
<<RT data: procedures>>=
subroutine show_tex_descriptions ()
type(rt_data_t), target :: global
call global%global_init ()
call fix_system_dependencies (global)
call global%set_int (var_str ("seed"), 0, is_known=.true.)
call global%var_list%sort ()
call global%write_var_descriptions ()
end subroutine show_tex_descriptions
@ %def show_tex_descriptions
@
\subsection{Unit Tests}
Test module, followed by the corresponding implementation module.
<<[[rt_data_ut.f90]]>>=
<<File header>>
module rt_data_ut
use unit_tests
use rt_data_uti
<<Standard module head>>
<<RT data: public test>>
contains
<<RT data: test driver>>
end module rt_data_ut
@ %def rt_data_ut
@
<<[[rt_data_uti.f90]]>>=
<<File header>>
module rt_data_uti
<<Use kinds>>
<<Use strings>>
use format_defs, only: FMT_19
use ifiles
use lexers
use parser
use flavors
use variables, only: var_list_t, var_entry_t, var_entry_init_int
use eval_trees
use models
use prclib_stacks
use rt_data
<<Standard module head>>
<<RT data: test declarations>>
contains
<<RT data: test auxiliary>>
<<RT data: tests>>
end module rt_data_uti
@ %def rt_data_ut
@ API: driver for the unit tests below.
<<RT data: public test>>=
public :: rt_data_test
<<RT data: test driver>>=
subroutine rt_data_test (u, results)
integer, intent(in) :: u
type(test_results_t), intent(inout) :: results
<<RT data: execute tests>>
end subroutine rt_data_test
@ %def rt_data_test
@
\subsubsection{Initial content}
@
Display the RT data in the state just after (global) initialization.
<<RT data: execute tests>>=
call test (rt_data_1, "rt_data_1", &
"initialize", &
u, results)
<<RT data: test declarations>>=
public :: rt_data_1
<<RT data: tests>>=
subroutine rt_data_1 (u)
integer, intent(in) :: u
type(rt_data_t), target :: global
write (u, "(A)") "* Test output: rt_data_1"
write (u, "(A)") "* Purpose: initialize global runtime data"
write (u, "(A)")
call global%global_init (logfile = var_str ("rt_data.log"))
call fix_system_dependencies (global)
call global%set_int (var_str ("seed"), 0, is_known=.true.)
call global%it_list%init ([2, 3], [5000, 20000])
call global%write (u)
call global%final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: rt_data_1"
end subroutine rt_data_1
@ %def rt_data_1
@
\subsubsection{Fill values}
Fill in empty slots in the runtime data block.
<<RT data: execute tests>>=
call test (rt_data_2, "rt_data_2", &
"fill", &
u, results)
<<RT data: test declarations>>=
public :: rt_data_2
<<RT data: tests>>=
subroutine rt_data_2 (u)
integer, intent(in) :: u
type(rt_data_t), target :: global
type(flavor_t), dimension(2) :: flv
type(string_t) :: cut_expr_text
type(ifile_t) :: ifile
type(stream_t) :: stream
type(parse_tree_t) :: parse_tree
write (u, "(A)") "* Test output: rt_data_2"
write (u, "(A)") "* Purpose: initialize global runtime data &
&and fill contents"
write (u, "(A)")
call syntax_model_file_init ()
call global%global_init ()
call fix_system_dependencies (global)
call global%select_model (var_str ("Test"))
call global%set_real (var_str ("sqrts"), &
1000._default, is_known = .true.)
call global%set_int (var_str ("seed"), &
0, is_known=.true.)
call flv%init ([25,25], global%model)
call global%set_string (var_str ("$run_id"), &
var_str ("run1"), is_known = .true.)
call global%set_real (var_str ("luminosity"), &
33._default, is_known = .true.)
call syntax_pexpr_init ()
cut_expr_text = "all Pt > 100 [s]"
call ifile_append (ifile, cut_expr_text)
call stream_init (stream, ifile)
call parse_tree_init_lexpr (parse_tree, stream, .true.)
global%pn%cuts_lexpr => parse_tree%get_root_ptr ()
allocate (global%sample_fmt (2))
global%sample_fmt(1) = "foo_fmt"
global%sample_fmt(2) = "bar_fmt"
call global%write (u)
call parse_tree_final (parse_tree)
call stream_final (stream)
call ifile_final (ifile)
call syntax_pexpr_final ()
call global%final ()
call syntax_model_file_final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: rt_data_2"
end subroutine rt_data_2
@ %def rt_data_2
@
\subsubsection{Save and restore}
Set up a local runtime data block, change some contents, restore the
global block.
<<RT data: execute tests>>=
call test (rt_data_3, "rt_data_3", &
"save/restore", &
u, results)
<<RT data: test declarations>>=
public :: rt_data_3
<<RT data: tests>>=
subroutine rt_data_3 (u)
use event_base, only: event_callback_nop_t
integer, intent(in) :: u
type(rt_data_t), target :: global, local
type(flavor_t), dimension(2) :: flv
type(string_t) :: cut_expr_text
type(ifile_t) :: ifile
type(stream_t) :: stream
type(parse_tree_t) :: parse_tree
type(prclib_entry_t), pointer :: lib
type(event_callback_nop_t) :: event_callback_nop
write (u, "(A)") "* Test output: rt_data_3"
write (u, "(A)") "* Purpose: initialize global runtime data &
&and fill contents;"
write (u, "(A)") "* copy to local block and back"
write (u, "(A)")
write (u, "(A)") "* Init global data"
write (u, "(A)")
call syntax_model_file_init ()
call global%global_init ()
call fix_system_dependencies (global)
call global%set_int (var_str ("seed"), &
0, is_known=.true.)
call global%select_model (var_str ("Test"))
call global%set_real (var_str ("sqrts"),&
1000._default, is_known = .true.)
call flv%init ([25,25], global%model)
call global%beam_structure%init_sf (flv%get_name (), [1])
call global%beam_structure%set_sf (1, 1, var_str ("pdf_builtin"))
call global%set_string (var_str ("$run_id"), &
var_str ("run1"), is_known = .true.)
call global%set_real (var_str ("luminosity"), &
33._default, is_known = .true.)
call syntax_pexpr_init ()
cut_expr_text = "all Pt > 100 [s]"
call ifile_append (ifile, cut_expr_text)
call stream_init (stream, ifile)
call parse_tree_init_lexpr (parse_tree, stream, .true.)
global%pn%cuts_lexpr => parse_tree%get_root_ptr ()
allocate (global%sample_fmt (2))
global%sample_fmt(1) = "foo_fmt"
global%sample_fmt(2) = "bar_fmt"
allocate (lib)
call lib%init (var_str ("library_1"))
call global%add_prclib (lib)
write (u, "(A)") "* Init and modify local data"
write (u, "(A)")
call local%local_init (global)
call local%append_string (var_str ("$integration_method"), intrinsic=.true.)
call local%append_string (var_str ("$phs_method"), intrinsic=.true.)
call local%activate ()
write (u, "(1x,A,L1)") "model associated = ", associated (local%model)
write (u, "(1x,A,L1)") "library associated = ", associated (local%prclib)
write (u, *)
call local%model_set_real (var_str ("ms"), 150._default)
call local%set_string (var_str ("$integration_method"), &
var_str ("midpoint"), is_known = .true.)
call local%set_string (var_str ("$phs_method"), &
var_str ("single"), is_known = .true.)
local%os_data%fc = "Local compiler"
allocate (lib)
call lib%init (var_str ("library_2"))
call local%add_prclib (lib)
call local%set_event_callback (event_callback_nop)
call local%write (u)
write (u, "(A)")
write (u, "(A)") "* Restore global data"
write (u, "(A)")
call local%deactivate (global)
write (u, "(1x,A,L1)") "model associated = ", associated (global%model)
write (u, "(1x,A,L1)") "library associated = ", associated (global%prclib)
write (u, *)
call global%write (u)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call parse_tree_final (parse_tree)
call stream_final (stream)
call ifile_final (ifile)
call syntax_pexpr_final ()
call global%final ()
call syntax_model_file_final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: rt_data_3"
end subroutine rt_data_3
@ %def rt_data_3
@
\subsubsection{Show variables}
Display selected variables in the global record.
<<RT data: execute tests>>=
call test (rt_data_4, "rt_data_4", &
"show variables", &
u, results)
<<RT data: test declarations>>=
public :: rt_data_4
<<RT data: tests>>=
subroutine rt_data_4 (u)
integer, intent(in) :: u
type(rt_data_t), target :: global
type(string_t), dimension(0) :: empty_string_array
write (u, "(A)") "* Test output: rt_data_4"
write (u, "(A)") "* Purpose: display selected variables"
write (u, "(A)")
call global%global_init ()
write (u, "(A)") "* No variables:"
write (u, "(A)")
call global%write_vars (u, empty_string_array)
write (u, "(A)") "* Two variables:"
write (u, "(A)")
call global%write_vars (u, &
[var_str ("?unweighted"), var_str ("$phs_method")])
write (u, "(A)")
write (u, "(A)") "* Display whole record with selected variables"
write (u, "(A)")
call global%write (u, &
vars = [var_str ("?unweighted"), var_str ("$phs_method")])
call global%final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: rt_data_4"
end subroutine rt_data_4
@ %def rt_data_4
@
\subsubsection{Show parts}
Display only selected parts in the state just after (global) initialization.
<<RT data: execute tests>>=
call test (rt_data_5, "rt_data_5", &
"show parts", &
u, results)
<<RT data: test declarations>>=
public :: rt_data_5
<<RT data: tests>>=
subroutine rt_data_5 (u)
integer, intent(in) :: u
type(rt_data_t), target :: global
write (u, "(A)") "* Test output: rt_data_5"
write (u, "(A)") "* Purpose: display parts of rt data"
write (u, "(A)")
call global%global_init ()
call global%write_libraries (u)
write (u, "(A)")
call global%write_beams (u)
write (u, "(A)")
call global%write_process_stack (u)
call global%final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: rt_data_5"
end subroutine rt_data_5
@ %def rt_data_5
@
\subsubsection{Local Model}
Locally modify a model and restore the global one. We need an auxiliary
function to determine the status of a model particle:
<<RT data: test auxiliary>>=
function is_stable (pdg, global) result (flag)
integer, intent(in) :: pdg
type(rt_data_t), intent(in) :: global
logical :: flag
type(flavor_t) :: flv
call flv%init (pdg, global%model)
flag = flv%is_stable ()
end function is_stable
function is_polarized (pdg, global) result (flag)
integer, intent(in) :: pdg
type(rt_data_t), intent(in) :: global
logical :: flag
type(flavor_t) :: flv
call flv%init (pdg, global%model)
flag = flv%is_polarized ()
end function is_polarized
@ %def is_stable is_polarized
<<RT data: execute tests>>=
call test (rt_data_6, "rt_data_6", &
"local model", &
u, results)
<<RT data: test declarations>>=
public :: rt_data_6
<<RT data: tests>>=
subroutine rt_data_6 (u)
integer, intent(in) :: u
type(rt_data_t), target :: global, local
type(var_list_t), pointer :: model_vars
type(string_t) :: var_name
write (u, "(A)") "* Test output: rt_data_6"
write (u, "(A)") "* Purpose: apply and keep local modifications to model"
write (u, "(A)")
call syntax_model_file_init ()
call global%global_init ()
call global%select_model (var_str ("Test"))
write (u, "(A)") "* Original model"
write (u, "(A)")
call global%write_model_list (u)
write (u, *)
write (u, "(A,L1)") "s is stable = ", is_stable (25, global)
write (u, "(A,L1)") "f is polarized = ", is_polarized (6, global)
write (u, *)
var_name = "ff"
write (u, "(A)", advance="no") "Global model variable: "
model_vars => global%model%get_var_list_ptr ()
call model_vars%write_var (var_name, u)
write (u, "(A)")
write (u, "(A)") "* Apply local modifications: unstable"
write (u, "(A)")
call local%local_init (global)
call local%activate ()
call local%model_set_real (var_name, 0.4_default)
call local%modify_particle (25, stable = .false., decay = [var_str ("d1")])
call local%modify_particle (6, stable = .false., &
decay = [var_str ("f1")], isotropic_decay = .true.)
call local%modify_particle (-6, stable = .false., &
decay = [var_str ("f2"), var_str ("f3")], diagonal_decay = .true.)
call local%model%write (u)
write (u, "(A)")
write (u, "(A)") "* Further modifications"
write (u, "(A)")
call local%modify_particle (6, stable = .false., &
decay = [var_str ("f1")], &
diagonal_decay = .true., isotropic_decay = .false.)
call local%modify_particle (-6, stable = .false., &
decay = [var_str ("f2"), var_str ("f3")], &
diagonal_decay = .false., isotropic_decay = .true.)
call local%model%write (u)
write (u, "(A)")
write (u, "(A)") "* Further modifications: f stable but polarized"
write (u, "(A)")
call local%modify_particle (6, stable = .true., polarized = .true.)
call local%modify_particle (-6, stable = .true.)
call local%model%write (u)
write (u, "(A)")
write (u, "(A)") "* Global model"
write (u, "(A)")
call global%model%write (u)
write (u, *)
write (u, "(A,L1)") "s is stable = ", is_stable (25, global)
write (u, "(A,L1)") "f is polarized = ", is_polarized (6, global)
write (u, "(A)")
write (u, "(A)") "* Local model"
write (u, "(A)")
call local%model%write (u)
write (u, *)
write (u, "(A,L1)") "s is stable = ", is_stable (25, local)
write (u, "(A,L1)") "f is polarized = ", is_polarized (6, local)
write (u, *)
write (u, "(A)", advance="no") "Global model variable: "
model_vars => global%model%get_var_list_ptr ()
call model_vars%write_var (var_name, u)
write (u, "(A)", advance="no") "Local model variable: "
associate (model_var_list_ptr => local%model%get_var_list_ptr())
call model_var_list_ptr%write_var (var_name, u)
end associate
write (u, "(A)")
write (u, "(A)") "* Restore global"
call local%deactivate (global, keep_local = .true.)
write (u, "(A)")
write (u, "(A)") "* Global model"
write (u, "(A)")
call global%model%write (u)
write (u, *)
write (u, "(A,L1)") "s is stable = ", is_stable (25, global)
write (u, "(A,L1)") "f is polarized = ", is_polarized (6, global)
write (u, "(A)")
write (u, "(A)") "* Local model"
write (u, "(A)")
call local%model%write (u)
write (u, *)
write (u, "(A,L1)") "s is stable = ", is_stable (25, local)
write (u, "(A,L1)") "f is polarized = ", is_polarized (6, local)
write (u, *)
write (u, "(A)", advance="no") "Global model variable: "
model_vars => global%model%get_var_list_ptr ()
call model_vars%write_var (var_name, u)
write (u, "(A)", advance="no") "Local model variable: "
associate (model_var_list_ptr => local%model%get_var_list_ptr())
call model_var_list_ptr%write_var (var_name, u)
end associate
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call local%model%final ()
deallocate (local%model)
call global%final ()
call syntax_model_file_final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: rt_data_6"
end subroutine rt_data_6
@ %def rt_data_6
@
\subsubsection{Result variables}
Initialize result variables and check that they are accessible via the
global variable list.
<<RT data: execute tests>>=
call test (rt_data_7, "rt_data_7", &
"result variables", &
u, results)
<<RT data: test declarations>>=
public :: rt_data_7
<<RT data: tests>>=
subroutine rt_data_7 (u)
integer, intent(in) :: u
type(rt_data_t), target :: global
write (u, "(A)") "* Test output: rt_data_7"
write (u, "(A)") "* Purpose: set and access result variables"
write (u, "(A)")
write (u, "(A)") "* Initialize process variables"
write (u, "(A)")
call global%global_init ()
call global%process_stack%init_result_vars (var_str ("testproc"))
call global%var_list%write_var (&
var_str ("integral(testproc)"), u, defined=.true.)
call global%var_list%write_var (&
var_str ("error(testproc)"), u, defined=.true.)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call global%final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: rt_data_7"
end subroutine rt_data_7
@ %def rt_data_7
@
\subsubsection{Beam energy}
If beam parameters are set, the variable [[sqrts]] is not necessarily
the collision energy. The method [[get_sqrts]] fetches the correct value.
<<RT data: execute tests>>=
call test (rt_data_8, "rt_data_8", &
"beam energy", &
u, results)
<<RT data: test declarations>>=
public :: rt_data_8
<<RT data: tests>>=
subroutine rt_data_8 (u)
integer, intent(in) :: u
type(rt_data_t), target :: global
write (u, "(A)") "* Test output: rt_data_8"
write (u, "(A)") "* Purpose: get correct collision energy"
write (u, "(A)")
write (u, "(A)") "* Initialize"
write (u, "(A)")
call global%global_init ()
write (u, "(A)") "* Set sqrts"
write (u, "(A)")
call global%set_real (var_str ("sqrts"), &
1000._default, is_known = .true.)
write (u, "(1x,A," // FMT_19 // ")") "sqrts =", global%get_sqrts ()
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call global%final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: rt_data_8"
end subroutine rt_data_8
@ %def rt_data_8
@
\subsubsection{Local variable modifications}
<<RT data: execute tests>>=
call test (rt_data_9, "rt_data_9", &
"local variables", &
u, results)
<<RT data: test declarations>>=
public :: rt_data_9
<<RT data: tests>>=
subroutine rt_data_9 (u)
integer, intent(in) :: u
type(rt_data_t), target :: global, local
type(var_list_t), pointer :: var_list
write (u, "(A)") "* Test output: rt_data_9"
write (u, "(A)") "* Purpose: handle local variables"
write (u, "(A)")
call syntax_model_file_init ()
write (u, "(A)") "* Initialize global record and set some variables"
write (u, "(A)")
call global%global_init ()
call global%select_model (var_str ("Test"))
call global%set_real (var_str ("sqrts"), 17._default, is_known = .true.)
call global%set_real (var_str ("luminosity"), 2._default, is_known = .true.)
call global%model_set_real (var_str ("ff"), 0.5_default)
call global%model_set_real (var_str ("gy"), 1.2_default)
var_list => global%get_var_list_ptr ()
call var_list%write_var (var_str ("sqrts"), u, defined=.true.)
call var_list%write_var (var_str ("luminosity"), u, defined=.true.)
call var_list%write_var (var_str ("ff"), u, defined=.true.)
call var_list%write_var (var_str ("gy"), u, defined=.true.)
call var_list%write_var (var_str ("mf"), u, defined=.true.)
call var_list%write_var (var_str ("x"), u, defined=.true.)
write (u, "(A)")
write (u, "(1x,A,1x,F5.2)") "sqrts = ", &
global%get_rval (var_str ("sqrts"))
write (u, "(1x,A,1x,F5.2)") "luminosity = ", &
global%get_rval (var_str ("luminosity"))
write (u, "(1x,A,1x,F5.2)") "ff = ", &
global%get_rval (var_str ("ff"))
write (u, "(1x,A,1x,F5.2)") "gy = ", &
global%get_rval (var_str ("gy"))
write (u, "(1x,A,1x,F5.2)") "mf = ", &
global%get_rval (var_str ("mf"))
write (u, "(1x,A,1x,F5.2)") "x = ", &
global%get_rval (var_str ("x"))
write (u, "(A)")
write (u, "(A)") "* Create local record with local variables"
write (u, "(A)")
call local%local_init (global)
call local%append_real (var_str ("luminosity"), intrinsic = .true.)
call local%append_real (var_str ("x"), user = .true.)
call local%activate ()
var_list => local%get_var_list_ptr ()
call var_list%write_var (var_str ("sqrts"), u)
call var_list%write_var (var_str ("luminosity"), u)
call var_list%write_var (var_str ("ff"), u)
call var_list%write_var (var_str ("gy"), u)
call var_list%write_var (var_str ("mf"), u)
call var_list%write_var (var_str ("x"), u, defined=.true.)
write (u, "(A)")
write (u, "(1x,A,1x,F5.2)") "sqrts = ", &
local%get_rval (var_str ("sqrts"))
write (u, "(1x,A,1x,F5.2)") "luminosity = ", &
local%get_rval (var_str ("luminosity"))
write (u, "(1x,A,1x,F5.2)") "ff = ", &
local%get_rval (var_str ("ff"))
write (u, "(1x,A,1x,F5.2)") "gy = ", &
local%get_rval (var_str ("gy"))
write (u, "(1x,A,1x,F5.2)") "mf = ", &
local%get_rval (var_str ("mf"))
write (u, "(1x,A,1x,F5.2)") "x = ", &
local%get_rval (var_str ("x"))
write (u, "(A)")
write (u, "(A)") "* Modify some local variables"
write (u, "(A)")
call local%set_real (var_str ("luminosity"), 42._default, is_known=.true.)
call local%set_real (var_str ("x"), 6.66_default, is_known=.true.)
call local%model_set_real (var_str ("ff"), 0.7_default)
var_list => local%get_var_list_ptr ()
call var_list%write_var (var_str ("sqrts"), u)
call var_list%write_var (var_str ("luminosity"), u)
call var_list%write_var (var_str ("ff"), u)
call var_list%write_var (var_str ("gy"), u)
call var_list%write_var (var_str ("mf"), u)
call var_list%write_var (var_str ("x"), u, defined=.true.)
write (u, "(A)")
write (u, "(1x,A,1x,F5.2)") "sqrts = ", &
local%get_rval (var_str ("sqrts"))
write (u, "(1x,A,1x,F5.2)") "luminosity = ", &
local%get_rval (var_str ("luminosity"))
write (u, "(1x,A,1x,F5.2)") "ff = ", &
local%get_rval (var_str ("ff"))
write (u, "(1x,A,1x,F5.2)") "gy = ", &
local%get_rval (var_str ("gy"))
write (u, "(1x,A,1x,F5.2)") "mf = ", &
local%get_rval (var_str ("mf"))
write (u, "(1x,A,1x,F5.2)") "x = ", &
local%get_rval (var_str ("x"))
write (u, "(A)")
write (u, "(A)") "* Restore globals"
write (u, "(A)")
call local%deactivate (global)
var_list => global%get_var_list_ptr ()
call var_list%write_var (var_str ("sqrts"), u)
call var_list%write_var (var_str ("luminosity"), u)
call var_list%write_var (var_str ("ff"), u)
call var_list%write_var (var_str ("gy"), u)
call var_list%write_var (var_str ("mf"), u)
call var_list%write_var (var_str ("x"), u, defined=.true.)
write (u, "(A)")
write (u, "(1x,A,1x,F5.2)") "sqrts = ", &
global%get_rval (var_str ("sqrts"))
write (u, "(1x,A,1x,F5.2)") "luminosity = ", &
global%get_rval (var_str ("luminosity"))
write (u, "(1x,A,1x,F5.2)") "ff = ", &
global%get_rval (var_str ("ff"))
write (u, "(1x,A,1x,F5.2)") "gy = ", &
global%get_rval (var_str ("gy"))
write (u, "(1x,A,1x,F5.2)") "mf = ", &
global%get_rval (var_str ("mf"))
write (u, "(1x,A,1x,F5.2)") "x = ", &
global%get_rval (var_str ("x"))
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call local%local_final ()
call global%final ()
call syntax_model_file_final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: rt_data_9"
end subroutine rt_data_9
@ %def rt_data_9
@
\subsubsection{Descriptions}
<<RT data: execute tests>>=
call test(rt_data_10, "rt_data_10", &
"descriptions", u, results)
<<RT data: test declarations>>=
public :: rt_data_10
<<RT data: tests>>=
subroutine rt_data_10 (u)
integer, intent(in) :: u
type(rt_data_t) :: global
! type(var_list_t) :: var_list
write (u, "(A)") "* Test output: rt_data_10"
write (u, "(A)") "* Purpose: display descriptions"
write (u, "(A)")
call global%var_list%append_real (var_str ("sqrts"), &
intrinsic=.true., &
description=var_str ('Real variable in order to set the center-of-mass ' // &
'energy for the collisions.'))
call global%var_list%append_real (var_str ("luminosity"), 0._default, &
intrinsic=.true., &
description=var_str ('This specifier \ttt{luminosity = {\em ' // &
'<num>}} sets the integrated luminosity (in inverse femtobarns, ' // &
'fb${}^{-1}$) for the event generation of the processes in the ' // &
'\sindarin\ input files.'))
call global%var_list%append_int (var_str ("seed"), 1234, &
intrinsic=.true., &
description=var_str ('Integer variable \ttt{seed = {\em <num>}} ' // &
'that allows to set a specific random seed \ttt{num}.'))
call global%var_list%append_string (var_str ("$method"), var_str ("omega"), &
intrinsic=.true., &
description=var_str ('This string variable specifies the method ' // &
'for the matrix elements to be used in the evaluation.'))
call global%var_list%append_log (var_str ("?read_color_factors"), .true., &
intrinsic=.true., &
description=var_str ('This flag decides whether to read QCD ' // &
'color factors from the matrix element provided by each method, ' // &
'or to try and calculate the color factors in \whizard\ internally.'))
call global%var_list%sort ()
call global%write_var_descriptions (u)
call global%final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: rt_data_10"
end subroutine rt_data_10
@ %def rt_data_10
@
\subsubsection{Export objects}
Export objects are variables or other data that should be copied or otherwise
applied to corresponding objects in the outer scope.
We test appending and retrieval for the export list.
<<RT data: execute tests>>=
call test(rt_data_11, "rt_data_11", &
"export objects", u, results)
<<RT data: test declarations>>=
public :: rt_data_11
<<RT data: tests>>=
subroutine rt_data_11 (u)
integer, intent(in) :: u
type(rt_data_t) :: global
type(string_t), dimension(:), allocatable :: exports
integer :: i
write (u, "(A)") "* Test output: rt_data_11"
write (u, "(A)") "* Purpose: handle export object list"
write (u, "(A)")
write (u, "(A)") "* Empty export list"
write (u, "(A)")
call global%write_exports (u)
write (u, "(A)") "* Add an entry"
write (u, "(A)")
allocate (exports (1))
exports(1) = var_str ("results")
do i = 1, size (exports)
write (u, "('+ ',A)") char (exports(i))
end do
write (u, *)
call global%append_exports (exports)
call global%write_exports (u)
write (u, "(A)")
write (u, "(A)") "* Add more entries, including doubler"
write (u, "(A)")
deallocate (exports)
allocate (exports (3))
exports(1) = var_str ("foo")
exports(2) = var_str ("results")
exports(3) = var_str ("bar")
do i = 1, size (exports)
write (u, "('+ ',A)") char (exports(i))
end do
write (u, *)
call global%append_exports (exports)
call global%write_exports (u)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call global%final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: rt_data_11"
end subroutine rt_data_11
@ %def rt_data_11
@
@
\clearpage
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{Select implementations}
For abstract types (process core, integrator, phase space, etc.), we need a
way to dynamically select a concrete type, using either data given by the user
or a previous selection of a concrete type. This is done by subroutines in
the current module.
We would like to put this in the [[me_methods]] folder but it also
depends on [[gosam]] and [[openloops]], so it is unclear where to put
it.
<<[[dispatch_me_methods.f90]]>>=
<<File header>>
module dispatch_me_methods
<<Use strings>>
<<Use debug>>
use physics_defs, only: BORN
use diagnostics
use sm_qcd
use variables, only: var_list_t
use models
use model_data
use prc_core_def
use prc_core
use prc_test_core
use prc_template_me
use prc_test
use prc_omega
use prc_external
use prc_gosam
use prc_openloops
use prc_recola
use prc_threshold
<<Standard module head>>
<<Dispatch me methods: public>>
contains
<<Dispatch me methods: procedures>>
end module dispatch_me_methods
@ %def dispatch_me_methods
@
\subsection{Process Core Definition}
The [[prc_core_def_t]] abstract type can be instantiated by providing a
[[$method]] string variable.
<<Dispatch me methods: public>>=
public :: dispatch_core_def
<<Dispatch me methods: procedures>>=
subroutine dispatch_core_def (core_def, prt_in, prt_out, &
model, var_list, id, nlo_type, method)
class(prc_core_def_t), allocatable, intent(out) :: core_def
type(string_t), dimension(:), intent(in) :: prt_in
type(string_t), dimension(:), intent(in) :: prt_out
type(model_t), pointer, intent(in) :: model
type(var_list_t), intent(in) :: var_list
type(string_t), intent(in), optional :: id
integer, intent(in), optional :: nlo_type
type(string_t), intent(in), optional :: method
type(string_t) :: model_name, meth
type(string_t) :: ufo_path
type(string_t) :: restrictions
logical :: ufo
logical :: cms_scheme
logical :: openmp_support
logical :: report_progress
logical :: diags, diags_color
logical :: write_phs_output
type(string_t) :: extra_options, correction_type
integer :: nlo
integer :: alpha_power
integer :: alphas_power
if (present (method)) then
meth = method
else
meth = var_list%get_sval (var_str ("$method"))
end if
if (debug_on) call msg_debug2 (D_CORE, "dispatch_core_def")
if (associated (model)) then
model_name = model%get_name ()
cms_scheme = model%get_scheme () == "Complex_Mass_Scheme"
ufo = model%is_ufo_model ()
ufo_path = model%get_ufo_path ()
else
model_name = ""
cms_scheme = .false.
ufo = .false.
end if
restrictions = var_list%get_sval (&
var_str ("$restrictions"))
diags = var_list%get_lval (&
var_str ("?vis_diags"))
diags_color = var_list%get_lval (&
var_str ("?vis_diags_color"))
openmp_support = var_list%get_lval (&
var_str ("?omega_openmp"))
report_progress = var_list%get_lval (&
var_str ("?report_progress"))
write_phs_output = var_list%get_lval (&
var_str ("?omega_write_phs_output"))
extra_options = var_list%get_sval (&
var_str ("$omega_flags"))
nlo = BORN; if (present (nlo_type)) nlo = nlo_type
alpha_power = var_list%get_ival (var_str ("alpha_power"))
alphas_power = var_list%get_ival (var_str ("alphas_power"))
correction_type = var_list%get_sval (var_str ("$nlo_correction_type"))
if (debug_on) call msg_debug2 (D_CORE, "dispatching core method: ", meth)
select case (char (meth))
case ("unit_test")
allocate (prc_test_def_t :: core_def)
select type (core_def)
type is (prc_test_def_t)
call core_def%init (model_name, prt_in, prt_out)
end select
case ("template")
allocate (template_me_def_t :: core_def)
select type (core_def)
type is (template_me_def_t)
call core_def%init (model, prt_in, prt_out, unity = .false.)
end select
case ("template_unity")
allocate (template_me_def_t :: core_def)
select type (core_def)
type is (template_me_def_t)
call core_def%init (model, prt_in, prt_out, unity = .true.)
end select
case ("omega")
allocate (omega_def_t :: core_def)
select type (core_def)
type is (omega_def_t)
call core_def%init (model_name, prt_in, prt_out, &
.false., ufo, ufo_path, &
restrictions, cms_scheme, &
openmp_support, report_progress, write_phs_output, &
extra_options, diags, diags_color)
end select
case ("ovm")
allocate (omega_def_t :: core_def)
select type (core_def)
type is (omega_def_t)
call core_def%init (model_name, prt_in, prt_out, &
.true., .false., var_str (""), &
restrictions, cms_scheme, &
openmp_support, report_progress, write_phs_output, &
extra_options, diags, diags_color)
end select
case ("gosam")
allocate (gosam_def_t :: core_def)
select type (core_def)
type is (gosam_def_t)
if (present (id)) then
call core_def%init (id, model_name, prt_in, &
prt_out, nlo, restrictions, var_list)
else
call msg_fatal ("Dispatch GoSam def: No id!")
end if
end select
case ("openloops")
allocate (openloops_def_t :: core_def)
select type (core_def)
type is (openloops_def_t)
if (present (id)) then
call core_def%init (id, model_name, prt_in, &
prt_out, nlo, restrictions, var_list)
else
call msg_fatal ("Dispatch OpenLoops def: No id!")
end if
end select
case ("recola")
call abort_if_recola_not_active ()
allocate (recola_def_t :: core_def)
select type (core_def)
type is (recola_def_t)
if (present (id)) then
call core_def%init (id, model_name, prt_in, prt_out, &
nlo, alpha_power, alphas_power, correction_type, &
restrictions)
else
call msg_fatal ("Dispatch RECOLA def: No id!")
end if
end select
case ("dummy")
allocate (prc_external_test_def_t :: core_def)
select type (core_def)
type is (prc_external_test_def_t)
if (present (id)) then
call core_def%init (id, model_name, prt_in, prt_out)
else
call msg_fatal ("Dispatch User-Defined Test def: No id!")
end if
end select
case ("threshold")
allocate (threshold_def_t :: core_def)
select type (core_def)
type is (threshold_def_t)
if (present (id)) then
call core_def%init (id, model_name, prt_in, prt_out, &
nlo, restrictions)
else
call msg_fatal ("Dispatch Threshold def: No id!")
end if
end select
case default
call msg_fatal ("Process configuration: method '" &
// char (meth) // "' not implemented")
end select
end subroutine dispatch_core_def
@ %def dispatch_core_def
@
\subsection{Process core allocation}
Here we allocate an object of abstract type [[prc_core_t]] with a concrete
type that matches a process definition. The [[prc_omega_t]] extension
will require the current parameter set, so we take the opportunity to
grab it from the model.
<<Dispatch me methods: public>>=
public :: dispatch_core
<<Dispatch me methods: procedures>>=
subroutine dispatch_core (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
select type (core_def)
type is (prc_test_def_t)
allocate (test_t :: core)
type is (template_me_def_t)
allocate (prc_template_me_t :: core)
select type (core)
type is (prc_template_me_t)
call core%set_parameters (model)
end select
class is (omega_def_t)
if (.not. allocated (core)) allocate (prc_omega_t :: core)
select type (core)
type is (prc_omega_t)
call core%set_parameters (model, &
helicity_selection, qcd, use_color_factors)
end select
type is (gosam_def_t)
if (.not. allocated (core)) allocate (prc_gosam_t :: core)
select type (core)
type is (prc_gosam_t)
call core%set_parameters (qcd)
end select
type is (openloops_def_t)
if (.not. allocated (core)) allocate (prc_openloops_t :: core)
select type (core)
type is (prc_openloops_t)
call core%set_parameters (qcd)
end select
type is (recola_def_t)
if (.not. allocated (core)) allocate (prc_recola_t :: core)
select type (core)
type is (prc_recola_t)
call core%set_parameters (qcd, model)
end select
type is (prc_external_test_def_t)
if (.not. allocated (core)) allocate (prc_external_test_t :: core)
select type (core)
type is (prc_external_test_t)
call core%set_parameters (qcd, model)
end select
type is (threshold_def_t)
if (.not. allocated (core)) allocate (prc_threshold_t :: core)
select type (core)
type is (prc_threshold_t)
call core%set_parameters (qcd, model)
call core%set_beam_pol (has_beam_pol)
end select
class default
call msg_bug ("Process core: unexpected process definition type")
end select
end subroutine dispatch_core
@ %def dispatch_core
@
\subsection{Process core update and restoration}
Here we take an existing object of abstract type [[prc_core_t]] and
update the parameters as given by the current state of [[model]].
Optionally, we can save the previous state as [[saved_core]]. The
second routine restores the original from the save.
(In the test case, there is no possible update.)
<<Dispatch me methods: public>>=
public :: dispatch_core_update
public :: dispatch_core_restore
<<Dispatch me methods: procedures>>=
subroutine dispatch_core_update &
(core, model, helicity_selection, qcd, saved_core)
class(prc_core_t), allocatable, intent(inout) :: core
class(model_data_t), intent(in), optional, target :: model
type(helicity_selection_t), intent(in), optional :: helicity_selection
type(qcd_t), intent(in), optional :: qcd
class(prc_core_t), allocatable, intent(inout), optional :: saved_core
if (present (saved_core)) then
allocate (saved_core, source = core)
end if
select type (core)
type is (test_t)
type is (prc_omega_t)
call core%set_parameters (model, helicity_selection, qcd)
call core%activate_parameters ()
class is (prc_external_t)
call msg_message ("Updating user defined cores is not implemented yet.")
class default
call msg_bug ("Process core update: unexpected process definition type")
end select
end subroutine dispatch_core_update
subroutine dispatch_core_restore (core, saved_core)
class(prc_core_t), allocatable, intent(inout) :: core
class(prc_core_t), allocatable, intent(inout) :: saved_core
call move_alloc (from = saved_core, to = core)
select type (core)
type is (test_t)
type is (prc_omega_t)
call core%activate_parameters ()
class default
call msg_bug ("Process core restore: unexpected process definition type")
end select
end subroutine dispatch_core_restore
@ %def dispatch_core_update dispatch_core_restore
@
\subsection{Unit Tests}
Test module, followed by the corresponding implementation module.
<<[[dispatch_ut.f90]]>>=
<<File header>>
module dispatch_ut
use unit_tests
use dispatch_uti
<<Standard module head>>
<<Dispatch: public test>>
<<Dispatch: public test auxiliary>>
contains
<<Dispatch: test driver>>
end module dispatch_ut
@ %def dispatch_ut
@
<<[[dispatch_uti.f90]]>>=
<<File header>>
module dispatch_uti
<<Use kinds>>
<<Use strings>>
use os_interface, only: os_data_t
use physics_defs, only: ELECTRON, PROTON
use sm_qcd, only: qcd_t
use flavors, only: flavor_t
use interactions, only: reset_interaction_counter
use pdg_arrays, only: pdg_array_t, assignment(=)
use prc_core_def, only: prc_core_def_t
use prc_test_core, only: test_t
use prc_core, only: prc_core_t
use prc_test, only: prc_test_def_t
use prc_omega, only: omega_def_t, prc_omega_t
use sf_mappings, only: sf_channel_t
use sf_base, only: sf_data_t, sf_config_t
use phs_base, only: phs_channel_collection_t
use variables, only: var_list_t
use model_data, only: model_data_t
use models, only: syntax_model_file_init, syntax_model_file_final
use rt_data, only: rt_data_t
use dispatch_phase_space, only: dispatch_sf_channels
use dispatch_beams, only: sf_prop_t, dispatch_qcd
use dispatch_beams, only: dispatch_sf_config, dispatch_sf_data
use dispatch_me_methods, only: dispatch_core_def, dispatch_core
use dispatch_me_methods, only: dispatch_core_update, dispatch_core_restore
use sf_base_ut, only: sf_test_data_t
<<Standard module head>>
<<Dispatch: public test auxiliary>>
<<Dispatch: test declarations>>
contains
<<Dispatch: tests>>
<<Dispatch: test auxiliary>>
end module dispatch_uti
@ %def dispatch_uti
@ API: driver for the unit tests below.
<<Dispatch: public test>>=
public :: dispatch_test
<<Dispatch: test driver>>=
subroutine dispatch_test (u, results)
integer, intent(in) :: u
type(test_results_t), intent(inout) :: results
<<Dispatch: execute tests>>
end subroutine dispatch_test
@ %def dispatch_test
@
\subsubsection{Select type: process definition}
<<Dispatch: execute tests>>=
call test (dispatch_1, "dispatch_1", &
"process configuration method", &
u, results)
<<Dispatch: test declarations>>=
public :: dispatch_1
<<Dispatch: tests>>=
subroutine dispatch_1 (u)
integer, intent(in) :: u
type(string_t), dimension(2) :: prt_in, prt_out
type(rt_data_t), target :: global
class(prc_core_def_t), allocatable :: core_def
write (u, "(A)") "* Test output: dispatch_1"
write (u, "(A)") "* Purpose: select process configuration method"
write (u, "(A)")
call global%global_init ()
call global%set_log (var_str ("?omega_openmp"), &
.false., is_known = .true.)
prt_in = [var_str ("a"), var_str ("b")]
prt_out = [var_str ("c"), var_str ("d")]
write (u, "(A)") "* Allocate core_def as prc_test_def"
call global%set_string (var_str ("$method"), &
var_str ("unit_test"), is_known = .true.)
call dispatch_core_def (core_def, prt_in, prt_out, global%model, global%var_list)
select type (core_def)
type is (prc_test_def_t)
call core_def%write (u)
end select
deallocate (core_def)
write (u, "(A)")
write (u, "(A)") "* Allocate core_def as omega_def"
write (u, "(A)")
call global%set_string (var_str ("$method"), &
var_str ("omega"), is_known = .true.)
call dispatch_core_def (core_def, prt_in, prt_out, global%model, global%var_list)
select type (core_def)
type is (omega_def_t)
call core_def%write (u)
end select
call global%final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: dispatch_1"
end subroutine dispatch_1
@ %def dispatch_1
@
\subsubsection{Select type: process core}
<<Dispatch: execute tests>>=
call test (dispatch_2, "dispatch_2", &
"process core", &
u, results)
<<Dispatch: test declarations>>=
public :: dispatch_2
<<Dispatch: tests>>=
subroutine dispatch_2 (u)
integer, intent(in) :: u
type(string_t), dimension(2) :: prt_in, prt_out
type(rt_data_t), target :: global
class(prc_core_def_t), allocatable :: core_def
class(prc_core_t), allocatable :: core
write (u, "(A)") "* Test output: dispatch_2"
write (u, "(A)") "* Purpose: select process configuration method"
write (u, "(A)") " and allocate process core"
write (u, "(A)")
call syntax_model_file_init ()
call global%global_init ()
prt_in = [var_str ("a"), var_str ("b")]
prt_out = [var_str ("c"), var_str ("d")]
write (u, "(A)") "* Allocate core as test_t"
write (u, "(A)")
call global%set_string (var_str ("$method"), &
var_str ("unit_test"), is_known = .true.)
call dispatch_core_def (core_def, prt_in, prt_out, global%model, global%var_list)
call dispatch_core (core, core_def)
select type (core)
type is (test_t)
call core%write (u)
end select
deallocate (core)
deallocate (core_def)
write (u, "(A)")
write (u, "(A)") "* Allocate core as prc_omega_t"
write (u, "(A)")
call global%set_string (var_str ("$method"), &
var_str ("omega"), is_known = .true.)
call dispatch_core_def (core_def, prt_in, prt_out, global%model, global%var_list)
call global%select_model (var_str ("Test"))
call global%set_log (&
var_str ("?helicity_selection_active"), &
.true., is_known = .true.)
call global%set_real (&
var_str ("helicity_selection_threshold"), &
1e9_default, is_known = .true.)
call global%set_int (&
var_str ("helicity_selection_cutoff"), &
10, is_known = .true.)
call dispatch_core (core, core_def, &
global%model, &
global%get_helicity_selection ())
call core_def%allocate_driver (core%driver, var_str (""))
select type (core)
type is (prc_omega_t)
call core%write (u)
end select
call global%final ()
call syntax_model_file_final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: dispatch_2"
end subroutine dispatch_2
@ %def dispatch_2
@
\subsubsection{Select type: structure-function data}
This is an extra dispatcher that enables the test structure
functions. This procedure should be assigned to the
[[dispatch_sf_data_extra]] hook before any tests are executed.
<<Dispatch: public test auxiliary>>=
public :: dispatch_sf_data_test
<<Dispatch: test auxiliary>>=
subroutine dispatch_sf_data_test (data, sf_method, i_beam, sf_prop, &
var_list, var_list_global, model, os_data, sqrts, pdg_in, pdg_prc, polarized)
class(sf_data_t), allocatable, intent(inout) :: data
type(string_t), intent(in) :: sf_method
integer, dimension(:), intent(in) :: i_beam
type(var_list_t), intent(in) :: var_list
type(var_list_t), intent(inout) :: var_list_global
class(model_data_t), target, intent(in) :: model
type(os_data_t), intent(in) :: os_data
real(default), intent(in) :: sqrts
type(pdg_array_t), dimension(:), intent(inout) :: pdg_in
type(pdg_array_t), dimension(:,:), intent(in) :: pdg_prc
type(sf_prop_t), intent(inout) :: sf_prop
logical, intent(in) :: polarized
select case (char (sf_method))
case ("sf_test_0", "sf_test_1")
allocate (sf_test_data_t :: data)
select type (data)
type is (sf_test_data_t)
select case (char (sf_method))
case ("sf_test_0"); call data%init (model, pdg_in(i_beam(1)))
case ("sf_test_1"); call data%init (model, pdg_in(i_beam(1)),&
mode = 1)
end select
end select
end select
end subroutine dispatch_sf_data_test
@ %def dispatch_sf_data_test
@ The actual test. We can't move this to [[beams]] as it depends on
[[model_features]] for the [[model_list_t]].
<<Dispatch: execute tests>>=
call test (dispatch_7, "dispatch_7", &
"structure-function data", &
u, results)
<<Dispatch: test declarations>>=
public :: dispatch_7
<<Dispatch: tests>>=
subroutine dispatch_7 (u)
integer, intent(in) :: u
type(rt_data_t), target :: global
type(os_data_t) :: os_data
type(string_t) :: prt, sf_method
type(sf_prop_t) :: sf_prop
class(sf_data_t), allocatable :: data
type(pdg_array_t), dimension(1) :: pdg_in
type(pdg_array_t), dimension(1,1) :: pdg_prc
type(pdg_array_t), dimension(1) :: pdg_out
integer, dimension(:), allocatable :: pdg1
write (u, "(A)") "* Test output: dispatch_7"
write (u, "(A)") "* Purpose: select and configure &
&structure function data"
write (u, "(A)")
call global%global_init ()
call os_data%init ()
call syntax_model_file_init ()
call global%select_model (var_str ("QCD"))
call reset_interaction_counter ()
call global%set_real (var_str ("sqrts"), &
14000._default, is_known = .true.)
prt = "p"
call global%beam_structure%init_sf ([prt, prt], [1])
pdg_in = 2212
write (u, "(A)") "* Allocate data as sf_pdf_builtin_t"
write (u, "(A)")
sf_method = "pdf_builtin"
call dispatch_sf_data (data, sf_method, [1], sf_prop, &
global%get_var_list_ptr (), global%var_list, &
global%model, global%os_data, global%get_sqrts (), &
pdg_in, pdg_prc, .false.)
call data%write (u)
call data%get_pdg_out (pdg_out)
pdg1 = pdg_out(1)
write (u, "(A)")
write (u, "(1x,A,99(1x,I0))") "PDG(out) = ", pdg1
deallocate (data)
write (u, "(A)")
write (u, "(A)") "* Allocate data for different PDF set"
write (u, "(A)")
pdg_in = 2212
call global%set_string (var_str ("$pdf_builtin_set"), &
var_str ("CTEQ6M"), is_known = .true.)
sf_method = "pdf_builtin"
call dispatch_sf_data (data, sf_method, [1], sf_prop, &
global%get_var_list_ptr (), global%var_list, &
global%model, global%os_data, global%get_sqrts (), &
pdg_in, pdg_prc, .false.)
call data%write (u)
call data%get_pdg_out (pdg_out)
pdg1 = pdg_out(1)
write (u, "(A)")
write (u, "(1x,A,99(1x,I0))") "PDG(out) = ", pdg1
deallocate (data)
call global%final ()
call syntax_model_file_final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: dispatch_7"
end subroutine dispatch_7
@ %def dispatch_7
@
\subsubsection{Beam structure}
The actual test. We can't move this to [[beams]] as it depends on
[[model_features]] for the [[model_list_t]].
<<Dispatch: execute tests>>=
call test (dispatch_8, "dispatch_8", &
"beam structure", &
u, results)
<<Dispatch: test declarations>>=
public :: dispatch_8
<<Dispatch: tests>>=
subroutine dispatch_8 (u)
integer, intent(in) :: u
type(rt_data_t), target :: global
type(os_data_t) :: os_data
type(flavor_t), dimension(2) :: flv
type(sf_config_t), dimension(:), allocatable :: sf_config
type(sf_prop_t) :: sf_prop
type(sf_channel_t), dimension(:), allocatable :: sf_channel
type(phs_channel_collection_t) :: coll
type(string_t) :: sf_string
integer :: i
type(pdg_array_t), dimension (2,1) :: pdg_prc
write (u, "(A)") "* Test output: dispatch_8"
write (u, "(A)") "* Purpose: configure a structure-function chain"
write (u, "(A)")
call global%global_init ()
call os_data%init ()
call syntax_model_file_init ()
call global%select_model (var_str ("QCD"))
write (u, "(A)") "* Allocate LHC beams with PDF builtin"
write (u, "(A)")
call flv(1)%init (PROTON, global%model)
call flv(2)%init (PROTON, global%model)
call reset_interaction_counter ()
call global%set_real (var_str ("sqrts"), &
14000._default, is_known = .true.)
call global%beam_structure%init_sf (flv%get_name (), [1])
call global%beam_structure%set_sf (1, 1, var_str ("pdf_builtin"))
call dispatch_sf_config (sf_config, sf_prop, global%beam_structure, &
global%get_var_list_ptr (), global%var_list, &
global%model, global%os_data, global%get_sqrts (), pdg_prc)
do i = 1, size (sf_config)
call sf_config(i)%write (u)
end do
call dispatch_sf_channels (sf_channel, sf_string, sf_prop, coll, &
global%var_list, global%get_sqrts(), global%beam_structure)
write (u, "(1x,A)") "Mapping configuration:"
do i = 1, size (sf_channel)
write (u, "(2x)", advance = "no")
call sf_channel(i)%write (u)
end do
write (u, "(A)")
write (u, "(A)") "* Allocate ILC beams with CIRCE1"
write (u, "(A)")
call global%select_model (var_str ("QED"))
call flv(1)%init ( ELECTRON, global%model)
call flv(2)%init (-ELECTRON, global%model)
call reset_interaction_counter ()
call global%set_real (var_str ("sqrts"), &
500._default, is_known = .true.)
call global%set_log (var_str ("?circe1_generate"), &
.false., is_known = .true.)
call global%beam_structure%init_sf (flv%get_name (), [1])
call global%beam_structure%set_sf (1, 1, var_str ("circe1"))
call dispatch_sf_config (sf_config, sf_prop, global%beam_structure, &
global%get_var_list_ptr (), global%var_list, &
global%model, global%os_data, global%get_sqrts (), pdg_prc)
do i = 1, size (sf_config)
call sf_config(i)%write (u)
end do
call dispatch_sf_channels (sf_channel, sf_string, sf_prop, coll, &
global%var_list, global%get_sqrts(), global%beam_structure)
write (u, "(1x,A)") "Mapping configuration:"
do i = 1, size (sf_channel)
write (u, "(2x)", advance = "no")
call sf_channel(i)%write (u)
end do
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call global%final ()
call syntax_model_file_final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: dispatch_8"
end subroutine dispatch_8
@ %def dispatch_8
@
\subsubsection{Update process core parameters}
This test dispatches a process core, temporarily modifies parameters,
then restores the original.
<<Dispatch: execute tests>>=
call test (dispatch_10, "dispatch_10", &
"process core update", &
u, results)
<<Dispatch: test declarations>>=
public :: dispatch_10
<<Dispatch: tests>>=
subroutine dispatch_10 (u)
integer, intent(in) :: u
type(string_t), dimension(2) :: prt_in, prt_out
type(rt_data_t), target :: global
class(prc_core_def_t), allocatable :: core_def
class(prc_core_t), allocatable :: core, saved_core
type(var_list_t), pointer :: model_vars
write (u, "(A)") "* Test output: dispatch_10"
write (u, "(A)") "* Purpose: select process configuration method,"
write (u, "(A)") " allocate process core,"
write (u, "(A)") " temporarily reset parameters"
write (u, "(A)")
call syntax_model_file_init ()
call global%global_init ()
prt_in = [var_str ("a"), var_str ("b")]
prt_out = [var_str ("c"), var_str ("d")]
write (u, "(A)") "* Allocate core as prc_omega_t"
write (u, "(A)")
call global%set_string (var_str ("$method"), &
var_str ("omega"), is_known = .true.)
call dispatch_core_def (core_def, prt_in, prt_out, global%model, global%var_list)
call global%select_model (var_str ("Test"))
call dispatch_core (core, core_def, global%model)
call core_def%allocate_driver (core%driver, var_str (""))
select type (core)
type is (prc_omega_t)
call core%write (u)
end select
write (u, "(A)")
write (u, "(A)") "* Update core with modified model and helicity selection"
write (u, "(A)")
model_vars => global%model%get_var_list_ptr ()
call model_vars%set_real (var_str ("gy"), 2._default, &
is_known = .true.)
call global%model%update_parameters ()
call global%set_log (&
var_str ("?helicity_selection_active"), &
.true., is_known = .true.)
call global%set_real (&
var_str ("helicity_selection_threshold"), &
2e10_default, is_known = .true.)
call global%set_int (&
var_str ("helicity_selection_cutoff"), &
5, is_known = .true.)
call dispatch_core_update (core, &
global%model, &
global%get_helicity_selection (), &
saved_core = saved_core)
select type (core)
type is (prc_omega_t)
call core%write (u)
end select
write (u, "(A)")
write (u, "(A)") "* Restore core from save"
write (u, "(A)")
call dispatch_core_restore (core, saved_core)
select type (core)
type is (prc_omega_t)
call core%write (u)
end select
call global%final ()
call syntax_model_file_final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: dispatch_10"
end subroutine dispatch_10
@ %def dispatch_10
@
\subsubsection{QCD Coupling}
This test dispatches an [[qcd]] object, which is used to compute the
(running) coupling by one of several possible methods.
We can't move this to [[beams]] as it depends on
[[model_features]] for the [[model_list_t]].
<<Dispatch: execute tests>>=
call test (dispatch_11, "dispatch_11", &
"QCD coupling", &
u, results)
<<Dispatch: test declarations>>=
public :: dispatch_11
<<Dispatch: tests>>=
subroutine dispatch_11 (u)
integer, intent(in) :: u
type(rt_data_t), target :: global
type(var_list_t), pointer :: model_vars
type(qcd_t) :: qcd
write (u, "(A)") "* Test output: dispatch_11"
write (u, "(A)") "* Purpose: select QCD coupling formula"
write (u, "(A)")
call syntax_model_file_init ()
call global%global_init ()
call global%select_model (var_str ("SM"))
model_vars => global%get_var_list_ptr ()
write (u, "(A)") "* Allocate alpha_s as fixed"
write (u, "(A)")
call global%set_log (var_str ("?alphas_is_fixed"), &
.true., is_known = .true.)
call dispatch_qcd (qcd, global%get_var_list_ptr (), global%os_data)
call qcd%write (u)
write (u, "(A)")
write (u, "(A)") "* Allocate alpha_s as running (built-in)"
write (u, "(A)")
call global%set_log (var_str ("?alphas_is_fixed"), &
.false., is_known = .true.)
call global%set_log (var_str ("?alphas_from_mz"), &
.true., is_known = .true.)
call global%set_int &
(var_str ("alphas_order"), 1, is_known = .true.)
call model_vars%set_real (var_str ("alphas"), 0.1234_default, &
is_known=.true.)
call model_vars%set_real (var_str ("mZ"), 91.234_default, &
is_known=.true.)
call dispatch_qcd (qcd, global%get_var_list_ptr (), global%os_data)
call qcd%write (u)
write (u, "(A)")
write (u, "(A)") "* Allocate alpha_s as running (built-in, Lambda defined)"
write (u, "(A)")
call global%set_log (var_str ("?alphas_from_mz"), &
.false., is_known = .true.)
call global%set_log (&
var_str ("?alphas_from_lambda_qcd"), &
.true., is_known = .true.)
call global%set_real &
(var_str ("lambda_qcd"), 250.e-3_default, &
is_known=.true.)
call global%set_int &
(var_str ("alphas_order"), 2, is_known = .true.)
call global%set_int &
(var_str ("alphas_nf"), 4, is_known = .true.)
call dispatch_qcd (qcd, global%get_var_list_ptr (), global%os_data)
call qcd%write (u)
write (u, "(A)")
write (u, "(A)") "* Allocate alpha_s as running (using builtin PDF set)"
write (u, "(A)")
call global%set_log (&
var_str ("?alphas_from_lambda_qcd"), &
.false., is_known = .true.)
call global%set_log &
(var_str ("?alphas_from_pdf_builtin"), &
.true., is_known = .true.)
call dispatch_qcd (qcd, global%get_var_list_ptr (), global%os_data)
call qcd%write (u)
call global%final ()
call syntax_model_file_final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: dispatch_11"
end subroutine dispatch_11
@ %def dispatch_11
@
\clearpage
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{Process Configuration}
This module communicates between the toplevel command structure with
its runtime data set and the process-library handling modules which
collect the definition of individual processes. Its primary purpose
is to select from the available matrix-element generating methods and
configure the entry in the process library accordingly.
<<[[process_configurations.f90]]>>=
<<File header>>
module process_configurations
<<Use strings>>
<<Use debug>>
use diagnostics
use io_units
use physics_defs, only: BORN, NLO_VIRTUAL, NLO_REAL, NLO_DGLAP, &
NLO_SUBTRACTION, NLO_MISMATCH
use models
use prc_core_def
use particle_specifiers
use process_libraries
use rt_data
use variables, only: var_list_t
use dispatch_me_methods, only: dispatch_core_def
use prc_external, only: prc_external_def_t
<<Standard module head>>
<<Process configurations: public>>
<<Process configurations: types>>
contains
<<Process configurations: procedures>>
end module process_configurations
@ %def process_configurations
@
\subsection{Data Type}
<<Process configurations: public>>=
public :: process_configuration_t
<<Process configurations: types>>=
type :: process_configuration_t
type(process_def_entry_t), pointer :: entry => null ()
type(string_t) :: id
integer :: num_id = 0
contains
<<Process configurations: process configuration: TBP>>
end type process_configuration_t
@ %def process_configuration_t
@ Output (for unit tests).
<<Process configurations: process configuration: TBP>>=
procedure :: write => process_configuration_write
<<Process configurations: procedures>>=
subroutine process_configuration_write (config, unit)
class(process_configuration_t), intent(in) :: config
integer, intent(in), optional :: unit
integer :: u
u = given_output_unit (unit)
write (u, "(A)") "Process configuration:"
if (associated (config%entry)) then
call config%entry%write (u)
else
write (u, "(1x,3A)") "ID = '", char (config%id), "'"
write (u, "(1x,A,1x,I0)") "num ID =", config%num_id
write (u, "(2x,A)") "[no entry]"
end if
end subroutine process_configuration_write
@ %def process_configuration_write
@ Initialize a process. We only need the name, the number of incoming
particles, and the number of components.
<<Process configurations: process configuration: TBP>>=
procedure :: init => process_configuration_init
<<Process configurations: procedures>>=
subroutine process_configuration_init &
(config, prc_name, n_in, n_components, model, var_list, nlo_process)
class(process_configuration_t), intent(out) :: config
type(string_t), intent(in) :: prc_name
integer, intent(in) :: n_in
integer, intent(in) :: n_components
type(model_t), intent(in), pointer :: model
type(var_list_t), intent(in) :: var_list
logical, intent(in), optional :: nlo_process
logical :: nlo_proc
logical :: requires_resonances
if (debug_on) call msg_debug (D_CORE, "process_configuration_init")
config%id = prc_name
if (present (nlo_process)) then
nlo_proc = nlo_process
else
nlo_proc = .false.
end if
requires_resonances = var_list%get_lval (var_str ("?resonance_history"))
if (debug_on) call msg_debug (D_CORE, "nlo_process", nlo_proc)
allocate (config%entry)
if (var_list%is_known (var_str ("process_num_id"))) then
config%num_id = &
var_list%get_ival (var_str ("process_num_id"))
call config%entry%init (prc_name, &
model = model, n_in = n_in, n_components = n_components, &
num_id = config%num_id, &
nlo_process = nlo_proc, &
requires_resonances = requires_resonances)
else
call config%entry%init (prc_name, &
model = model, n_in = n_in, n_components = n_components, &
nlo_process = nlo_proc, &
requires_resonances = requires_resonances)
end if
end subroutine process_configuration_init
@ %def process_configuration_init
@ Initialize a process component. The details depend on the process method,
which determines the type of the process component core. We set the incoming
and outgoing particles (as strings, to be interpreted by the process driver).
All other information is taken from the variable list.
The dispatcher gets only the names of the particles. The process
component definition gets the complete specifiers which contains a
polarization flag and names of decay processes, where applicable.
<<Process configurations: process configuration: TBP>>=
procedure :: setup_component => process_configuration_setup_component
<<Process configurations: procedures>>=
subroutine process_configuration_setup_component &
(config, i_component, prt_in, prt_out, model, var_list, &
nlo_type, can_be_integrated)
class(process_configuration_t), intent(inout) :: config
integer, intent(in) :: i_component
type(prt_spec_t), dimension(:), intent(in) :: prt_in
type(prt_spec_t), dimension(:), intent(in) :: prt_out
type(model_t), pointer, intent(in) :: model
type(var_list_t), intent(in) :: var_list
integer, intent(in), optional :: nlo_type
logical, intent(in), optional :: can_be_integrated
type(string_t), dimension(:), allocatable :: prt_str_in
type(string_t), dimension(:), allocatable :: prt_str_out
class(prc_core_def_t), allocatable :: core_def
type(string_t) :: method
type(string_t) :: born_me_method
type(string_t) :: real_tree_me_method
type(string_t) :: loop_me_method
type(string_t) :: correlation_me_method
type(string_t) :: dglap_me_method
integer :: i
if (debug_on) call msg_debug2 (D_CORE, "process_configuration_setup_component")
allocate (prt_str_in (size (prt_in)))
allocate (prt_str_out (size (prt_out)))
forall (i = 1:size (prt_in)) prt_str_in(i) = prt_in(i)% get_name ()
forall (i = 1:size (prt_out)) prt_str_out(i) = prt_out(i)%get_name ()
method = var_list%get_sval (var_str ("$method"))
if (present (nlo_type)) then
select case (nlo_type)
case (BORN)
born_me_method = var_list%get_sval (var_str ("$born_me_method"))
if (born_me_method /= var_str ("")) then
method = born_me_method
end if
case (NLO_VIRTUAL)
loop_me_method = var_list%get_sval (var_str ("$loop_me_method"))
if (loop_me_method /= var_str ("")) then
method = loop_me_method
end if
case (NLO_REAL)
real_tree_me_method = &
var_list%get_sval (var_str ("$real_tree_me_method"))
if (real_tree_me_method /= var_str ("")) then
method = real_tree_me_method
end if
case (NLO_DGLAP)
dglap_me_method = &
var_list%get_sval (var_str ("$dglap_me_method"))
if (dglap_me_method /= var_str ("")) then
method = dglap_me_method
end if
case (NLO_SUBTRACTION,NLO_MISMATCH)
correlation_me_method = &
var_list%get_sval (var_str ("$correlation_me_method"))
if (correlation_me_method /= var_str ("")) then
method = correlation_me_method
end if
case default
end select
end if
call dispatch_core_def (core_def, prt_str_in, prt_str_out, &
model, var_list, config%id, nlo_type, method)
select type (core_def)
class is (prc_external_def_t)
if (present (can_be_integrated)) then
call core_def%set_active_writer (can_be_integrated)
else
call msg_fatal ("Cannot decide if external core is integrated!")
end if
end select
if (debug_on) call msg_debug2 (D_CORE, "import_component with method ", method)
call config%entry%import_component (i_component, &
n_out = size (prt_out), &
prt_in = prt_in, &
prt_out = prt_out, &
method = method, &
variant = core_def, &
nlo_type = nlo_type, &
can_be_integrated = can_be_integrated)
end subroutine process_configuration_setup_component
@ %def process_configuration_setup_component
@
<<Process configurations: process configuration: TBP>>=
procedure :: set_fixed_emitter => process_configuration_set_fixed_emitter
<<Process configurations: procedures>>=
subroutine process_configuration_set_fixed_emitter (config, i, emitter)
class(process_configuration_t), intent(inout) :: config
integer, intent(in) :: i, emitter
call config%entry%set_fixed_emitter (i, emitter)
end subroutine process_configuration_set_fixed_emitter
@ %def process_configuration_set_fixed_emitter
@
<<Process configurations: process configuration: TBP>>=
procedure :: set_coupling_powers => process_configuration_set_coupling_powers
<<Process configurations: procedures>>=
subroutine process_configuration_set_coupling_powers &
(config, alpha_power, alphas_power)
class(process_configuration_t), intent(inout) :: config
integer, intent(in) :: alpha_power, alphas_power
call config%entry%set_coupling_powers (alpha_power, alphas_power)
end subroutine process_configuration_set_coupling_powers
@ %def process_configuration_set_coupling_powers
@
<<Process configurations: process configuration: TBP>>=
procedure :: set_component_associations => &
process_configuration_set_component_associations
<<Process configurations: procedures>>=
subroutine process_configuration_set_component_associations &
(config, i_list, remnant, use_real_finite, mismatch)
class(process_configuration_t), intent(inout) :: config
integer, dimension(:), intent(in) :: i_list
logical, intent(in) :: remnant, use_real_finite, mismatch
integer :: i_component
do i_component = 1, config%entry%get_n_components ()
if (any (i_list == i_component)) then
call config%entry%set_associated_components (i_component, &
i_list, remnant, use_real_finite, mismatch)
end if
end do
end subroutine process_configuration_set_component_associations
@ %def process_configuration_set_component_associations
@ Record a process configuration: append it to the currently selected process
definition library.
<<Process configurations: process configuration: TBP>>=
procedure :: record => process_configuration_record
<<Process configurations: procedures>>=
subroutine process_configuration_record (config, global)
class(process_configuration_t), intent(inout) :: config
type(rt_data_t), intent(inout) :: global
if (associated (global%prclib)) then
call global%prclib%open ()
call global%prclib%append (config%entry)
if (config%num_id /= 0) then
write (msg_buffer, "(5A,I0,A)") "Process library '", &
char (global%prclib%get_name ()), &
"': recorded process '", char (config%id), "' (", &
config%num_id, ")"
else
write (msg_buffer, "(5A)") "Process library '", &
char (global%prclib%get_name ()), &
"': recorded process '", char (config%id), "'"
end if
call msg_message ()
else
call msg_fatal ("Recording process '" // char (config%id) &
// "': active process library undefined")
end if
end subroutine process_configuration_record
@ %def process_configuration_record
@
\subsection{Unit Tests}
Test module, followed by the corresponding implementation module.
<<[[process_configurations_ut.f90]]>>=
<<File header>>
module process_configurations_ut
use unit_tests
use process_configurations_uti
<<Standard module head>>
<<Process configurations: public test>>
<<Process configurations: public test auxiliary>>
contains
<<Process configurations: test driver>>
end module process_configurations_ut
@ %def process_configurations_ut
@
<<[[process_configurations_uti.f90]]>>=
<<File header>>
module process_configurations_uti
<<Use strings>>
use particle_specifiers, only: new_prt_spec
use prclib_stacks
use models
use rt_data
use process_configurations
<<Standard module head>>
<<Process configurations: test declarations>>
<<Process configurations: public test auxiliary>>
contains
<<Process configurations: test auxiliary>>
<<Process configurations: tests>>
end module process_configurations_uti
@ %def process_configurations_uti
@ API: driver for the unit tests below.
<<Process configurations: public test>>=
public :: process_configurations_test
<<Process configurations: test driver>>=
subroutine process_configurations_test (u, results)
integer, intent(in) :: u
type(test_results_t), intent(inout) :: results
<<Process configurations: execute tests>>
end subroutine process_configurations_test
@ %def process_configurations_test
@
\subsubsection{Minimal setup}
The workflow for setting up a minimal process configuration with the
test matrix element method.
We wrap this in a public procedure, so we can reuse it in later modules.
The procedure prepares a process definition list for two processes
(one [[prc_test]] and one [[omega]] type) and appends this to the
process library stack in the global data set.
The [[mode]] argument determines which processes to build.
The [[procname]] argument replaces the predefined procname(s).
This is re-exported by the UT module.
<<Process configurations: public test auxiliary>>=
public :: prepare_test_library
<<Process configurations: test auxiliary>>=
subroutine prepare_test_library (global, libname, mode, procname)
type(rt_data_t), intent(inout), target :: global
type(string_t), intent(in) :: libname
integer, intent(in) :: mode
type(string_t), intent(in), dimension(:), optional :: procname
type(prclib_entry_t), pointer :: lib
type(string_t) :: prc_name
type(string_t), dimension(:), allocatable :: prt_in, prt_out
integer :: n_components
type(process_configuration_t) :: prc_config
if (.not. associated (global%prclib_stack%get_first_ptr ())) then
allocate (lib)
call lib%init (libname)
call global%add_prclib (lib)
end if
if (btest (mode, 0)) then
call global%select_model (var_str ("Test"))
if (present (procname)) then
prc_name = procname(1)
else
prc_name = "prc_config_a"
end if
n_components = 1
allocate (prt_in (2), prt_out (2))
prt_in = [var_str ("s"), var_str ("s")]
prt_out = [var_str ("s"), var_str ("s")]
call global%set_string (var_str ("$method"),&
var_str ("unit_test"), is_known = .true.)
call prc_config%init (prc_name, &
size (prt_in), n_components, &
global%model, global%var_list)
call prc_config%setup_component (1, &
new_prt_spec (prt_in), new_prt_spec (prt_out), &
global%model, global%var_list)
call prc_config%record (global)
deallocate (prt_in, prt_out)
end if
if (btest (mode, 1)) then
call global%select_model (var_str ("QED"))
if (present (procname)) then
prc_name = procname(2)
else
prc_name = "prc_config_b"
end if
n_components = 1
allocate (prt_in (2), prt_out (2))
prt_in = [var_str ("e+"), var_str ("e-")]
prt_out = [var_str ("m+"), var_str ("m-")]
call global%set_string (var_str ("$method"),&
var_str ("omega"), is_known = .true.)
call prc_config%init (prc_name, &
size (prt_in), n_components, &
global%model, global%var_list)
call prc_config%setup_component (1, &
new_prt_spec (prt_in), new_prt_spec (prt_out), &
global%model, global%var_list)
call prc_config%record (global)
deallocate (prt_in, prt_out)
end if
if (btest (mode, 2)) then
call global%select_model (var_str ("Test"))
if (present (procname)) then
prc_name = procname(1)
else
prc_name = "prc_config_a"
end if
n_components = 1
allocate (prt_in (1), prt_out (2))
prt_in = [var_str ("s")]
prt_out = [var_str ("f"), var_str ("fbar")]
call global%set_string (var_str ("$method"),&
var_str ("unit_test"), is_known = .true.)
call prc_config%init (prc_name, &
size (prt_in), n_components, &
global%model, global%var_list)
call prc_config%setup_component (1, &
new_prt_spec (prt_in), new_prt_spec (prt_out), &
global%model, global%var_list)
call prc_config%record (global)
deallocate (prt_in, prt_out)
end if
end subroutine prepare_test_library
@ %def prepare_test_library
@ The actual test: the previous procedure with some prelude and postlude.
In the global variable list, just before printing we reset the
variables where the value may depend on the system and run environment.
<<Process configurations: execute tests>>=
call test (process_configurations_1, "process_configurations_1", &
"test processes", &
u, results)
<<Process configurations: test declarations>>=
public :: process_configurations_1
<<Process configurations: tests>>=
subroutine process_configurations_1 (u)
integer, intent(in) :: u
type(rt_data_t), target :: global
write (u, "(A)") "* Test output: process_configurations_1"
write (u, "(A)") "* Purpose: configure test processes"
write (u, "(A)")
call syntax_model_file_init ()
call global%global_init ()
call global%set_log (var_str ("?omega_openmp"), &
.false., is_known = .true.)
write (u, "(A)") "* Configure processes as prc_test, model Test"
write (u, "(A)") "* and omega, model QED"
write (u, *)
call global%set_int (var_str ("process_num_id"), &
42, is_known = .true.)
call prepare_test_library (global, var_str ("prc_config_lib_1"), 3)
global%os_data%fc = "Fortran-compiler"
global%os_data%fcflags = "Fortran-flags"
global%os_data%fclibs = "Fortran-libs"
call global%write_libraries (u)
call global%final ()
call syntax_model_file_final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: process_configurations_1"
end subroutine process_configurations_1
@ %def process_configurations_1
@
\subsubsection{\oMega\ options}
Slightly extended example where we pass \oMega\ options to the
library. The [[prepare_test_library]] contents are spelled out.
<<Process configurations: execute tests>>=
call test (process_configurations_2, "process_configurations_2", &
"omega options", &
u, results)
<<Process configurations: test declarations>>=
public :: process_configurations_2
<<Process configurations: tests>>=
subroutine process_configurations_2 (u)
integer, intent(in) :: u
type(rt_data_t), target :: global
type(string_t) :: libname
type(prclib_entry_t), pointer :: lib
type(string_t) :: prc_name
type(string_t), dimension(:), allocatable :: prt_in, prt_out
integer :: n_components
type(process_configuration_t) :: prc_config
write (u, "(A)") "* Test output: process_configurations_2"
write (u, "(A)") "* Purpose: configure test processes with options"
write (u, "(A)")
call syntax_model_file_init ()
call global%global_init ()
write (u, "(A)") "* Configure processes as omega, model QED"
write (u, *)
libname = "prc_config_lib_2"
allocate (lib)
call lib%init (libname)
call global%add_prclib (lib)
call global%select_model (var_str ("QED"))
prc_name = "prc_config_c"
n_components = 2
allocate (prt_in (2), prt_out (2))
prt_in = [var_str ("e+"), var_str ("e-")]
prt_out = [var_str ("m+"), var_str ("m-")]
call global%set_string (var_str ("$method"),&
var_str ("omega"), is_known = .true.)
call global%set_log (var_str ("?omega_openmp"), &
.false., is_known = .true.)
call prc_config%init (prc_name, size (prt_in), n_components, &
global%model, global%var_list)
call global%set_log (var_str ("?report_progress"), &
.true., is_known = .true.)
call prc_config%setup_component (1, &
new_prt_spec (prt_in), new_prt_spec (prt_out), global%model, global%var_list)
call global%set_log (var_str ("?report_progress"), &
.false., is_known = .true.)
call global%set_log (var_str ("?omega_openmp"), &
.true., is_known = .true.)
call global%set_string (var_str ("$restrictions"),&
var_str ("3+4~A"), is_known = .true.)
call global%set_string (var_str ("$omega_flags"), &
var_str ("-fusion:progress_file omega_prc_config.log"), &
is_known = .true.)
call prc_config%setup_component (2, &
new_prt_spec (prt_in), new_prt_spec (prt_out), global%model, global%var_list)
call prc_config%record (global)
deallocate (prt_in, prt_out)
global%os_data%fc = "Fortran-compiler"
global%os_data%fcflags = "Fortran-flags"
global%os_data%fclibs = "Fortran-libs"
call global%write_vars (u, [ &
var_str ("$model_name"), &
var_str ("$method"), &
var_str ("?report_progress"), &
var_str ("$restrictions"), &
var_str ("$omega_flags")])
write (u, "(A)")
call global%write_libraries (u)
call global%final ()
call syntax_model_file_final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: process_configurations_2"
end subroutine process_configurations_2
@ %def process_configurations_2
@
\clearpage
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{Compilation}
This module manages compilation and loading of of process libraries. It is
needed as a separate module because integration depends on it.
<<[[compilations.f90]]>>=
<<File header>>
module compilations
<<Use strings>>
use io_units
use system_defs, only: TAB
use system_dependencies, only: OS_IS_DARWIN
use diagnostics
use os_interface
use variables, only: var_list_t
use model_data
use process_libraries
use prclib_stacks
use rt_data
<<Standard module head>>
<<Compilations: public>>
<<Compilations: types>>
<<Compilations: parameters>>
contains
<<Compilations: procedures>>
end module compilations
@ %def compilations
@
\subsection{The data type}
The compilation item handles the compilation and loading of a single
process library.
<<Compilations: public>>=
public :: compilation_item_t
<<Compilations: types>>=
type :: compilation_item_t
private
type(string_t) :: libname
type(string_t) :: static_external_tag
type(process_library_t), pointer :: lib => null ()
logical :: recompile_library = .false.
logical :: verbose = .false.
logical :: use_workspace = .false.
type(string_t) :: workspace
contains
<<Compilations: compilation item: TBP>>
end type compilation_item_t
@ %def compilation_item_t
@ Initialize.
Set flags and global properties of the library. Establish the workspace name,
if defined.
<<Compilations: compilation item: TBP>>=
procedure :: init => compilation_item_init
<<Compilations: procedures>>=
subroutine compilation_item_init (comp, libname, stack, var_list)
class(compilation_item_t), intent(out) :: comp
type(string_t), intent(in) :: libname
type(prclib_stack_t), intent(inout) :: stack
type(var_list_t), intent(in) :: var_list
comp%libname = libname
comp%lib => stack%get_library_ptr (comp%libname)
if (.not. associated (comp%lib)) then
call msg_fatal ("Process library '" // char (comp%libname) &
// "' has not been declared.")
end if
comp%recompile_library = &
var_list%get_lval (var_str ("?recompile_library"))
comp%verbose = &
var_list%get_lval (var_str ("?me_verbose"))
comp%use_workspace = &
var_list%is_known (var_str ("$compile_workspace"))
if (comp%use_workspace) then
comp%workspace = &
var_list%get_sval (var_str ("$compile_workspace"))
if (comp%workspace == "") comp%use_workspace = .false.
else
comp%workspace = ""
end if
end subroutine compilation_item_init
@ %def compilation_item_init
@ Compile the current library. The [[force]] flag has the
effect that we first delete any previous files, as far as accessible
by the current makefile. It also guarantees that previous files not
accessible by a makefile will be overwritten.
<<Compilations: compilation item: TBP>>=
procedure :: compile => compilation_item_compile
<<Compilations: procedures>>=
subroutine compilation_item_compile (comp, model, os_data, force, recompile)
class(compilation_item_t), intent(inout) :: comp
class(model_data_t), intent(in), target :: model
type(os_data_t), intent(in) :: os_data
logical, intent(in) :: force, recompile
if (associated (comp%lib)) then
if (comp%use_workspace) call setup_workspace (comp%workspace, os_data)
call msg_message ("Process library '" &
// char (comp%libname) // "': compiling ...")
call comp%lib%configure (os_data)
if (signal_is_pending ()) return
call comp%lib%compute_md5sum (model)
call comp%lib%write_makefile &
(os_data, force, verbose=comp%verbose, workspace=comp%workspace)
if (signal_is_pending ()) return
if (force) then
call comp%lib%clean &
(os_data, distclean = .false., workspace=comp%workspace)
if (signal_is_pending ()) return
end if
call comp%lib%write_driver (force, workspace=comp%workspace)
if (signal_is_pending ()) return
if (recompile) then
call comp%lib%load &
(os_data, keep_old_source = .true., workspace=comp%workspace)
if (signal_is_pending ()) return
end if
call comp%lib%update_status (os_data, workspace=comp%workspace)
end if
end subroutine compilation_item_compile
@ %def compilation_item_compile
@ The workspace directory is created if it does not exist. (Applies only if
the use has set the workspace directory.)
<<Compilations: parameters>>=
character(*), parameter :: ALLOWED_IN_DIRNAME = &
"abcdefghijklmnopqrstuvwxyz&
&ABCDEFGHIJKLMNOPQRSTUVWXYZ&
&1234567890&
&.,_-+="
@ %def ALLOWED_IN_DIRNAME
<<Compilations: procedures>>=
subroutine setup_workspace (workspace, os_data)
type(string_t), intent(in) :: workspace
type(os_data_t), intent(in) :: os_data
if (verify (workspace, ALLOWED_IN_DIRNAME) == 0) then
call msg_message ("Compile: preparing workspace directory '" &
// char (workspace) // "'")
call os_system_call ("mkdir -p '" // workspace // "'")
else
call msg_fatal ("compile: workspace name '" &
// char (workspace) // "' contains illegal characters")
end if
end subroutine setup_workspace
@ %def setup_workspace
@ Load the current library, just after compiling it.
<<Compilations: compilation item: TBP>>=
procedure :: load => compilation_item_load
<<Compilations: procedures>>=
subroutine compilation_item_load (comp, os_data)
class(compilation_item_t), intent(inout) :: comp
type(os_data_t), intent(in) :: os_data
if (associated (comp%lib)) then
call comp%lib%load (os_data, workspace=comp%workspace)
end if
end subroutine compilation_item_load
@ %def compilation_item_load
@ Message as a separate call:
<<Compilations: compilation item: TBP>>=
procedure :: success => compilation_item_success
<<Compilations: procedures>>=
subroutine compilation_item_success (comp)
class(compilation_item_t), intent(in) :: comp
if (associated (comp%lib)) then
call msg_message ("Process library '" // char (comp%libname) &
// "': ... success.")
else
call msg_fatal ("Process library '" // char (comp%libname) &
// "': ... failure.")
end if
end subroutine compilation_item_success
@ %def compilation_item_success
@ %def compilation_item_failure
@
\subsection{API for library compilation and loading}
This is a shorthand for compiling and loading a single library. The
[[compilation_item]] object is used only internally.
The [[global]] data set may actually be local to the caller. The
compilation affects the library specified by its name if it is on the
stack, but it does not reset the currently selected library.
<<Compilations: public>>=
public :: compile_library
<<Compilations: procedures>>=
subroutine compile_library (libname, global)
type(string_t), intent(in) :: libname
type(rt_data_t), intent(inout), target :: global
type(compilation_item_t) :: comp
logical :: force, recompile
force = &
global%var_list%get_lval (var_str ("?rebuild_library"))
recompile = &
global%var_list%get_lval (var_str ("?recompile_library"))
if (associated (global%model)) then
call comp%init (libname, global%prclib_stack, global%var_list)
call comp%compile (global%model, global%os_data, force, recompile)
if (signal_is_pending ()) return
call comp%load (global%os_data)
if (signal_is_pending ()) return
else
call msg_fatal ("Process library compilation: " &
// " model is undefined.")
end if
call comp%success ()
end subroutine compile_library
@ %def compile_library
@
\subsection{Compiling static executable}
This object handles the creation of a static executable which should
contain a set of static process libraries.
<<Compilations: public>>=
public :: compilation_t
<<Compilations: types>>=
type :: compilation_t
private
type(string_t) :: exe_name
type(string_t), dimension(:), allocatable :: lib_name
contains
<<Compilations: compilation: TBP>>
end type compilation_t
@ %def compilation_t
@ Output.
<<Compilations: compilation: TBP>>=
procedure :: write => compilation_write
<<Compilations: procedures>>=
subroutine compilation_write (object, unit)
class(compilation_t), intent(in) :: object
integer, intent(in), optional :: unit
integer :: u, i
u = given_output_unit (unit)
write (u, "(1x,A)") "Compilation object:"
write (u, "(3x,3A)") "executable = '", &
char (object%exe_name), "'"
write (u, "(3x,A)", advance="no") "process libraries ="
do i = 1, size (object%lib_name)
write (u, "(1x,3A)", advance="no") "'", char (object%lib_name(i)), "'"
end do
write (u, *)
end subroutine compilation_write
@ %def compilation_write
@ Initialize: we know the names of the executable and of the libraries.
Optionally, we may provide a workspace directory.
<<Compilations: compilation: TBP>>=
procedure :: init => compilation_init
<<Compilations: procedures>>=
subroutine compilation_init (compilation, exe_name, lib_name)
class(compilation_t), intent(out) :: compilation
type(string_t), intent(in) :: exe_name
type(string_t), dimension(:), intent(in) :: lib_name
compilation%exe_name = exe_name
allocate (compilation%lib_name (size (lib_name)))
compilation%lib_name = lib_name
end subroutine compilation_init
@ %def compilation_init
@ Write the dispatcher subroutine for the compiled libraries. Also
write a subroutine which returns the names of the compiled libraries.
<<Compilations: compilation: TBP>>=
procedure :: write_dispatcher => compilation_write_dispatcher
<<Compilations: procedures>>=
subroutine compilation_write_dispatcher (compilation)
class(compilation_t), intent(in) :: compilation
type(string_t) :: file
integer :: u, i
file = compilation%exe_name // "_prclib_dispatcher.f90"
call msg_message ("Static executable '" // char (compilation%exe_name) &
// "': writing library dispatcher")
u = free_unit ()
open (u, file = char (file), status="replace", action="write")
write (u, "(3A)") "! Whizard: process libraries for executable '", &
char (compilation%exe_name), "'"
write (u, "(A)") "! Automatically generated file, do not edit"
write (u, "(A)") "subroutine dispatch_prclib_static " // &
"(driver, basename, modellibs_ldflags)"
write (u, "(A)") " use iso_varying_string, string_t => varying_string"
write (u, "(A)") " use prclib_interfaces"
do i = 1, size (compilation%lib_name)
associate (lib_name => compilation%lib_name(i))
write (u, "(A)") " use " // char (lib_name) // "_driver"
end associate
end do
write (u, "(A)") " implicit none"
write (u, "(A)") " class(prclib_driver_t), intent(inout), allocatable &
&:: driver"
write (u, "(A)") " type(string_t), intent(in) :: basename"
write (u, "(A)") " logical, intent(in), optional :: " // &
"modellibs_ldflags"
write (u, "(A)") " select case (char (basename))"
do i = 1, size (compilation%lib_name)
associate (lib_name => compilation%lib_name(i))
write (u, "(3A)") " case ('", char (lib_name), "')"
write (u, "(3A)") " allocate (", char (lib_name), "_driver_t &
&:: driver)"
end associate
end do
write (u, "(A)") " end select"
write (u, "(A)") "end subroutine dispatch_prclib_static"
write (u, *)
write (u, "(A)") "subroutine get_prclib_static (libname)"
write (u, "(A)") " use iso_varying_string, string_t => varying_string"
write (u, "(A)") " implicit none"
write (u, "(A)") " type(string_t), dimension(:), intent(inout), &
&allocatable :: libname"
write (u, "(A,I0,A)") " allocate (libname (", &
size (compilation%lib_name), "))"
do i = 1, size (compilation%lib_name)
associate (lib_name => compilation%lib_name(i))
write (u, "(A,I0,A,A,A)") " libname(", i, ") = '", &
char (lib_name), "'"
end associate
end do
write (u, "(A)") "end subroutine get_prclib_static"
close (u)
end subroutine compilation_write_dispatcher
@ %def compilation_write_dispatcher
@ Write the Makefile subroutine for the compiled libraries.
<<Compilations: compilation: TBP>>=
procedure :: write_makefile => compilation_write_makefile
<<Compilations: procedures>>=
subroutine compilation_write_makefile &
(compilation, os_data, ext_libtag, verbose, overwrite_os)
class(compilation_t), intent(in) :: compilation
type(os_data_t), intent(in) :: os_data
logical, intent(in) :: verbose
logical, intent(in), optional :: overwrite_os
logical :: overwrite
type(string_t), intent(in), optional :: ext_libtag
type(string_t) :: file, ext_tag
integer :: u, i
overwrite = .false.
if (present (overwrite_os)) overwrite = overwrite_os
if (present (ext_libtag)) then
ext_tag = ext_libtag
else
ext_tag = ""
end if
file = compilation%exe_name // ".makefile"
call msg_message ("Static executable '" // char (compilation%exe_name) &
// "': writing makefile")
u = free_unit ()
open (u, file = char (file), status="replace", action="write")
write (u, "(3A)") "# WHIZARD: Makefile for executable '", &
char (compilation%exe_name), "'"
write (u, "(A)") "# Automatically generated file, do not edit"
write (u, "(A)") ""
write (u, "(A)") "# Executable name"
write (u, "(A)") "EXE = " // char (compilation%exe_name)
write (u, "(A)") ""
write (u, "(A)") "# Compiler"
write (u, "(A)") "FC = " // char (os_data%fc)
write (u, "(A)") "CXX = " // char (os_data%cxx)
write (u, "(A)") ""
write (u, "(A)") "# Included libraries"
write (u, "(A)") "FCINCL = " // char (os_data%whizard_includes)
write (u, "(A)") ""
write (u, "(A)") "# Compiler flags"
write (u, "(A)") "FCFLAGS = " // char (os_data%fcflags)
write (u, "(A)") "FCLIBS = " // char (os_data%fclibs)
write (u, "(A)") "CXXFLAGS = " // char (os_data%cxxflags)
write (u, "(A)") "CXXLIBSS = " // char (os_data%cxxlibs)
write (u, "(A)") "LDFLAGS = " // char (os_data%ldflags)
write (u, "(A)") "LDFLAGS_STATIC = " // char (os_data%ldflags_static)
write (u, "(A)") "LDFLAGS_HEPMC = " // char (os_data%ldflags_hepmc)
write (u, "(A)") "LDFLAGS_LCIO = " // char (os_data%ldflags_lcio)
write (u, "(A)") "LDFLAGS_HOPPET = " // char (os_data%ldflags_hoppet)
write (u, "(A)") "LDFLAGS_LOOPTOOLS = " // char (os_data%ldflags_looptools)
write (u, "(A)") "LDWHIZARD = " // char (os_data%whizard_ldflags)
write (u, "(A)") ""
write (u, "(A)") "# Libtool"
write (u, "(A)") "LIBTOOL = " // char (os_data%whizard_libtool)
if (verbose) then
write (u, "(A)") "FCOMPILE = $(LIBTOOL) --tag=FC --mode=compile"
if (OS_IS_DARWIN .and. .not. overwrite) then
write (u, "(A)") "LINK = $(LIBTOOL) --tag=CXX --mode=link"
else
write (u, "(A)") "LINK = $(LIBTOOL) --tag=FC --mode=link"
end if
else
write (u, "(A)") "FCOMPILE = @$(LIBTOOL) --silent --tag=FC --mode=compile"
if (OS_IS_DARWIN .and. .not. overwrite) then
write (u, "(A)") "LINK = @$(LIBTOOL) --silent --tag=CXX --mode=link"
else
write (u, "(A)") "LINK = @$(LIBTOOL) --silent --tag=FC --mode=link"
end if
end if
write (u, "(A)") ""
write (u, "(A)") "# Compile commands (default)"
write (u, "(A)") "LTFCOMPILE = $(FCOMPILE) $(FC) -c $(FCINCL) $(FCFLAGS)"
write (u, "(A)") ""
write (u, "(A)") "# Default target"
write (u, "(A)") "all: link"
write (u, "(A)") ""
write (u, "(A)") "# Libraries"
do i = 1, size (compilation%lib_name)
associate (lib_name => compilation%lib_name(i))
write (u, "(A)") "LIBRARIES += " // char (lib_name) // ".la"
write (u, "(A)") char (lib_name) // ".la:"
write (u, "(A)") TAB // "$(MAKE) -f " // char (lib_name) // ".makefile"
end associate
end do
write (u, "(A)") ""
write (u, "(A)") "# Library dispatcher"
write (u, "(A)") "DISP = $(EXE)_prclib_dispatcher"
write (u, "(A)") "$(DISP).lo: $(DISP).f90 $(LIBRARIES)"
if (.not. verbose) then
write (u, "(A)") TAB // '@echo " FC " $@'
end if
write (u, "(A)") TAB // "$(LTFCOMPILE) $<"
write (u, "(A)") ""
write (u, "(A)") "# Executable"
write (u, "(A)") "$(EXE): $(DISP).lo $(LIBRARIES)"
if (.not. verbose) then
if (OS_IS_DARWIN .and. .not. overwrite) then
write (u, "(A)") TAB // '@echo " CXXLD " $@'
else
write (u, "(A)") TAB // '@echo " FCLD " $@'
end if
end if
if (OS_IS_DARWIN .and. .not. overwrite) then
write (u, "(A)") TAB // "$(LINK) $(CXX) -static $(CXXFLAGS) \"
else
write (u, "(A)") TAB // "$(LINK) $(FC) -static $(FCFLAGS) \"
end if
write (u, "(A)") TAB // " $(LDWHIZARD) $(LDFLAGS) \"
write (u, "(A)") TAB // " -o $(EXE) $^ \"
write (u, "(A)") TAB // " $(LDFLAGS_HEPMC) $(LDFLAGS_LCIO) $(LDFLAGS_HOPPET) \"
if (OS_IS_DARWIN .and. .not. overwrite) then
write (u, "(A)") TAB // " $(LDFLAGS_LOOPTOOLS) $(LDFLAGS_STATIC) \"
write (u, "(A)") TAB // " $(CXXLIBS) $(FCLIBS)" // char (ext_tag)
else
write (u, "(A)") TAB // " $(LDFLAGS_LOOPTOOLS) $(LDFLAGS_STATIC)" // char (ext_tag)
end if
write (u, "(A)") ""
write (u, "(A)") "# Main targets"
write (u, "(A)") "link: compile $(EXE)"
write (u, "(A)") "compile: $(LIBRARIES) $(DISP).lo"
write (u, "(A)") ".PHONY: link compile"
write (u, "(A)") ""
write (u, "(A)") "# Cleanup targets"
write (u, "(A)") "clean-exe:"
write (u, "(A)") TAB // "rm -f $(EXE)"
write (u, "(A)") "clean-objects:"
write (u, "(A)") TAB // "rm -f $(DISP).lo"
write (u, "(A)") "clean-source:"
write (u, "(A)") TAB // "rm -f $(DISP).f90"
write (u, "(A)") "clean-makefile:"
write (u, "(A)") TAB // "rm -f $(EXE).makefile"
write (u, "(A)") ""
write (u, "(A)") "clean: clean-exe clean-objects clean-source"
write (u, "(A)") "distclean: clean clean-makefile"
write (u, "(A)") ".PHONY: clean distclean"
close (u)
end subroutine compilation_write_makefile
@ %def compilation_write_makefile
@ Compile the dispatcher source code.
<<Compilations: compilation: TBP>>=
procedure :: make_compile => compilation_make_compile
<<Compilations: procedures>>=
subroutine compilation_make_compile (compilation, os_data)
class(compilation_t), intent(in) :: compilation
type(os_data_t), intent(in) :: os_data
call os_system_call ("make compile " // os_data%makeflags &
// " -f " // compilation%exe_name // ".makefile")
end subroutine compilation_make_compile
@ %def compilation_make_compile
@ Link the dispatcher together with all matrix-element code and the
\whizard\ and \oMega\ main libraries, to generate a static executable.
<<Compilations: compilation: TBP>>=
procedure :: make_link => compilation_make_link
<<Compilations: procedures>>=
subroutine compilation_make_link (compilation, os_data)
class(compilation_t), intent(in) :: compilation
type(os_data_t), intent(in) :: os_data
call os_system_call ("make link " // os_data%makeflags &
// " -f " // compilation%exe_name // ".makefile")
end subroutine compilation_make_link
@ %def compilation_make_link
@ Cleanup.
<<Compilations: compilation: TBP>>=
procedure :: make_clean_exe => compilation_make_clean_exe
<<Compilations: procedures>>=
subroutine compilation_make_clean_exe (compilation, os_data)
class(compilation_t), intent(in) :: compilation
type(os_data_t), intent(in) :: os_data
call os_system_call ("make clean-exe " // os_data%makeflags &
// " -f " // compilation%exe_name // ".makefile")
end subroutine compilation_make_clean_exe
@ %def compilation_make_clean_exe
@
\subsection{API for executable compilation}
This is a shorthand for compiling and loading an executable, including
the enclosed libraries. The [[compilation]] object is used only internally.
The [[global]] data set may actually be local to the caller. The
compilation affects the library specified by its name if it is on the
stack, but it does not reset the currently selected library.
<<Compilations: public>>=
public :: compile_executable
<<Compilations: procedures>>=
subroutine compile_executable (exename, libname, global)
type(string_t), intent(in) :: exename
type(string_t), dimension(:), intent(in) :: libname
type(rt_data_t), intent(inout), target :: global
type(compilation_t) :: compilation
type(compilation_item_t) :: item
type(string_t) :: ext_libtag
logical :: force, recompile, verbose
integer :: i
ext_libtag = ""
force = &
global%var_list%get_lval (var_str ("?rebuild_library"))
recompile = &
global%var_list%get_lval (var_str ("?recompile_library"))
verbose = &
global%var_list%get_lval (var_str ("?me_verbose"))
call compilation%init (exename, [libname])
if (signal_is_pending ()) return
call compilation%write_dispatcher ()
if (signal_is_pending ()) return
do i = 1, size (libname)
call item%init (libname(i), global%prclib_stack, global%var_list)
call item%compile (global%model, global%os_data, &
force=force, recompile=recompile)
ext_libtag = "" // item%lib%get_static_modelname (global%os_data)
if (signal_is_pending ()) return
call item%success ()
end do
call compilation%write_makefile &
(global%os_data, ext_libtag=ext_libtag, verbose=verbose)
if (signal_is_pending ()) return
call compilation%make_compile (global%os_data)
if (signal_is_pending ()) return
call compilation%make_link (global%os_data)
end subroutine compile_executable
@ %def compile_executable
@
\subsection{Unit Tests}
Test module, followed by the stand-alone unit-test procedures.
<<[[compilations_ut.f90]]>>=
<<File header>>
module compilations_ut
use unit_tests
use compilations_uti
<<Standard module head>>
<<Compilations: public test>>
contains
<<Compilations: test driver>>
end module compilations_ut
@ %def compilations_ut
@
<<[[compilations_uti.f90]]>>=
<<File header>>
module compilations_uti
<<Use strings>>
use io_units
use models
use rt_data
use process_configurations_ut, only: prepare_test_library
use compilations
<<Standard module head>>
<<Compilations: test declarations>>
contains
<<Compilations: tests>>
end module compilations_uti
@ %def compilations_uti
@ API: driver for the unit tests below.
<<Compilations: public test>>=
public :: compilations_test
<<Compilations: test driver>>=
subroutine compilations_test (u, results)
integer, intent(in) :: u
type(test_results_t), intent(inout) :: results
<<Compilations: execute tests>>
end subroutine compilations_test
@ %def compilations_test
@
\subsubsection{Intrinsic Matrix Element}
Compile an intrinsic test matrix element ([[prc_test]] type).
Note: In this and the following test, we reset the Fortran compiler and flag
variables immediately before they are printed, so the test is portable.
<<Compilations: execute tests>>=
call test (compilations_1, "compilations_1", &
"intrinsic test processes", &
u, results)
<<Compilations: test declarations>>=
public :: compilations_1
<<Compilations: tests>>=
subroutine compilations_1 (u)
integer, intent(in) :: u
type(string_t) :: libname, procname
type(rt_data_t), target :: global
write (u, "(A)") "* Test output: compilations_1"
write (u, "(A)") "* Purpose: configure and compile test process"
write (u, "(A)")
call syntax_model_file_init ()
call global%global_init ()
libname = "compilation_1"
procname = "prc_comp_1"
call prepare_test_library (global, libname, 1, [procname])
call compile_library (libname, global)
call global%write_libraries (u)
call global%final ()
call syntax_model_file_final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: compilations_1"
end subroutine compilations_1
@ %def compilations_1
@
\subsubsection{External Matrix Element}
Compile an external test matrix element ([[omega]] type)
<<Compilations: execute tests>>=
call test (compilations_2, "compilations_2", &
"external process (omega)", &
u, results)
<<Compilations: test declarations>>=
public :: compilations_2
<<Compilations: tests>>=
subroutine compilations_2 (u)
integer, intent(in) :: u
type(string_t) :: libname, procname
type(rt_data_t), target :: global
write (u, "(A)") "* Test output: compilations_2"
write (u, "(A)") "* Purpose: configure and compile test process"
write (u, "(A)")
call syntax_model_file_init ()
call global%global_init ()
call global%set_log (var_str ("?omega_openmp"), &
.false., is_known = .true.)
libname = "compilation_2"
procname = "prc_comp_2"
call prepare_test_library (global, libname, 2, [procname,procname])
call compile_library (libname, global)
call global%write_libraries (u, libpath = .false.)
call global%final ()
call syntax_model_file_final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: compilations_2"
end subroutine compilations_2
@ %def compilations_2
@
\subsubsection{External Matrix Element}
Compile an external test matrix element ([[omega]] type) and
create driver files for a static executable.
<<Compilations: execute tests>>=
call test (compilations_3, "compilations_3", &
"static executable: driver", &
u, results)
<<Compilations: test declarations>>=
public :: compilations_3
<<Compilations: tests>>=
subroutine compilations_3 (u)
integer, intent(in) :: u
type(string_t) :: libname, procname, exename
type(rt_data_t), target :: global
type(compilation_t) :: compilation
integer :: u_file
character(80) :: buffer
write (u, "(A)") "* Test output: compilations_3"
write (u, "(A)") "* Purpose: make static executable"
write (u, "(A)")
write (u, "(A)") "* Initialize library"
write (u, "(A)")
call syntax_model_file_init ()
call global%global_init ()
call global%set_log (var_str ("?omega_openmp"), &
.false., is_known = .true.)
libname = "compilations_3_lib"
procname = "prc_comp_3"
exename = "compilations_3"
call prepare_test_library (global, libname, 2, [procname,procname])
call compilation%init (exename, [libname])
call compilation%write (u)
write (u, "(A)")
write (u, "(A)") "* Write dispatcher"
write (u, "(A)")
call compilation%write_dispatcher ()
u_file = free_unit ()
open (u_file, file = char (exename) // "_prclib_dispatcher.f90", &
status = "old", action = "read")
do
read (u_file, "(A)", end = 1) buffer
write (u, "(A)") trim (buffer)
end do
1 close (u_file)
write (u, "(A)")
write (u, "(A)") "* Write Makefile"
write (u, "(A)")
associate (os_data => global%os_data)
os_data%fc = "fortran-compiler"
os_data%cxx = "c++-compiler"
os_data%whizard_includes = "my-includes"
os_data%fcflags = "my-fcflags"
os_data%fclibs = "my-fclibs"
os_data%cxxflags = "my-cxxflags"
os_data%cxxlibs = "my-cxxlibs"
os_data%ldflags = "my-ldflags"
os_data%ldflags_static = "my-ldflags-static"
os_data%ldflags_hepmc = "my-ldflags-hepmc"
os_data%ldflags_lcio = "my-ldflags-lcio"
os_data%ldflags_hoppet = "my-ldflags-hoppet"
os_data%ldflags_looptools = "my-ldflags-looptools"
os_data%whizard_ldflags = "my-ldwhizard"
os_data%whizard_libtool = "my-libtool"
end associate
call compilation%write_makefile &
(global%os_data, verbose = .true., overwrite_os = .true.)
open (u_file, file = char (exename) // ".makefile", &
status = "old", action = "read")
do
read (u_file, "(A)", end = 2) buffer
write (u, "(A)") trim (buffer)
end do
2 close (u_file)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call global%final ()
call syntax_model_file_final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: compilations_3"
end subroutine compilations_3
@ %def compilations_3
@
\subsection{Test static build}
The tests for building a static executable are separate, since they
should be skipped if the \whizard\ build itself has static libraries
disabled.
<<Compilations: public test>>=
public :: compilations_static_test
<<Compilations: test driver>>=
subroutine compilations_static_test (u, results)
integer, intent(in) :: u
type(test_results_t), intent(inout) :: results
<<Compilations: static tests>>
end subroutine compilations_static_test
@ %def compilations_static_test
@
\subsubsection{External Matrix Element}
Compile an external test matrix element ([[omega]] type) and
incorporate this in a new static WHIZARD executable.
<<Compilations: static tests>>=
call test (compilations_static_1, "compilations_static_1", &
"static executable: compilation", &
u, results)
<<Compilations: test declarations>>=
public :: compilations_static_1
<<Compilations: tests>>=
subroutine compilations_static_1 (u)
integer, intent(in) :: u
type(string_t) :: libname, procname, exename
type(rt_data_t), target :: global
type(compilation_item_t) :: item
type(compilation_t) :: compilation
logical :: exist
write (u, "(A)") "* Test output: compilations_static_1"
write (u, "(A)") "* Purpose: make static executable"
write (u, "(A)")
write (u, "(A)") "* Initialize library"
call syntax_model_file_init ()
call global%global_init ()
call global%set_log (var_str ("?omega_openmp"), &
.false., is_known = .true.)
libname = "compilations_static_1_lib"
procname = "prc_comp_stat_1"
exename = "compilations_static_1"
call prepare_test_library (global, libname, 2, [procname,procname])
call compilation%init (exename, [libname])
write (u, "(A)")
write (u, "(A)") "* Write dispatcher"
call compilation%write_dispatcher ()
write (u, "(A)")
write (u, "(A)") "* Write Makefile"
call compilation%write_makefile (global%os_data, verbose = .true.)
write (u, "(A)")
write (u, "(A)") "* Build libraries"
call item%init (libname, global%prclib_stack, global%var_list)
call item%compile &
(global%model, global%os_data, force=.true., recompile=.false.)
call item%success ()
write (u, "(A)")
write (u, "(A)") "* Check executable (should be absent)"
write (u, "(A)")
call compilation%make_clean_exe (global%os_data)
inquire (file = char (exename), exist = exist)
write (u, "(A,A,L1)") char (exename), " exists = ", exist
write (u, "(A)")
write (u, "(A)") "* Build executable"
write (u, "(A)")
call compilation%make_compile (global%os_data)
call compilation%make_link (global%os_data)
write (u, "(A)") "* Check executable (should be present)"
write (u, "(A)")
inquire (file = char (exename), exist = exist)
write (u, "(A,A,L1)") char (exename), " exists = ", exist
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call compilation%make_clean_exe (global%os_data)
call global%final ()
call syntax_model_file_final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: compilations_static_1"
end subroutine compilations_static_1
@ %def compilations_static_1
@
\subsubsection{External Matrix Element}
Compile an external test matrix element ([[omega]] type) and
incorporate this in a new static WHIZARD executable. In this version,
we use the wrapper [[compile_executable]] procedure.
<<Compilations: static tests>>=
call test (compilations_static_2, "compilations_static_2", &
"static executable: shortcut", &
u, results)
<<Compilations: test declarations>>=
public :: compilations_static_2
<<Compilations: tests>>=
subroutine compilations_static_2 (u)
integer, intent(in) :: u
type(string_t) :: libname, procname, exename
type(rt_data_t), target :: global
logical :: exist
integer :: u_file
write (u, "(A)") "* Test output: compilations_static_2"
write (u, "(A)") "* Purpose: make static executable"
write (u, "(A)")
write (u, "(A)") "* Initialize library and compile"
write (u, "(A)")
call syntax_model_file_init ()
call global%global_init ()
call global%set_log (var_str ("?omega_openmp"), &
.false., is_known = .true.)
libname = "compilations_static_2_lib"
procname = "prc_comp_stat_2"
exename = "compilations_static_2"
call prepare_test_library (global, libname, 2, [procname,procname])
call compile_executable (exename, [libname], global)
write (u, "(A)") "* Check executable (should be present)"
write (u, "(A)")
inquire (file = char (exename), exist = exist)
write (u, "(A,A,L1)") char (exename), " exists = ", exist
write (u, "(A)")
write (u, "(A)") "* Cleanup"
u_file = free_unit ()
open (u_file, file = char (exename), status = "old", action = "write")
close (u_file, status = "delete")
call global%final ()
call syntax_model_file_final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: compilations_static_2"
end subroutine compilations_static_2
@ %def compilations_static_2
@
\clearpage
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{Integration}
This module manages phase space setup, matrix-element evaluation and
integration, as far as it is not done by lower-level routines, in particular
in the [[processes]] module.
<<[[integrations.f90]]>>=
<<File header>>
module integrations
<<Use kinds>>
<<Use strings>>
<<Use debug>>
use io_units
use diagnostics
use os_interface
use cputime
use sm_qcd
use physics_defs
use model_data
use pdg_arrays
use variables, only: var_list_t
use eval_trees
use sf_mappings
use sf_base
use phs_base
use rng_base
use mci_base
use process_libraries
use prc_core
use process_config, only: COMP_MASTER, COMP_REAL_FIN, &
COMP_MISMATCH, COMP_PDF, COMP_REAL, COMP_SUB, COMP_VIRT, &
COMP_REAL_SING
use process
use pcm_base, only: pcm_t
use instances
use process_stacks
use models
use iterations
use rt_data
use dispatch_me_methods, only: dispatch_core
use dispatch_beams, only: dispatch_qcd, sf_prop_t, dispatch_sf_config
use dispatch_phase_space, only: dispatch_sf_channels
use dispatch_phase_space, only: dispatch_phs
use dispatch_mci, only: dispatch_mci_s, setup_grid_path
use dispatch_transforms, only: dispatch_evt_shower_hook
use compilations, only: compile_library
use dispatch_fks, only: dispatch_fks_s
use nlo_data
<<Use mpi f08>>
<<Standard module head>>
<<Integrations: public>>
<<Integrations: types>>
contains
<<Integrations: procedures>>
end module integrations
@ %def integrations
@
\subsection{The integration type}
This type holds all relevant data, the integration methods operates on this.
In contrast to the [[simulation_t]] introduced later, the [[integration_t]]
applies to a single process.
<<Integrations: public>>=
public :: integration_t
<<Integrations: types>>=
type :: integration_t
private
type(string_t) :: process_id
type(string_t) :: run_id
type(process_t), pointer :: process => null ()
logical :: rebuild_phs = .false.
logical :: ignore_phs_mismatch = .false.
logical :: phs_only = .false.
logical :: process_has_me = .true.
integer :: n_calls_test = 0
logical :: vis_history = .true.
type(string_t) :: history_filename
type(string_t) :: log_filename
type(helicity_selection_t) :: helicity_selection
logical :: use_color_factors = .false.
logical :: has_beam_pol = .false.
logical :: combined_integration = .false.
type(iteration_multipliers_t) :: iteration_multipliers
type(nlo_settings_t) :: nlo_settings
contains
<<Integrations: integration: TBP>>
end type integration_t
@ %def integration_t
@
@
\subsection{Initialization}
Initialization, first part: Create a process entry.
Push it on the stack if the [[global]] environment is supplied.
<<Integrations: integration: TBP>>=
procedure :: create_process => integration_create_process
<<Integrations: procedures>>=
subroutine integration_create_process (intg, process_id, global)
class(integration_t), intent(out) :: intg
type(rt_data_t), intent(inout), optional, target :: global
type(string_t), intent(in) :: process_id
type(process_entry_t), pointer :: process_entry
if (debug_on) call msg_debug (D_CORE, "integration_create_process")
intg%process_id = process_id
if (present (global)) then
allocate (process_entry)
intg%process => process_entry%process_t
call global%process_stack%push (process_entry)
else
allocate (process_t :: intg%process)
end if
end subroutine integration_create_process
@ %def integration_create_process
@ Initialization, second part: Initialize the process object, using the local
environment. We allocate a RNG factory and a QCD object.
We also fetch a pointer to the model that the process uses. The
process initializer will create a snapshot of that model.
This procedure
does not modify the [[local]] stack directly. The intent(inout) attribute for
the [[local]] data set is due to the random generator seed which may be
incremented during initialization.
NOTE: Changes to model parameters within the current context are respected
only if the process model coincides with the current model. This is the usual
case. If not, we read
the model from the global model library, which has default parameters. To
become more flexible, we should implement a local model library which records
local changes to currently inactive models.
<<Integrations: integration: TBP>>=
procedure :: init_process => integration_init_process
<<Integrations: procedures>>=
subroutine integration_init_process (intg, local)
class(integration_t), intent(inout) :: intg
type(rt_data_t), intent(inout), target :: local
type(string_t) :: model_name
type(model_t), pointer :: model
class(model_data_t), pointer :: model_instance
type(var_list_t), pointer :: var_list
if (debug_on) call msg_debug (D_CORE, "integration_init_process")
if (.not. local%prclib%contains (intg%process_id)) then
call msg_fatal ("Process '" // char (intg%process_id) // "' not found" &
// " in library '" // char (local%prclib%get_name ()) // "'")
return
end if
model_name = local%prclib%get_model_name (intg%process_id)
if (local%get_sval (var_str ("$model_name")) == model_name) then
model => local%model
else
model => local%model_list%get_model_ptr (model_name)
end if
var_list => local%get_var_list_ptr ()
call intg%process%init (intg%process_id, &
local%prclib, &
local%os_data, &
model, &
var_list, &
local%beam_structure)
intg%run_id = intg%process%get_run_id ()
end subroutine integration_init_process
@ %def integration_init_process
@ Initialization, third part: complete process configuration.
<<Integrations: integration: TBP>>=
procedure :: setup_process => integration_setup_process
<<Integrations: procedures>>=
subroutine integration_setup_process (intg, local, verbose, init_only)
class(integration_t), intent(inout) :: intg
type(rt_data_t), intent(inout), target :: local
logical, intent(in), optional :: verbose
logical, intent(in), optional :: init_only
type(var_list_t), pointer :: var_list
class(mci_t), allocatable :: mci_template
type(sf_config_t), dimension(:), allocatable :: sf_config
type(sf_prop_t) :: sf_prop
type(sf_channel_t), dimension(:), allocatable :: sf_channel
type(phs_channel_collection_t) :: phs_channel_collection
logical :: sf_trace
logical :: verb, initialize_only
type(string_t) :: sf_string
type(string_t) :: workspace
real(default) :: sqrts
verb = .true.; if (present (verbose)) verb = verbose
initialize_only = .false.
if (present (init_only)) initialize_only = init_only
call display_init_message (verb)
var_list => local%get_var_list_ptr ()
call setup_log_and_history ()
associate (process => intg%process)
call set_intg_parameters (process)
call process%setup_cores (dispatch_core, &
intg%helicity_selection, intg%use_color_factors, intg%has_beam_pol)
call process%init_phs_config ()
call process%init_components ()
call process%record_inactive_components ()
intg%process_has_me = process%has_matrix_element ()
if (.not. intg%process_has_me) then
call msg_warning ("Process '" &
// char (intg%process_id) // "': matrix element vanishes")
end if
call setup_beams ()
call setup_structure_functions ()
workspace = var_list%get_sval (var_str ("$integrate_workspace"))
if (workspace == "") then
call process%configure_phs &
(intg%rebuild_phs, &
intg%ignore_phs_mismatch, &
intg%combined_integration)
else
call setup_grid_path (workspace)
call process%configure_phs &
(intg%rebuild_phs, &
intg%ignore_phs_mismatch, &
intg%combined_integration, &
workspace)
end if
call process%complete_pcm_setup ()
call process%prepare_blha_cores ()
call process%create_blha_interface ()
call process%prepare_any_external_code ()
call process%setup_terms (with_beams = intg%has_beam_pol)
call process%check_masses ()
call process%optimize_nlo_singular_regions ()
if (verb) then
call process%write (screen = .true.)
call process%print_phs_startup_message ()
end if
if (intg%process_has_me) then
if (size (sf_config) > 0) then
call process%collect_channels (phs_channel_collection)
else if (.not. initialize_only &
.and. process%contains_trivial_component ()) then
call msg_fatal ("Integrate: 2 -> 1 process can't be handled &
&with fixed-energy beams")
end if
if (local%beam_structure%asymmetric ()) then
sqrts = process%get_sqrts ()
else
sqrts = local%get_sqrts ()
end if
call dispatch_sf_channels &
(sf_channel, sf_string, sf_prop, phs_channel_collection, &
local%var_list, sqrts, local%beam_structure)
if (allocated (sf_channel)) then
if (size (sf_channel) > 0) then
call process%set_sf_channel (sf_channel)
end if
end if
call phs_channel_collection%final ()
if (verb) call process%sf_startup_message (sf_string)
end if
call process%setup_mci (dispatch_mci_s)
call setup_expressions ()
call process%compute_md5sum ()
end associate
contains
subroutine setup_log_and_history ()
if (intg%run_id /= "") then
intg%history_filename = intg%process_id // "." // intg%run_id &
// ".history"
intg%log_filename = intg%process_id // "." // intg%run_id // ".log"
else
intg%history_filename = intg%process_id // ".history"
intg%log_filename = intg%process_id // ".log"
end if
intg%vis_history = &
var_list%get_lval (var_str ("?vis_history"))
end subroutine setup_log_and_history
subroutine set_intg_parameters (process)
type(process_t), intent(in) :: process
intg%n_calls_test = &
var_list%get_ival (var_str ("n_calls_test"))
intg%combined_integration = &
var_list%get_lval (var_str ('?combined_nlo_integration')) &
.and. process%is_nlo_calculation ()
intg%use_color_factors = &
var_list%get_lval (var_str ("?read_color_factors"))
intg%has_beam_pol = &
local%beam_structure%has_polarized_beams ()
intg%helicity_selection = &
local%get_helicity_selection ()
intg%rebuild_phs = &
var_list%get_lval (var_str ("?rebuild_phase_space"))
intg%ignore_phs_mismatch = &
.not. var_list%get_lval (var_str ("?check_phs_file"))
intg%phs_only = &
var_list%get_lval (var_str ("?phs_only"))
end subroutine set_intg_parameters
subroutine display_init_message (verb)
logical, intent(in) :: verb
if (verb) then
call msg_message ("Initializing integration for process " &
// char (intg%process_id) // ":")
if (intg%run_id /= "") &
call msg_message ("Run ID = " // '"' // char (intg%run_id) // '"')
end if
end subroutine display_init_message
subroutine setup_beams ()
real(default) :: sqrts
logical :: decay_rest_frame
sqrts = local%get_sqrts ()
decay_rest_frame = &
var_list%get_lval (var_str ("?decay_rest_frame"))
if (intg%process_has_me) then
call intg%process%setup_beams_beam_structure &
(local%beam_structure, sqrts, decay_rest_frame)
end if
if (verb .and. intg%process_has_me) then
call intg%process%beams_startup_message &
(beam_structure = local%beam_structure)
end if
end subroutine setup_beams
subroutine setup_structure_functions ()
integer :: n_in
type(pdg_array_t), dimension(:,:), allocatable :: pdg_prc
type(string_t) :: sf_trace_file
if (intg%process_has_me) then
call intg%process%get_pdg_in (pdg_prc)
else
n_in = intg%process%get_n_in ()
allocate (pdg_prc (n_in, intg%process%get_n_components ()))
pdg_prc = 0
end if
call dispatch_sf_config (sf_config, sf_prop, local%beam_structure, &
local%get_var_list_ptr (), local%var_list, &
local%model, local%os_data, local%get_sqrts (), pdg_prc)
sf_trace = &
var_list%get_lval (var_str ("?sf_trace"))
sf_trace_file = &
var_list%get_sval (var_str ("$sf_trace_file"))
if (sf_trace) then
call intg%process%init_sf_chain (sf_config, sf_trace_file)
else
call intg%process%init_sf_chain (sf_config)
end if
end subroutine setup_structure_functions
subroutine setup_expressions ()
type(eval_tree_factory_t) :: expr_factory
if (associated (local%pn%cuts_lexpr)) then
if (verb) call msg_message ("Applying user-defined cuts.")
call expr_factory%init (local%pn%cuts_lexpr)
call intg%process%set_cuts (expr_factory)
else
if (verb) call msg_warning ("No cuts have been defined.")
end if
if (associated (local%pn%scale_expr)) then
if (verb) call msg_message ("Using user-defined general scale.")
call expr_factory%init (local%pn%scale_expr)
call intg%process%set_scale (expr_factory)
end if
if (associated (local%pn%fac_scale_expr)) then
if (verb) call msg_message ("Using user-defined factorization scale.")
call expr_factory%init (local%pn%fac_scale_expr)
call intg%process%set_fac_scale (expr_factory)
end if
if (associated (local%pn%ren_scale_expr)) then
if (verb) call msg_message ("Using user-defined renormalization scale.")
call expr_factory%init (local%pn%ren_scale_expr)
call intg%process%set_ren_scale (expr_factory)
end if
if (associated (local%pn%weight_expr)) then
if (verb) call msg_message ("Using user-defined reweighting factor.")
call expr_factory%init (local%pn%weight_expr)
call intg%process%set_weight (expr_factory)
end if
end subroutine setup_expressions
end subroutine integration_setup_process
@ %def integration_setup_process
@
\subsection{Integration}
Integrate: do the final integration. Here, we do a multi-iteration
integration. Again, we skip iterations that are already on file.
Record the results in the global variable list.
<<Integrations: integration: TBP>>=
procedure :: evaluate => integration_evaluate
<<Integrations: procedures>>=
subroutine integration_evaluate &
(intg, process_instance, i_mci, pass, it_list, pacify)
class(integration_t), intent(inout) :: intg
type(process_instance_t), intent(inout), target :: process_instance
integer, intent(in) :: i_mci
integer, intent(in) :: pass
type(iterations_list_t), intent(in) :: it_list
logical, intent(in), optional :: pacify
integer :: n_calls, n_it
logical :: adapt_grids, adapt_weights, final
n_it = it_list%get_n_it (pass)
n_calls = it_list%get_n_calls (pass)
adapt_grids = it_list%adapt_grids (pass)
adapt_weights = it_list%adapt_weights (pass)
final = pass == it_list%get_n_pass ()
call process_instance%integrate ( &
i_mci, n_it, n_calls, adapt_grids, adapt_weights, &
final, pacify)
end subroutine integration_evaluate
@ %def integration_evaluate
@ In case the user has not provided a list of iterations, make a
reasonable default. This can depend on the process. The usual
approach is to define two distinct passes, one for adaptation and one
for integration.
<<Integrations: integration: TBP>>=
procedure :: make_iterations_list => integration_make_iterations_list
<<Integrations: procedures>>=
subroutine integration_make_iterations_list (intg, it_list)
class(integration_t), intent(in) :: intg
type(iterations_list_t), intent(out) :: it_list
integer :: pass, n_pass
integer, dimension(:), allocatable :: n_it, n_calls
logical, dimension(:), allocatable :: adapt_grids, adapt_weights
n_pass = intg%process%get_n_pass_default ()
allocate (n_it (n_pass), n_calls (n_pass))
allocate (adapt_grids (n_pass), adapt_weights (n_pass))
do pass = 1, n_pass
n_it(pass) = intg%process%get_n_it_default (pass)
n_calls(pass) = intg%process%get_n_calls_default (pass)
adapt_grids(pass) = intg%process%adapt_grids_default (pass)
adapt_weights(pass) = intg%process%adapt_weights_default (pass)
end do
call it_list%init (n_it, n_calls, &
adapt_grids = adapt_grids, adapt_weights = adapt_weights)
end subroutine integration_make_iterations_list
@ %def integration_make_iterations_list
@ In NLO calculations, the individual components might scale very differently
with the number of calls. This especially applies to the real-subtracted
component, which usually fluctuates more than the Born and virtual
component, making it a bottleneck of the calculation. Thus, the calculation
is throttled twice, first by the number of calls for the real component,
second by the number of surplus calls of computation-intense virtual
matrix elements. Therefore, we want to set a different number of calls
for each component, which is done by the subroutine [[integration_apply_call_multipliers]].
<<Integrations: integration: TBP>>=
procedure :: init_iteration_multipliers => integration_init_iteration_multipliers
<<Integrations: procedures>>=
subroutine integration_init_iteration_multipliers (intg, local)
class(integration_t), intent(inout) :: intg
type(rt_data_t), intent(in) :: local
integer :: n_pass, pass
type(iterations_list_t) :: it_list
n_pass = local%it_list%get_n_pass ()
if (n_pass == 0) then
call intg%make_iterations_list (it_list)
n_pass = it_list%get_n_pass ()
end if
associate (it_multipliers => intg%iteration_multipliers)
allocate (it_multipliers%n_calls0 (n_pass))
do pass = 1, n_pass
it_multipliers%n_calls0(pass) = local%it_list%get_n_calls (pass)
end do
it_multipliers%mult_real = local%var_list%get_rval &
(var_str ("mult_call_real"))
it_multipliers%mult_virt = local%var_list%get_rval &
(var_str ("mult_call_virt"))
it_multipliers%mult_dglap = local%var_list%get_rval &
(var_str ("mult_call_dglap"))
end associate
end subroutine integration_init_iteration_multipliers
@ %def integration_init_iteration_multipliers
@
<<Integrations: integration: TBP>>=
procedure :: apply_call_multipliers => integration_apply_call_multipliers
<<Integrations: procedures>>=
subroutine integration_apply_call_multipliers (intg, n_pass, i_component, it_list)
class(integration_t), intent(in) :: intg
integer, intent(in) :: n_pass, i_component
type(iterations_list_t), intent(inout) :: it_list
integer :: nlo_type
integer :: n_calls0, n_calls
integer :: pass
real(default) :: multiplier
nlo_type = intg%process%get_component_nlo_type (i_component)
do pass = 1, n_pass
associate (multipliers => intg%iteration_multipliers)
select case (nlo_type)
case (NLO_REAL)
multiplier = multipliers%mult_real
case (NLO_VIRTUAL)
multiplier = multipliers%mult_virt
case (NLO_DGLAP)
multiplier = multipliers%mult_dglap
case default
return
end select
end associate
if (n_pass <= size (intg%iteration_multipliers%n_calls0)) then
n_calls0 = intg%iteration_multipliers%n_calls0 (pass)
n_calls = floor (multiplier * n_calls0)
call it_list%set_n_calls (pass, n_calls)
end if
end do
end subroutine integration_apply_call_multipliers
@ %def integration_apply_call_multipliers
@
\subsection{API for integration objects}
This initializer does everything except assigning cuts/scale/weight
expressions.
<<Integrations: integration: TBP>>=
procedure :: init => integration_init
<<Integrations: procedures>>=
subroutine integration_init &
(intg, process_id, local, global, local_stack, init_only)
class(integration_t), intent(out) :: intg
type(string_t), intent(in) :: process_id
type(rt_data_t), intent(inout), target :: local
type(rt_data_t), intent(inout), optional, target :: global
logical, intent(in), optional :: init_only
logical, intent(in), optional :: local_stack
logical :: use_local
use_local = .false.; if (present (local_stack)) use_local = local_stack
if (present (global)) then
call intg%create_process (process_id, global)
else if (use_local) then
call intg%create_process (process_id, local)
else
call intg%create_process (process_id)
end if
call intg%init_process (local)
call intg%setup_process (local, init_only = init_only)
call intg%init_iteration_multipliers (local)
end subroutine integration_init
@ %def integration_init
@ Do the integration for a single process, both warmup and final evaluation.
The [[eff_reset]] flag is to suppress numerical noise in the graphical output
of the integration history.
<<Integrations: integration: TBP>>=
procedure :: integrate => integration_integrate
<<Integrations: procedures>>=
subroutine integration_integrate (intg, local, eff_reset)
class(integration_t), intent(inout) :: intg
type(rt_data_t), intent(in), target :: local
logical, intent(in), optional :: eff_reset
type(string_t) :: log_filename
type(var_list_t), pointer :: var_list
type(process_instance_t), allocatable, target :: process_instance
type(iterations_list_t) :: it_list
logical :: pacify
integer :: pass, i_mci, n_mci, n_pass
integer :: i_component
integer :: nlo_type
logical :: display_summed
logical :: nlo_active
type(string_t) :: component_output
allocate (process_instance)
call process_instance%init (intg%process)
var_list => intg%process%get_var_list_ptr ()
call openmp_set_num_threads_verbose &
(var_list%get_ival (var_str ("openmp_num_threads")), &
var_list%get_lval (var_str ("?openmp_logging")))
pacify = var_list%get_lval (var_str ("?pacify"))
display_summed = .true.
n_mci = intg%process%get_n_mci ()
if (n_mci == 1) then
write (msg_buffer, "(A,A,A)") &
"Starting integration for process '", &
char (intg%process%get_id ()), "'"
call msg_message ()
end if
call setup_hooks ()
nlo_active = any (intg%process%get_component_nlo_type &
([(i_mci, i_mci = 1, n_mci)]) /= BORN)
do i_mci = 1, n_mci
i_component = intg%process%get_master_component (i_mci)
nlo_type = intg%process%get_component_nlo_type (i_component)
if (intg%process%component_can_be_integrated (i_component)) then
if (n_mci > 1) then
if (nlo_active) then
if (intg%combined_integration .and. nlo_type == BORN) then
component_output = var_str ("Combined")
else
component_output = component_status (nlo_type)
end if
write (msg_buffer, "(A,A,A,A,A)") &
"Starting integration for process '", &
char (intg%process%get_id ()), "' part '", &
char (component_output), "'"
else
write (msg_buffer, "(A,A,A,I0)") &
"Starting integration for process '", &
char (intg%process%get_id ()), "' part ", i_mci
end if
call msg_message ()
end if
n_pass = local%it_list%get_n_pass ()
if (n_pass == 0) then
call msg_message ("Integrate: iterations not specified, &
&using default")
call intg%make_iterations_list (it_list)
n_pass = it_list%get_n_pass ()
else
it_list = local%it_list
end if
call intg%apply_call_multipliers (n_pass, i_mci, it_list)
call msg_message ("Integrate: " // char (it_list%to_string ()))
do pass = 1, n_pass
call intg%evaluate (process_instance, i_mci, pass, it_list, pacify)
if (signal_is_pending ()) return
end do
call intg%process%final_integration (i_mci)
if (intg%vis_history) then
call intg%process%display_integration_history &
(i_mci, intg%history_filename, local%os_data, eff_reset)
end if
if (local%logfile == intg%log_filename) then
if (intg%run_id /= "") then
log_filename = intg%process_id // "." // intg%run_id // &
".var.log"
else
log_filename = intg%process_id // ".var.log"
end if
call msg_message ("Name clash for global logfile and process log: ", &
arr =[var_str ("| Renaming log file from ") // local%logfile, &
var_str ("| to ") // log_filename // var_str (" .")])
else
log_filename = intg%log_filename
end if
call intg%process%write_logfile (i_mci, log_filename)
end if
end do
if (n_mci > 1 .and. display_summed) then
call msg_message ("Integrate: sum of all components")
call intg%process%display_summed_results (pacify)
end if
call process_instance%final ()
deallocate (process_instance)
contains
subroutine setup_hooks ()
class(process_instance_hook_t), pointer :: hook
call dispatch_evt_shower_hook (hook, var_list, process_instance)
if (associated (hook)) then
call process_instance%append_after_hook (hook)
end if
end subroutine setup_hooks
end subroutine integration_integrate
@ %def integration_integrate
@ Do a dummy integration for a process which could not be initialized (e.g.,
has no matrix element). The result is zero.
<<Integrations: integration: TBP>>=
procedure :: integrate_dummy => integration_integrate_dummy
<<Integrations: procedures>>=
subroutine integration_integrate_dummy (intg)
class(integration_t), intent(inout) :: intg
call intg%process%integrate_dummy ()
end subroutine integration_integrate_dummy
@ %def integration_integrate_dummy
@ Just sample the matrix element under realistic conditions (but no
cuts); throw away the results.
<<Integrations: integration: TBP>>=
procedure :: sampler_test => integration_sampler_test
<<Integrations: procedures>>=
subroutine integration_sampler_test (intg)
class(integration_t), intent(inout) :: intg
type(process_instance_t), allocatable, target :: process_instance
integer :: n_mci, i_mci
type(timer_t) :: timer_mci, timer_tot
real(default) :: t_mci, t_tot
allocate (process_instance)
call process_instance%init (intg%process)
n_mci = intg%process%get_n_mci ()
if (n_mci == 1) then
write (msg_buffer, "(A,A,A)") &
"Test: probing process '", &
char (intg%process%get_id ()), "'"
call msg_message ()
end if
call timer_tot%start ()
do i_mci = 1, n_mci
if (n_mci > 1) then
write (msg_buffer, "(A,A,A,I0)") &
"Test: probing process '", &
char (intg%process%get_id ()), "' part ", i_mci
call msg_message ()
end if
call timer_mci%start ()
call process_instance%sampler_test (i_mci, intg%n_calls_test)
call timer_mci%stop ()
t_mci = timer_mci
write (msg_buffer, "(A,ES12.5)") "Test: " &
// "time in seconds (wallclock): ", t_mci
call msg_message ()
end do
call timer_tot%stop ()
t_tot = timer_tot
if (n_mci > 1) then
write (msg_buffer, "(A,ES12.5)") "Test: " &
// "total time (wallclock): ", t_tot
call msg_message ()
end if
call process_instance%final ()
end subroutine integration_sampler_test
@ %def integration_sampler_test
@ Return the process pointer (needed by simulate):
<<Integrations: integration: TBP>>=
procedure :: get_process_ptr => integration_get_process_ptr
<<Integrations: procedures>>=
function integration_get_process_ptr (intg) result (ptr)
class(integration_t), intent(in) :: intg
type(process_t), pointer :: ptr
ptr => intg%process
end function integration_get_process_ptr
@ %def integration_get_process_ptr
@ Simply integrate, do a dummy integration if necessary. The [[integration]]
object exists only internally.
If the [[global]] environment is provided, the process object is appended to
the global stack. Otherwise, if [[local_stack]] is set, we append to the
local process stack. If this is unset, the [[process]] object is not recorded
permanently.
The [[init_only]] flag can be used to skip the actual integration part. We
will end up with a process object that is completely initialized, including
phase space configuration.
The [[eff_reset]] flag is to suppress numerical noise in the visualization
of the integration history.
<<Integrations: public>>=
public :: integrate_process
<<Integrations: procedures>>=
subroutine integrate_process (process_id, local, global, local_stack, init_only, eff_reset)
type(string_t), intent(in) :: process_id
type(rt_data_t), intent(inout), target :: local
type(rt_data_t), intent(inout), optional, target :: global
logical, intent(in), optional :: local_stack, init_only, eff_reset
type(string_t) :: prclib_name
type(integration_t) :: intg
character(32) :: buffer
<<Integrations: integrate process: variables>>
<<Integrations: integrate process: init>>
if (.not. associated (local%prclib)) then
call msg_fatal ("Integrate: current process library is undefined")
return
end if
if (.not. local%prclib%is_active ()) then
call msg_message ("Integrate: current process library needs compilation")
prclib_name = local%prclib%get_name ()
call compile_library (prclib_name, local)
if (signal_is_pending ()) return
call msg_message ("Integrate: compilation done")
end if
call intg%init (process_id, local, global, local_stack, init_only)
if (signal_is_pending ()) return
if (present (init_only)) then
if (init_only) return
end if
if (intg%n_calls_test > 0) then
write (buffer, "(I0)") intg%n_calls_test
call msg_message ("Integrate: test (" // trim (buffer) // " calls) ...")
call intg%sampler_test ()
call msg_message ("Integrate: ... test complete.")
if (signal_is_pending ()) return
end if
<<Integrations: integrate process: end init>>
if (intg%phs_only) then
call msg_message ("Integrate: phase space only, skipping integration")
else
if (intg%process_has_me) then
call intg%integrate (local, eff_reset)
else
call intg%integrate_dummy ()
end if
end if
end subroutine integrate_process
@ %def integrate_process
<<Integrations: integrate process: variables>>=
@
<<Integrations: integrate process: init>>=
@
<<Integrations: integrate process: end init>>=
@
@ The parallelization leads to undefined behavior while writing simultaneously to one file.
The master worker has to initialize single-handed the corresponding library files and the phase space file.
The slave worker will wait with a blocking [[MPI_BCAST]] until they receive a logical flag.
<<MPI: Integrations: integrate process: variables>>=
type(var_list_t), pointer :: var_list
logical :: mpi_logging, process_init
integer :: rank, n_size
<<MPI: Integrations: integrate process: init>>=
if (debug_on) call msg_debug (D_MPI, "integrate_process")
var_list => local%get_var_list_ptr ()
process_init = .false.
call mpi_get_comm_id (n_size, rank)
mpi_logging = (("vamp2" == char (var_list%get_sval (var_str ("$integration_method"))) .and. &
& (n_size > 1)) .or. var_list%get_lval (var_str ("?mpi_logging")))
if (debug_on) call msg_debug (D_MPI, "n_size", rank)
if (debug_on) call msg_debug (D_MPI, "rank", rank)
if (debug_on) call msg_debug (D_MPI, "mpi_logging", mpi_logging)
if (rank /= 0) then
if (mpi_logging) then
call msg_message ("MPI: wait for master to finish process initialization ...")
end if
call MPI_bcast (process_init, 1, MPI_LOGICAL, 0, MPI_COMM_WORLD)
else
process_init = .true.
end if
if (process_init) then
<<MPI: Integrations: integrate process: end init>>=
if (rank == 0) then
if (mpi_logging) then
call msg_message ("MPI: finish process initialization, load slaves ...")
end if
call MPI_bcast (process_init, 1, MPI_LOGICAL, 0, MPI_COMM_WORLD)
end if
end if
call MPI_barrier (MPI_COMM_WORLD)
call mpi_set_logging (mpi_logging)
@ %def integrate_process_mpi
@
\subsection{Unit Tests}
Test module, followed by the stand-alone unit-test procedures.
<<[[integrations_ut.f90]]>>=
<<File header>>
module integrations_ut
use unit_tests
use integrations_uti
<<Standard module head>>
<<Integrations: public test>>
contains
<<Integrations: test driver>>
end module integrations_ut
@ %def integrations_ut
@
<<[[integrations_uti.f90]]>>=
<<File header>>
module integrations_uti
<<Use kinds>>
<<Use strings>>
use io_units
use ifiles
use lexers
use parser
use flavors
use interactions, only: reset_interaction_counter
use phs_forests
use eval_trees
use models
use rt_data
use process_configurations_ut, only: prepare_test_library
use compilations, only: compile_library
use integrations
use phs_wood_ut, only: write_test_phs_file
<<Standard module head>>
<<Integrations: test declarations>>
contains
<<Integrations: tests>>
end module integrations_uti
@ %def integrations_uti
@ API: driver for the unit tests below.
<<Integrations: public test>>=
public :: integrations_test
<<Integrations: test driver>>=
subroutine integrations_test (u, results)
integer, intent(in) :: u
type(test_results_t), intent(inout) :: results
<<Integrations: execute tests>>
end subroutine integrations_test
@ %def integrations_test
@
<<Integrations: public test>>=
public :: integrations_history_test
<<Integrations: test driver>>=
subroutine integrations_history_test (u, results)
integer, intent(in) :: u
type(test_results_t), intent(inout) :: results
<<Integrations: execute history tests>>
end subroutine integrations_history_test
@ %def integrations_history_test
@
\subsubsection{Integration of test process}
Compile and integrate an intrinsic test matrix element ([[prc_test]]
type). The phase-space implementation is [[phs_single]]
(single-particle phase space), the integrator is [[mci_midpoint]].
The cross section for the $2\to 2$ process $ss\to ss$ with its
constant matrix element is given by
\begin{equation}
\sigma = c\times f\times \Phi_2 \times |M|^2.
\end{equation}
$c$ is the conversion constant
\begin{equation}
c = 0.3894\times 10^{12}\;\mathrm{fb}\,\mathrm{GeV}^2.
\end{equation}
$f$ is the flux of the incoming particles with mass
$m=125\,\mathrm{GeV}$ and energy $\sqrt{s}=1000\,\mathrm{GeV}$
\begin{equation}
f = \frac{(2\pi)^4}{2\lambda^{1/2}(s,m^2,m^2)}
= \frac{(2\pi)^4}{2\sqrt{s}\,\sqrt{s - 4m^2}}
= 8.048\times 10^{-4}\;\mathrm{GeV}^{-2}
\end{equation}
$\Phi_2$ is the volume of the two-particle phase space
\begin{equation}
\Phi_2 = \frac{1}{4(2\pi)^5} = 2.5529\times 10^{-5}.
\end{equation}
The squared matrix element $|M|^2$ is unity.
Combining everything, we obtain
\begin{equation}
\sigma = 8000\;\mathrm{fb}
\end{equation}
This number should appear as the final result.
Note: In this and the following test, we reset the Fortran compiler and flag
variables immediately before they are printed, so the test is portable.
<<Integrations: execute tests>>=
call test (integrations_1, "integrations_1", &
"intrinsic test process", &
u, results)
<<Integrations: test declarations>>=
public :: integrations_1
<<Integrations: tests>>=
subroutine integrations_1 (u)
integer, intent(in) :: u
type(string_t) :: libname, procname
type(rt_data_t), target :: global
write (u, "(A)") "* Test output: integrations_1"
write (u, "(A)") "* Purpose: integrate test process"
write (u, "(A)")
call syntax_model_file_init ()
call global%global_init ()
libname = "integration_1"
procname = "prc_config_a"
call prepare_test_library (global, libname, 1)
call compile_library (libname, global)
call global%set_string (var_str ("$run_id"), &
var_str ("integrations1"), is_known = .true.)
call global%set_string (var_str ("$method"), &
var_str ("unit_test"), is_known = .true.)
call global%set_string (var_str ("$phs_method"), &
var_str ("single"), is_known = .true.)
call global%set_string (var_str ("$integration_method"),&
var_str ("midpoint"), is_known = .true.)
call global%set_log (var_str ("?vis_history"),&
.false., is_known = .true.)
call global%set_log (var_str ("?integration_timer"),&
.false., is_known = .true.)
call global%set_int (var_str ("seed"), &
0, is_known=.true.)
call global%set_real (var_str ("sqrts"),&
1000._default, is_known = .true.)
call global%it_list%init ([1], [1000])
call reset_interaction_counter ()
call integrate_process (procname, global, local_stack=.true.)
call global%write (u, vars = [ &
var_str ("$method"), &
var_str ("sqrts"), &
var_str ("$integration_method"), &
var_str ("$phs_method"), &
var_str ("$run_id")])
call global%final ()
call syntax_model_file_final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: integrations_1"
end subroutine integrations_1
@ %def integrations_1
@
\subsubsection{Integration with cuts}
Compile and integrate an intrinsic test matrix element ([[prc_test]]
type) with cuts set.
<<Integrations: execute tests>>=
call test (integrations_2, "integrations_2", &
"intrinsic test process with cut", &
u, results)
<<Integrations: test declarations>>=
public :: integrations_2
<<Integrations: tests>>=
subroutine integrations_2 (u)
integer, intent(in) :: u
type(string_t) :: libname, procname
type(rt_data_t), target :: global
type(string_t) :: cut_expr_text
type(ifile_t) :: ifile
type(stream_t) :: stream
type(parse_tree_t) :: parse_tree
type(string_t), dimension(0) :: empty_string_array
write (u, "(A)") "* Test output: integrations_2"
write (u, "(A)") "* Purpose: integrate test process with cut"
write (u, "(A)")
call syntax_model_file_init ()
call global%global_init ()
write (u, "(A)") "* Prepare a cut expression"
write (u, "(A)")
call syntax_pexpr_init ()
cut_expr_text = "all Pt > 100 [s]"
call ifile_append (ifile, cut_expr_text)
call stream_init (stream, ifile)
call parse_tree_init_lexpr (parse_tree, stream, .true.)
global%pn%cuts_lexpr => parse_tree%get_root_ptr ()
write (u, "(A)") "* Build and initialize a test process"
write (u, "(A)")
libname = "integration_3"
procname = "prc_config_a"
call prepare_test_library (global, libname, 1)
call compile_library (libname, global)
call global%set_string (var_str ("$run_id"), &
var_str ("integrations1"), is_known = .true.)
call global%set_string (var_str ("$method"), &
var_str ("unit_test"), is_known = .true.)
call global%set_string (var_str ("$phs_method"), &
var_str ("single"), is_known = .true.)
call global%set_string (var_str ("$integration_method"),&
var_str ("midpoint"), is_known = .true.)
call global%set_log (var_str ("?vis_history"),&
.false., is_known = .true.)
call global%set_log (var_str ("?integration_timer"),&
.false., is_known = .true.)
call global%set_int (var_str ("seed"), &
0, is_known=.true.)
call global%set_real (var_str ("sqrts"),&
1000._default, is_known = .true.)
call global%it_list%init ([1], [1000])
call reset_interaction_counter ()
call integrate_process (procname, global, local_stack=.true.)
call global%write (u, vars = empty_string_array)
call global%final ()
call syntax_model_file_final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: integrations_2"
end subroutine integrations_2
@ %def integrations_2
@
\subsubsection{Standard phase space}
Compile and integrate an intrinsic test matrix element ([[prc_test]]
type) using the default ([[phs_wood]]) phase-space implementation. We
use an explicit phase-space configuration file with a single channel
and integrate by [[mci_midpoint]].
<<Integrations: execute tests>>=
call test (integrations_3, "integrations_3", &
"standard phase space", &
u, results)
<<Integrations: test declarations>>=
public :: integrations_3
<<Integrations: tests>>=
subroutine integrations_3 (u)
<<Use kinds>>
<<Use strings>>
use interactions, only: reset_interaction_counter
use models
use rt_data
use process_configurations_ut, only: prepare_test_library
use compilations, only: compile_library
use integrations
implicit none
integer, intent(in) :: u
type(string_t) :: libname, procname
type(rt_data_t), target :: global
integer :: u_phs
write (u, "(A)") "* Test output: integrations_3"
write (u, "(A)") "* Purpose: integrate test process"
write (u, "(A)")
write (u, "(A)") "* Initialize process and parameters"
write (u, "(A)")
call syntax_model_file_init ()
call syntax_phs_forest_init ()
call global%global_init ()
libname = "integration_3"
procname = "prc_config_a"
call prepare_test_library (global, libname, 1)
call compile_library (libname, global)
call global%set_string (var_str ("$run_id"), &
var_str ("integrations1"), is_known = .true.)
call global%set_string (var_str ("$method"), &
var_str ("unit_test"), is_known = .true.)
call global%set_string (var_str ("$phs_method"), &
var_str ("default"), is_known = .true.)
call global%set_string (var_str ("$integration_method"),&
var_str ("midpoint"), is_known = .true.)
call global%set_log (var_str ("?vis_history"),&
.false., is_known = .true.)
call global%set_log (var_str ("?integration_timer"),&
.false., is_known = .true.)
call global%set_log (var_str ("?phs_s_mapping"),&
.false., is_known = .true.)
call global%set_int (var_str ("seed"), &
0, is_known=.true.)
call global%set_real (var_str ("sqrts"),&
1000._default, is_known = .true.)
write (u, "(A)") "* Create a scratch phase-space file"
write (u, "(A)")
u_phs = free_unit ()
open (u_phs, file = "integrations_3.phs", &
status = "replace", action = "write")
call write_test_phs_file (u_phs, var_str ("prc_config_a_i1"))
close (u_phs)
call global%set_string (var_str ("$phs_file"),&
var_str ("integrations_3.phs"), is_known = .true.)
call global%it_list%init ([1], [1000])
write (u, "(A)") "* Integrate"
write (u, "(A)")
call reset_interaction_counter ()
call integrate_process (procname, global, local_stack=.true.)
call global%write (u, vars = [ &
var_str ("$phs_method"), &
var_str ("$phs_file")])
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call global%final ()
call syntax_phs_forest_final ()
call syntax_model_file_final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: integrations_3"
end subroutine integrations_3
@ %def integrations_3
@
\subsubsection{VAMP integration}
Compile and integrate an intrinsic test matrix element ([[prc_test]]
type) using the single-channel ([[phs_single]]) phase-space
implementation. The integration method is [[vamp]].
<<Integrations: execute tests>>=
call test (integrations_4, "integrations_4", &
"VAMP integration (one iteration)", &
u, results)
<<Integrations: test declarations>>=
public :: integrations_4
<<Integrations: tests>>=
subroutine integrations_4 (u)
integer, intent(in) :: u
type(string_t) :: libname, procname
type(rt_data_t), target :: global
write (u, "(A)") "* Test output: integrations_4"
write (u, "(A)") "* Purpose: integrate test process using VAMP"
write (u, "(A)")
write (u, "(A)") "* Initialize process and parameters"
write (u, "(A)")
call syntax_model_file_init ()
call global%global_init ()
libname = "integrations_4_lib"
procname = "integrations_4"
call prepare_test_library (global, libname, 1, [procname])
call compile_library (libname, global)
call global%append_log (&
var_str ("?rebuild_grids"), .true., intrinsic = .true.)
call global%set_string (var_str ("$run_id"), &
var_str ("r1"), is_known = .true.)
call global%set_string (var_str ("$method"), &
var_str ("unit_test"), is_known = .true.)
call global%set_string (var_str ("$phs_method"), &
var_str ("single"), is_known = .true.)
call global%set_string (var_str ("$integration_method"),&
var_str ("vamp"), is_known = .true.)
call global%set_log (var_str ("?use_vamp_equivalences"),&
.false., is_known = .true.)
call global%set_log (var_str ("?vis_history"),&
.false., is_known = .true.)
call global%set_log (var_str ("?integration_timer"),&
.false., is_known = .true.)
call global%set_int (var_str ("seed"), &
0, is_known=.true.)
call global%set_real (var_str ("sqrts"),&
1000._default, is_known = .true.)
call global%it_list%init ([1], [1000])
write (u, "(A)") "* Integrate"
write (u, "(A)")
call reset_interaction_counter ()
call integrate_process (procname, global, local_stack=.true.)
call global%pacify (efficiency_reset = .true., error_reset = .true.)
call global%write (u, vars = [var_str ("$integration_method")], &
pacify = .true.)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call global%final ()
call syntax_model_file_final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: integrations_4"
end subroutine integrations_4
@ %def integrations_4
@
\subsubsection{Multiple iterations integration}
Compile and integrate an intrinsic test matrix element ([[prc_test]]
type) using the single-channel ([[phs_single]]) phase-space
implementation. The integration method is [[vamp]]. We launch three
iterations.
<<Integrations: execute tests>>=
call test (integrations_5, "integrations_5", &
"VAMP integration (three iterations)", &
u, results)
<<Integrations: test declarations>>=
public :: integrations_5
<<Integrations: tests>>=
subroutine integrations_5 (u)
integer, intent(in) :: u
type(string_t) :: libname, procname
type(rt_data_t), target :: global
write (u, "(A)") "* Test output: integrations_5"
write (u, "(A)") "* Purpose: integrate test process using VAMP"
write (u, "(A)")
write (u, "(A)") "* Initialize process and parameters"
write (u, "(A)")
call syntax_model_file_init ()
call global%global_init ()
libname = "integrations_5_lib"
procname = "integrations_5"
call prepare_test_library (global, libname, 1, [procname])
call compile_library (libname, global)
call global%append_log (&
var_str ("?rebuild_grids"), .true., intrinsic = .true.)
call global%set_string (var_str ("$run_id"), &
var_str ("r1"), is_known = .true.)
call global%set_string (var_str ("$method"), &
var_str ("unit_test"), is_known = .true.)
call global%set_string (var_str ("$phs_method"), &
var_str ("single"), is_known = .true.)
call global%set_string (var_str ("$integration_method"),&
var_str ("vamp"), is_known = .true.)
call global%set_log (var_str ("?use_vamp_equivalences"),&
.false., is_known = .true.)
call global%set_log (var_str ("?vis_history"),&
.false., is_known = .true.)
call global%set_log (var_str ("?integration_timer"),&
.false., is_known = .true.)
call global%set_int (var_str ("seed"), &
0, is_known=.true.)
call global%set_real (var_str ("sqrts"),&
1000._default, is_known = .true.)
call global%it_list%init ([3], [1000])
write (u, "(A)") "* Integrate"
write (u, "(A)")
call reset_interaction_counter ()
call integrate_process (procname, global, local_stack=.true.)
call global%pacify (efficiency_reset = .true., error_reset = .true.)
call global%write (u, vars = [var_str ("$integration_method")], &
pacify = .true.)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call global%final ()
call syntax_model_file_final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: integrations_5"
end subroutine integrations_5
@ %def integrations_5
@
\subsubsection{Multiple passes integration}
Compile and integrate an intrinsic test matrix element ([[prc_test]]
type) using the single-channel ([[phs_single]]) phase-space
implementation. The integration method is [[vamp]]. We launch three
passes with three iterations each.
<<Integrations: execute tests>>=
call test (integrations_6, "integrations_6", &
"VAMP integration (three passes)", &
u, results)
<<Integrations: test declarations>>=
public :: integrations_6
<<Integrations: tests>>=
subroutine integrations_6 (u)
integer, intent(in) :: u
type(string_t) :: libname, procname
type(rt_data_t), target :: global
type(string_t), dimension(0) :: no_vars
write (u, "(A)") "* Test output: integrations_6"
write (u, "(A)") "* Purpose: integrate test process using VAMP"
write (u, "(A)")
write (u, "(A)") "* Initialize process and parameters"
write (u, "(A)")
call syntax_model_file_init ()
call global%global_init ()
libname = "integrations_6_lib"
procname = "integrations_6"
call prepare_test_library (global, libname, 1, [procname])
call compile_library (libname, global)
call global%append_log (&
var_str ("?rebuild_grids"), .true., intrinsic = .true.)
call global%set_string (var_str ("$run_id"), &
var_str ("r1"), is_known = .true.)
call global%set_string (var_str ("$method"), &
var_str ("unit_test"), is_known = .true.)
call global%set_string (var_str ("$phs_method"), &
var_str ("single"), is_known = .true.)
call global%set_string (var_str ("$integration_method"),&
var_str ("vamp"), is_known = .true.)
call global%set_log (var_str ("?use_vamp_equivalences"),&
.false., is_known = .true.)
call global%set_log (var_str ("?vis_history"),&
.false., is_known = .true.)
call global%set_log (var_str ("?integration_timer"),&
.false., is_known = .true.)
call global%set_int (var_str ("seed"), &
0, is_known=.true.)
call global%set_real (var_str ("sqrts"),&
1000._default, is_known = .true.)
call global%it_list%init ([3, 3, 3], [1000, 1000, 1000], &
adapt = [.true., .true., .false.], &
adapt_code = [var_str ("wg"), var_str ("g"), var_str ("")])
write (u, "(A)") "* Integrate"
write (u, "(A)")
call reset_interaction_counter ()
call integrate_process (procname, global, local_stack=.true.)
call global%pacify (efficiency_reset = .true., error_reset = .true.)
call global%write (u, vars = no_vars, pacify = .true.)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call global%final ()
call syntax_model_file_final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: integrations_6"
end subroutine integrations_6
@ %def integrations_6
@
\subsubsection{VAMP and default phase space}
Compile and integrate an intrinsic test matrix element ([[prc_test]]
type) using the default ([[phs_wood]]) phase-space
implementation. The integration method is [[vamp]]. We launch three
passes with three iterations each. We enable channel equivalences and
groves.
<<Integrations: execute tests>>=
call test (integrations_7, "integrations_7", &
"VAMP integration with wood phase space", &
u, results)
<<Integrations: test declarations>>=
public :: integrations_7
<<Integrations: tests>>=
subroutine integrations_7 (u)
integer, intent(in) :: u
type(string_t) :: libname, procname
type(rt_data_t), target :: global
type(string_t), dimension(0) :: no_vars
integer :: iostat, u_phs
character(95) :: buffer
type(string_t) :: phs_file
logical :: exist
write (u, "(A)") "* Test output: integrations_7"
write (u, "(A)") "* Purpose: integrate test process using VAMP"
write (u, "(A)")
write (u, "(A)") "* Initialize process and parameters"
write (u, "(A)")
call syntax_model_file_init ()
call syntax_phs_forest_init ()
call global%global_init ()
libname = "integrations_7_lib"
procname = "integrations_7"
call prepare_test_library (global, libname, 1, [procname])
call compile_library (libname, global)
call global%append_log (&
var_str ("?rebuild_phase_space"), .true., intrinsic = .true.)
call global%append_log (&
var_str ("?rebuild_grids"), .true., intrinsic = .true.)
call global%set_string (var_str ("$run_id"), &
var_str ("r1"), is_known = .true.)
call global%set_string (var_str ("$method"), &
var_str ("unit_test"), is_known = .true.)
call global%set_string (var_str ("$phs_method"), &
var_str ("wood"), is_known = .true.)
call global%set_string (var_str ("$integration_method"),&
var_str ("vamp"), is_known = .true.)
call global%set_log (var_str ("?use_vamp_equivalences"),&
.true., is_known = .true.)
call global%set_log (var_str ("?vis_history"),&
.false., is_known = .true.)
call global%set_log (var_str ("?integration_timer"),&
.false., is_known = .true.)
call global%set_log (var_str ("?phs_s_mapping"),&
.false., is_known = .true.)
call global%set_int (var_str ("seed"), &
0, is_known=.true.)
call global%set_real (var_str ("sqrts"),&
1000._default, is_known = .true.)
call global%it_list%init ([3, 3, 3], [1000, 1000, 1000], &
adapt = [.true., .true., .false.], &
adapt_code = [var_str ("wg"), var_str ("g"), var_str ("")])
write (u, "(A)") "* Integrate"
write (u, "(A)")
call reset_interaction_counter ()
call integrate_process (procname, global, local_stack=.true.)
call global%pacify (efficiency_reset = .true., error_reset = .true.)
call global%write (u, vars = no_vars, pacify = .true.)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call global%final ()
call syntax_phs_forest_final ()
call syntax_model_file_final ()
write (u, "(A)")
write (u, "(A)") "* Generated phase-space file"
write (u, "(A)")
phs_file = procname // ".r1.i1.phs"
inquire (file = char (phs_file), exist = exist)
if (exist) then
u_phs = free_unit ()
open (u_phs, file = char (phs_file), action = "read", status = "old")
iostat = 0
do while (iostat == 0)
read (u_phs, "(A)", iostat = iostat) buffer
if (iostat == 0) write (u, "(A)") trim (buffer)
end do
close (u_phs)
else
write (u, "(A)") "[file is missing]"
end if
write (u, "(A)")
write (u, "(A)") "* Test output end: integrations_7"
end subroutine integrations_7
@ %def integrations_7
@
\subsubsection{Structure functions}
Compile and integrate an intrinsic test matrix element ([[prc_test]]
type) using the default ([[phs_wood]]) phase-space
implementation. The integration method is [[vamp]]. There is a structure
function of type [[unit_test]].
We use a test structure function $f(x)=x$ for both beams. Together with the
$1/x_1x_2$ factor from the phase-space flux and a unit matrix element, we
should get the same result as previously for the process without structure
functions. There is a slight correction due to the $m_s$ mass which we set to
zero here.
<<Integrations: execute tests>>=
call test (integrations_8, "integrations_8", &
"integration with structure function", &
u, results)
<<Integrations: test declarations>>=
public :: integrations_8
<<Integrations: tests>>=
subroutine integrations_8 (u)
<<Use kinds>>
<<Use strings>>
use interactions, only: reset_interaction_counter
use phs_forests
use models
use rt_data
use process_configurations_ut, only: prepare_test_library
use compilations, only: compile_library
use integrations
implicit none
integer, intent(in) :: u
type(string_t) :: libname, procname
type(rt_data_t), target :: global
type(flavor_t) :: flv
type(string_t) :: name
write (u, "(A)") "* Test output: integrations_8"
write (u, "(A)") "* Purpose: integrate test process using VAMP &
&with structure function"
write (u, "(A)")
write (u, "(A)") "* Initialize process and parameters"
write (u, "(A)")
call syntax_model_file_init ()
call syntax_phs_forest_init ()
call global%global_init ()
libname = "integrations_8_lib"
procname = "integrations_8"
call prepare_test_library (global, libname, 1, [procname])
call compile_library (libname, global)
call global%append_log (&
var_str ("?rebuild_phase_space"), .true., intrinsic = .true.)
call global%append_log (&
var_str ("?rebuild_grids"), .true., intrinsic = .true.)
call global%set_string (var_str ("$run_id"), &
var_str ("r1"), is_known = .true.)
call global%set_string (var_str ("$method"), &
var_str ("unit_test"), is_known = .true.)
call global%set_string (var_str ("$phs_method"), &
var_str ("wood"), is_known = .true.)
call global%set_string (var_str ("$integration_method"),&
var_str ("vamp"), is_known = .true.)
call global%set_log (var_str ("?use_vamp_equivalences"),&
.true., is_known = .true.)
call global%set_log (var_str ("?vis_history"),&
.false., is_known = .true.)
call global%set_log (var_str ("?integration_timer"),&
.false., is_known = .true.)
call global%set_log (var_str ("?phs_s_mapping"),&
.false., is_known = .true.)
call global%set_int (var_str ("seed"), &
0, is_known=.true.)
call global%set_real (var_str ("sqrts"),&
1000._default, is_known = .true.)
call global%model_set_real (var_str ("ms"), 0._default)
call reset_interaction_counter ()
call flv%init (25, global%model)
name = flv%get_name ()
call global%beam_structure%init_sf ([name, name], [1])
call global%beam_structure%set_sf (1, 1, var_str ("sf_test_1"))
write (u, "(A)") "* Integrate"
write (u, "(A)")
call global%it_list%init ([1], [1000])
call integrate_process (procname, global, local_stack=.true.)
call global%write (u, vars = [var_str ("ms")])
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call global%final ()
call syntax_phs_forest_final ()
call syntax_model_file_final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: integrations_8"
end subroutine integrations_8
@ %def integrations_8
@
\subsubsection{Integration with sign change}
Compile and integrate an intrinsic test matrix element ([[prc_test]]
type). The phase-space implementation is [[phs_single]]
(single-particle phase space), the integrator is [[mci_midpoint]].
The weight that is applied changes the sign in half of phase space.
The weight is $-3$ and $1$, respectively, so the total result is equal
to the original, but negative sign.
The efficiency should (approximately) become the average of $1$ and
$1/3$, that is $2/3$.
<<Integrations: execute tests>>=
call test (integrations_9, "integrations_9", &
"handle sign change", &
u, results)
<<Integrations: test declarations>>=
public :: integrations_9
<<Integrations: tests>>=
subroutine integrations_9 (u)
integer, intent(in) :: u
type(string_t) :: libname, procname
type(rt_data_t), target :: global
type(string_t) :: wgt_expr_text
type(ifile_t) :: ifile
type(stream_t) :: stream
type(parse_tree_t) :: parse_tree
write (u, "(A)") "* Test output: integrations_9"
write (u, "(A)") "* Purpose: integrate test process"
write (u, "(A)")
call syntax_model_file_init ()
call global%global_init ()
write (u, "(A)") "* Prepare a weight expression"
write (u, "(A)")
call syntax_pexpr_init ()
wgt_expr_text = "eval 2 * sgn (Pz) - 1 [s]"
call ifile_append (ifile, wgt_expr_text)
call stream_init (stream, ifile)
call parse_tree_init_expr (parse_tree, stream, .true.)
global%pn%weight_expr => parse_tree%get_root_ptr ()
write (u, "(A)") "* Build and evaluate a test process"
write (u, "(A)")
libname = "integration_9"
procname = "prc_config_a"
call prepare_test_library (global, libname, 1)
call compile_library (libname, global)
call global%set_string (var_str ("$run_id"), &
var_str ("integrations1"), is_known = .true.)
call global%set_string (var_str ("$method"), &
var_str ("unit_test"), is_known = .true.)
call global%set_string (var_str ("$phs_method"), &
var_str ("single"), is_known = .true.)
call global%set_string (var_str ("$integration_method"),&
var_str ("midpoint"), is_known = .true.)
call global%set_log (var_str ("?vis_history"),&
.false., is_known = .true.)
call global%set_log (var_str ("?integration_timer"),&
.false., is_known = .true.)
call global%set_int (var_str ("seed"), &
0, is_known=.true.)
call global%set_real (var_str ("sqrts"),&
1000._default, is_known = .true.)
call global%it_list%init ([1], [1000])
call reset_interaction_counter ()
call integrate_process (procname, global, local_stack=.true.)
call global%write (u, vars = [ &
var_str ("$method"), &
var_str ("sqrts"), &
var_str ("$integration_method"), &
var_str ("$phs_method"), &
var_str ("$run_id")])
call global%final ()
call syntax_model_file_final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: integrations_9"
end subroutine integrations_9
@ %def integrations_9
@
\subsubsection{Integration history for VAMP integration with default
phase space}
This test is only run when event analysis can be done.
<<Integrations: execute history tests>>=
call test (integrations_history_1, "integrations_history_1", &
"Test integration history files", &
u, results)
<<Integrations: test declarations>>=
public :: integrations_history_1
<<Integrations: tests>>=
subroutine integrations_history_1 (u)
integer, intent(in) :: u
type(string_t) :: libname, procname
type(rt_data_t), target :: global
type(string_t), dimension(0) :: no_vars
integer :: iostat, u_his
character(91) :: buffer
type(string_t) :: his_file, ps_file, pdf_file
logical :: exist, exist_ps, exist_pdf
write (u, "(A)") "* Test output: integrations_history_1"
write (u, "(A)") "* Purpose: test integration history files"
write (u, "(A)")
write (u, "(A)") "* Initialize process and parameters"
write (u, "(A)")
call syntax_model_file_init ()
call syntax_phs_forest_init ()
call global%global_init ()
libname = "integrations_history_1_lib"
procname = "integrations_history_1"
call global%set_log (var_str ("?vis_history"), &
.true., is_known = .true.)
call global%set_log (var_str ("?integration_timer"),&
.false., is_known = .true.)
call global%set_log (var_str ("?phs_s_mapping"),&
.false., is_known = .true.)
call prepare_test_library (global, libname, 1, [procname])
call compile_library (libname, global)
call global%append_log (&
var_str ("?rebuild_phase_space"), .true., intrinsic = .true.)
call global%append_log (&
var_str ("?rebuild_grids"), .true., intrinsic = .true.)
call global%set_string (var_str ("$run_id"), &
var_str ("r1"), is_known = .true.)
call global%set_string (var_str ("$method"), &
var_str ("unit_test"), is_known = .true.)
call global%set_string (var_str ("$phs_method"), &
var_str ("wood"), is_known = .true.)
call global%set_string (var_str ("$integration_method"),&
var_str ("vamp"), is_known = .true.)
call global%set_log (var_str ("?use_vamp_equivalences"),&
.true., is_known = .true.)
call global%set_real (var_str ("error_threshold"),&
5E-6_default, is_known = .true.)
call global%set_int (var_str ("seed"), &
0, is_known=.true.)
call global%set_real (var_str ("sqrts"),&
1000._default, is_known = .true.)
call global%it_list%init ([2, 2, 2], [1000, 1000, 1000], &
adapt = [.true., .true., .false.], &
adapt_code = [var_str ("wg"), var_str ("g"), var_str ("")])
write (u, "(A)") "* Integrate"
write (u, "(A)")
call reset_interaction_counter ()
call integrate_process (procname, global, local_stack=.true., &
eff_reset = .true.)
call global%pacify (efficiency_reset = .true., error_reset = .true.)
call global%write (u, vars = no_vars, pacify = .true.)
write (u, "(A)")
write (u, "(A)") "* Generated history files"
write (u, "(A)")
his_file = procname // ".r1.history.tex"
ps_file = procname // ".r1.history.ps"
pdf_file = procname // ".r1.history.pdf"
inquire (file = char (his_file), exist = exist)
if (exist) then
u_his = free_unit ()
open (u_his, file = char (his_file), action = "read", status = "old")
iostat = 0
do while (iostat == 0)
read (u_his, "(A)", iostat = iostat) buffer
if (iostat == 0) write (u, "(A)") trim (buffer)
end do
close (u_his)
else
write (u, "(A)") "[History LaTeX file is missing]"
end if
inquire (file = char (ps_file), exist = exist_ps)
if (exist_ps) then
write (u, "(A)") "[History Postscript file exists and is nonempty]"
else
write (u, "(A)") "[History Postscript file is missing/non-regular]"
end if
inquire (file = char (pdf_file), exist = exist_pdf)
if (exist_pdf) then
write (u, "(A)") "[History PDF file exists and is nonempty]"
else
write (u, "(A)") "[History PDF file is missing/non-regular]"
end if
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call global%final ()
call syntax_phs_forest_final ()
call syntax_model_file_final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: integrations_history_1"
end subroutine integrations_history_1
@ %def integrations_history_1
@
\clearpage
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{Event Streams}
This module manages I/O from/to multiple concurrent event streams.
Usually, there is at most one input stream, but several output
streams. For the latter, we set up an array which can hold [[eio_t]]
(event I/O) objects of different dynamic types simultaneously. One of
them may be marked as an input channel.
<<[[event_streams.f90]]>>=
<<File header>>
module event_streams
<<Use strings>>
use io_units
use diagnostics
use events
use event_handles, only: event_handle_t
use eio_data
use eio_base
use rt_data
use dispatch_transforms, only: dispatch_eio
<<Standard module head>>
<<Event streams: public>>
<<Event streams: types>>
contains
<<Event streams: procedures>>
end module event_streams
@ %def event_streams
@
\subsection{Event Stream Array}
Each entry is an [[eio_t]] object. Since the type is dynamic, we need
a wrapper:
<<Event streams: types>>=
type :: event_stream_entry_t
class(eio_t), allocatable :: eio
end type event_stream_entry_t
@ %def event_stream_entry_t
@ An array of event-stream entry objects. If one of the entries is an
input channel, [[i_in]] is the corresponding index.
<<Event streams: public>>=
public :: event_stream_array_t
<<Event streams: types>>=
type :: event_stream_array_t
type(event_stream_entry_t), dimension(:), allocatable :: entry
integer :: i_in = 0
contains
<<Event streams: event stream array: TBP>>
end type event_stream_array_t
@ %def event_stream_array_t
@ Output.
<<Event streams: event stream array: TBP>>=
procedure :: write => event_stream_array_write
<<Event streams: procedures>>=
subroutine event_stream_array_write (object, unit)
class(event_stream_array_t), intent(in) :: object
integer, intent(in), optional :: unit
integer :: u, i
u = given_output_unit (unit)
write (u, "(1x,A)") "Event stream array:"
if (allocated (object%entry)) then
select case (size (object%entry))
case (0)
write (u, "(3x,A)") "[empty]"
case default
do i = 1, size (object%entry)
if (i == object%i_in) write (u, "(1x,A)") "Input stream:"
call object%entry(i)%eio%write (u)
end do
end select
else
write (u, "(3x,A)") "[undefined]"
end if
end subroutine event_stream_array_write
@ %def event_stream_array_write
@ Check if there is content.
<<Event streams: event stream array: TBP>>=
procedure :: is_valid => event_stream_array_is_valid
<<Event streams: procedures>>=
function event_stream_array_is_valid (es_array) result (flag)
class(event_stream_array_t), intent(in) :: es_array
logical :: flag
flag = allocated (es_array%entry)
end function event_stream_array_is_valid
@ %def event_stream_array_is_valid
@ Finalize all streams.
<<Event streams: event stream array: TBP>>=
procedure :: final => event_stream_array_final
<<Event streams: procedures>>=
subroutine event_stream_array_final (es_array)
class(event_stream_array_t), intent(inout) :: es_array
integer :: i
if (allocated (es_array%entry)) then
do i = 1, size (es_array%entry)
call es_array%entry(i)%eio%final ()
end do
end if
end subroutine event_stream_array_final
@ %def event_stream_array_final
@ Initialization. We use a generic [[sample]] name, open event I/O
objects for all provided stream types (using the [[dispatch_eio]]
routine), and initialize for the given list of process pointers. If
there is an [[input]] argument, this channel is initialized as an input
channel and appended to the array.
The [[input_data]] or, if not present, [[data]] may be modified. This
happens if we open a stream for reading and get new information there.
<<Event streams: event stream array: TBP>>=
procedure :: init => event_stream_array_init
<<Event streams: procedures>>=
subroutine event_stream_array_init &
(es_array, sample, stream_fmt, global, &
data, input, input_sample, input_data, allow_switch, &
checkpoint, callback, &
error)
class(event_stream_array_t), intent(out) :: es_array
type(string_t), intent(in) :: sample
type(string_t), dimension(:), intent(in) :: stream_fmt
type(rt_data_t), intent(in) :: global
type(event_sample_data_t), intent(inout), optional :: data
type(string_t), intent(in), optional :: input
type(string_t), intent(in), optional :: input_sample
type(event_sample_data_t), intent(inout), optional :: input_data
logical, intent(in), optional :: allow_switch
integer, intent(in), optional :: checkpoint
integer, intent(in), optional :: callback
logical, intent(out), optional :: error
type(string_t) :: sample_in
integer :: n, i, n_output, i_input, i_checkpoint, i_callback
logical :: success, switch
if (present (input_sample)) then
sample_in = input_sample
else
sample_in = sample
end if
if (present (allow_switch)) then
switch = allow_switch
else
switch = .true.
end if
if (present (error)) then
error = .false.
end if
n = size (stream_fmt)
n_output = n
if (present (input)) then
n = n + 1
i_input = n
else
i_input = 0
end if
if (present (checkpoint)) then
n = n + 1
i_checkpoint = n
else
i_checkpoint = 0
end if
if (present (callback)) then
n = n + 1
i_callback = n
else
i_callback = 0
end if
allocate (es_array%entry (n))
if (i_checkpoint > 0) then
call dispatch_eio &
(es_array%entry(i_checkpoint)%eio, var_str ("checkpoint"), &
global%var_list, global%fallback_model, &
global%event_callback)
call es_array%entry(i_checkpoint)%eio%init_out (sample, data)
end if
if (i_callback > 0) then
call dispatch_eio &
(es_array%entry(i_callback)%eio, var_str ("callback"), &
global%var_list, global%fallback_model, &
global%event_callback)
call es_array%entry(i_callback)%eio%init_out (sample, data)
end if
if (i_input > 0) then
call dispatch_eio (es_array%entry(i_input)%eio, input, &
global%var_list, global%fallback_model, &
global%event_callback)
if (present (input_data)) then
call es_array%entry(i_input)%eio%init_in &
(sample_in, input_data, success)
else
call es_array%entry(i_input)%eio%init_in &
(sample_in, data, success)
end if
if (success) then
es_array%i_in = i_input
else if (present (input_sample)) then
if (present (error)) then
error = .true.
else
call msg_fatal ("Events: &
&parameter mismatch in input, aborting")
end if
else
call msg_message ("Events: &
&parameter mismatch, discarding old event set")
call es_array%entry(i_input)%eio%final ()
if (switch) then
call msg_message ("Events: generating new events")
call es_array%entry(i_input)%eio%init_out (sample, data)
end if
end if
end if
do i = 1, n_output
call dispatch_eio (es_array%entry(i)%eio, stream_fmt(i), &
global%var_list, global%fallback_model, &
global%event_callback)
call es_array%entry(i)%eio%init_out (sample, data)
end do
end subroutine event_stream_array_init
@ %def event_stream_array_init
@ Switch the (only) input channel to an output channel, so further
events are appended to the respective stream.
<<Event streams: event stream array: TBP>>=
procedure :: switch_inout => event_stream_array_switch_inout
<<Event streams: procedures>>=
subroutine event_stream_array_switch_inout (es_array)
class(event_stream_array_t), intent(inout) :: es_array
integer :: n
if (es_array%has_input ()) then
n = es_array%i_in
call es_array%entry(n)%eio%switch_inout ()
es_array%i_in = 0
else
call msg_bug ("Reading events: switch_inout: no input stream selected")
end if
end subroutine event_stream_array_switch_inout
@ %def event_stream_array_switch_inout
@ Output an event (with given process number) to all output streams.
If there is no output stream, do nothing.
<<Event streams: event stream array: TBP>>=
procedure :: output => event_stream_array_output
<<Event streams: procedures>>=
subroutine event_stream_array_output &
(es_array, event, i_prc, event_index, passed, pacify, event_handle)
class(event_stream_array_t), intent(inout) :: es_array
type(event_t), intent(in), target :: event
integer, intent(in) :: i_prc, event_index
logical, intent(in), optional :: passed, pacify
class(event_handle_t), intent(inout), optional :: event_handle
logical :: increased
integer :: i
do i = 1, size (es_array%entry)
if (i /= es_array%i_in) then
associate (eio => es_array%entry(i)%eio)
if (eio%split) then
if (eio%split_n_evt > 0 .and. event_index > 1) then
if (mod (event_index, eio%split_n_evt) == 1) then
call eio%split_out ()
end if
else if (eio%split_n_kbytes > 0) then
call eio%update_split_count (increased)
if (increased) call eio%split_out ()
end if
end if
call eio%output (event, i_prc, reading = es_array%i_in /= 0, &
passed = passed, &
pacify = pacify, &
event_handle = event_handle)
end associate
end if
end do
end subroutine event_stream_array_output
@ %def event_stream_array_output
@ Input the [[i_prc]] index which selects the process for the current
event. This is separated from reading the event, because it
determines which event record to read. [[iostat]] may indicate an
error or an EOF condition, as usual.
<<Event streams: event stream array: TBP>>=
procedure :: input_i_prc => event_stream_array_input_i_prc
<<Event streams: procedures>>=
subroutine event_stream_array_input_i_prc (es_array, i_prc, iostat)
class(event_stream_array_t), intent(inout) :: es_array
integer, intent(out) :: i_prc
integer, intent(out) :: iostat
integer :: n
if (es_array%has_input ()) then
n = es_array%i_in
call es_array%entry(n)%eio%input_i_prc (i_prc, iostat)
else
call msg_fatal ("Reading events: no input stream selected")
end if
end subroutine event_stream_array_input_i_prc
@ %def event_stream_array_input_i_prc
@ Input an event from the selected input stream. [[iostat]] may indicate an
error or an EOF condition, as usual.
<<Event streams: event stream array: TBP>>=
procedure :: input_event => event_stream_array_input_event
<<Event streams: procedures>>=
subroutine event_stream_array_input_event &
(es_array, event, iostat, event_handle)
class(event_stream_array_t), intent(inout) :: es_array
type(event_t), intent(inout), target :: event
integer, intent(out) :: iostat
class(event_handle_t), intent(inout), optional :: event_handle
integer :: n
if (es_array%has_input ()) then
n = es_array%i_in
call es_array%entry(n)%eio%input_event (event, iostat, event_handle)
else
call msg_fatal ("Reading events: no input stream selected")
end if
end subroutine event_stream_array_input_event
@ %def event_stream_array_input_event
@ Skip an entry of eio\_t. Used to synchronize the event read-in for
NLO events.
<<Event streams: event stream array: TBP>>=
procedure :: skip_eio_entry => event_stream_array_skip_eio_entry
<<Event streams: procedures>>=
subroutine event_stream_array_skip_eio_entry (es_array, iostat)
class(event_stream_array_t), intent(inout) :: es_array
integer, intent(out) :: iostat
integer :: n
if (es_array%has_input ()) then
n = es_array%i_in
call es_array%entry(n)%eio%skip (iostat)
else
call msg_fatal ("Reading events: no input stream selected")
end if
end subroutine event_stream_array_skip_eio_entry
@ %def event_stream_array_skip_eio_entry
@ Return true if there is an input channel among the event streams.
<<Event streams: event stream array: TBP>>=
procedure :: has_input => event_stream_array_has_input
<<Event streams: procedures>>=
function event_stream_array_has_input (es_array) result (flag)
class(event_stream_array_t), intent(in) :: es_array
logical :: flag
flag = es_array%i_in /= 0
end function event_stream_array_has_input
@ %def event_stream_array_has_input
@
\subsection{Unit Tests}
Test module, followed by the stand-alone unit-test procedures.
<<[[event_streams_ut.f90]]>>=
<<File header>>
module event_streams_ut
use unit_tests
use event_streams_uti
<<Standard module head>>
<<Event streams: public test>>
contains
<<Event streams: test driver>>
end module event_streams_ut
@
<<[[event_streams_uti.f90]]>>=
<<File header>>
module event_streams_uti
<<Use kinds>>
<<Use strings>>
use model_data
use eio_data
use process, only: process_t
use instances, only: process_instance_t
use models
use rt_data
use events
use event_streams
<<Standard module head>>
<<Event streams: test declarations>>
contains
<<Event streams: tests>>
end module event_streams_uti
@ %def event_streams_uti
@ API: driver for the unit tests below.
<<Event streams: public test>>=
public :: event_streams_test
<<Event streams: test driver>>=
subroutine event_streams_test (u, results)
integer, intent(in) :: u
type(test_results_t), intent(inout) :: results
<<Event streams: execute tests>>
end subroutine event_streams_test
@ %def event_streams_test
@
\subsubsection{Empty event stream}
This should set up an empty event output stream array, including
initialization, output, and finalization (which are all no-ops).
<<Event streams: execute tests>>=
call test (event_streams_1, "event_streams_1", &
"empty event stream array", &
u, results)
<<Event streams: test declarations>>=
public :: event_streams_1
<<Event streams: tests>>=
subroutine event_streams_1 (u)
integer, intent(in) :: u
type(event_stream_array_t) :: es_array
type(rt_data_t) :: global
type(event_t) :: event
type(string_t) :: sample
type(string_t), dimension(0) :: empty_string_array
write (u, "(A)") "* Test output: event_streams_1"
write (u, "(A)") "* Purpose: handle empty event stream array"
write (u, "(A)")
sample = "event_streams_1"
call es_array%init (sample, empty_string_array, global)
call es_array%output (event, 42, 1)
call es_array%write (u)
call es_array%final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: event_streams_1"
end subroutine event_streams_1
@ %def event_streams_1
@
\subsubsection{Nontrivial event stream}
Here we generate a trivial event and choose [[raw]] output as an entry in
the stream array.
<<Event streams: execute tests>>=
call test (event_streams_2, "event_streams_2", &
"nontrivial event stream array", &
u, results)
<<Event streams: test declarations>>=
public :: event_streams_2
<<Event streams: tests>>=
subroutine event_streams_2 (u)
use processes_ut, only: prepare_test_process
integer, intent(in) :: u
type(event_stream_array_t) :: es_array
type(rt_data_t) :: global
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
type(string_t) :: sample
type(string_t), dimension(0) :: empty_string_array
integer :: i_prc, iostat
write (u, "(A)") "* Test output: event_streams_2"
write (u, "(A)") "* Purpose: handle empty event stream array"
write (u, "(A)")
call syntax_model_file_init ()
call global%global_init ()
call global%init_fallback_model &
(var_str ("SM_hadrons"), var_str ("SM_hadrons.mdl"))
call model%init_test ()
write (u, "(A)") "* Generate test process event"
write (u, "(A)")
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 ())
call event%generate (1, [0.4_default, 0.4_default])
call event%set_index (42)
call event%evaluate_expressions ()
call event%write (u)
write (u, "(A)")
write (u, "(A)") "* Allocate raw eio stream and write event to file"
write (u, "(A)")
sample = "event_streams_2"
call es_array%init (sample, [var_str ("raw")], global)
call es_array%output (event, 1, 1)
call es_array%write (u)
call es_array%final ()
write (u, "(A)")
write (u, "(A)") "* Reallocate raw eio stream for reading"
write (u, "(A)")
sample = "foo"
call es_array%init (sample, empty_string_array, global, &
input = var_str ("raw"), input_sample = var_str ("event_streams_2"))
call es_array%write (u)
write (u, "(A)")
write (u, "(A)") "* Reread event"
write (u, "(A)")
call es_array%input_i_prc (i_prc, iostat)
write (u, "(1x,A,I0)") "i_prc = ", i_prc
write (u, "(A)")
call es_array%input_event (event, iostat)
call es_array%final ()
call event%write (u)
call global%final ()
call model%final ()
call syntax_model_file_final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: event_streams_2"
end subroutine event_streams_2
@ %def event_streams_2
@
\subsubsection{Switch in/out}
Here we generate an event file and test switching from writing to
reading when the file is exhausted.
<<Event streams: execute tests>>=
call test (event_streams_3, "event_streams_3", &
"switch input/output", &
u, results)
<<Event streams: test declarations>>=
public :: event_streams_3
<<Event streams: tests>>=
subroutine event_streams_3 (u)
use processes_ut, only: prepare_test_process
integer, intent(in) :: u
type(event_stream_array_t) :: es_array
type(rt_data_t) :: global
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
type(string_t) :: sample
type(string_t), dimension(0) :: empty_string_array
integer :: i_prc, iostat
write (u, "(A)") "* Test output: event_streams_3"
write (u, "(A)") "* Purpose: handle in/out switching"
write (u, "(A)")
call syntax_model_file_init ()
call global%global_init ()
call global%init_fallback_model &
(var_str ("SM_hadrons"), var_str ("SM_hadrons.mdl"))
call model%init_test ()
write (u, "(A)") "* Generate test process event"
write (u, "(A)")
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 ())
call event%generate (1, [0.4_default, 0.4_default])
call event%increment_index ()
call event%evaluate_expressions ()
write (u, "(A)") "* Allocate raw eio stream and write event to file"
write (u, "(A)")
sample = "event_streams_3"
call es_array%init (sample, [var_str ("raw")], global)
call es_array%output (event, 1, 1)
call es_array%write (u)
call es_array%final ()
write (u, "(A)")
write (u, "(A)") "* Reallocate raw eio stream for reading"
write (u, "(A)")
call es_array%init (sample, empty_string_array, global, &
input = var_str ("raw"))
call es_array%write (u)
write (u, "(A)")
write (u, "(A)") "* Reread event"
write (u, "(A)")
call es_array%input_i_prc (i_prc, iostat)
call es_array%input_event (event, iostat)
write (u, "(A)") "* Attempt to read another event (fail), then generate"
write (u, "(A)")
call es_array%input_i_prc (i_prc, iostat)
if (iostat < 0) then
call es_array%switch_inout ()
call event%generate (1, [0.3_default, 0.3_default])
call event%increment_index ()
call event%evaluate_expressions ()
call es_array%output (event, 1, 2)
end if
call es_array%write (u)
call es_array%final ()
write (u, "(A)")
call event%write (u)
write (u, "(A)")
write (u, "(A)") "* Reallocate raw eio stream for reading"
write (u, "(A)")
call es_array%init (sample, empty_string_array, global, &
input = var_str ("raw"))
call es_array%write (u)
write (u, "(A)")
write (u, "(A)") "* Reread two events and display 2nd event"
write (u, "(A)")
call es_array%input_i_prc (i_prc, iostat)
call es_array%input_event (event, iostat)
call es_array%input_i_prc (i_prc, iostat)
call es_array%input_event (event, iostat)
call es_array%final ()
call event%write (u)
call global%final ()
call model%final ()
call syntax_model_file_final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: event_streams_3"
end subroutine event_streams_3
@ %def event_streams_3
@
\subsubsection{Checksum}
Here we generate an event file and repeat twice, once with identical
parameters and once with modified parameters.
<<Event streams: execute tests>>=
call test (event_streams_4, "event_streams_4", &
"check MD5 sum", &
u, results)
<<Event streams: test declarations>>=
public :: event_streams_4
<<Event streams: tests>>=
subroutine event_streams_4 (u)
integer, intent(in) :: u
type(event_stream_array_t) :: es_array
type(rt_data_t) :: global
type(process_t), allocatable, target :: process
type(string_t) :: sample
type(string_t), dimension(0) :: empty_string_array
type(event_sample_data_t) :: data
write (u, "(A)") "* Test output: event_streams_4"
write (u, "(A)") "* Purpose: handle in/out switching"
write (u, "(A)")
write (u, "(A)") "* Generate test process event"
write (u, "(A)")
call syntax_model_file_init ()
call global%global_init ()
call global%init_fallback_model &
(var_str ("SM_hadrons"), var_str ("SM_hadrons.mdl"))
call global%set_log (var_str ("?check_event_file"), &
.true., is_known = .true.)
allocate (process)
write (u, "(A)") "* Allocate raw eio stream for writing"
write (u, "(A)")
sample = "event_streams_4"
data%md5sum_cfg = "1234567890abcdef1234567890abcdef"
call es_array%init (sample, [var_str ("raw")], global, data)
call es_array%write (u)
call es_array%final ()
write (u, "(A)")
write (u, "(A)") "* Reallocate raw eio stream for reading"
write (u, "(A)")
call es_array%init (sample, empty_string_array, global, &
data, input = var_str ("raw"))
call es_array%write (u)
call es_array%final ()
write (u, "(A)")
write (u, "(A)") "* Reallocate modified raw eio stream for reading (fail)"
write (u, "(A)")
data%md5sum_cfg = "1234567890______1234567890______"
call es_array%init (sample, empty_string_array, global, &
data, input = var_str ("raw"))
call es_array%write (u)
call es_array%final ()
write (u, "(A)")
write (u, "(A)") "* Repeat ignoring checksum"
write (u, "(A)")
call global%set_log (var_str ("?check_event_file"), &
.false., is_known = .true.)
call es_array%init (sample, empty_string_array, global, &
data, input = var_str ("raw"))
call es_array%write (u)
call es_array%final ()
call global%final ()
call syntax_model_file_final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: event_streams_4"
end subroutine event_streams_4
@ %def event_streams_4
@
\clearpage
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{Restricted Subprocesses}
This module provides an automatic means to construct restricted subprocesses
of a current process object. A restricted subprocess has the same initial and
final state as the current process, but a restricted set of Feynman graphs.
The actual application extracts the set of resonance histories that apply to
the process and uses this to construct subprocesses that are restricted to one
of those histories, respectively. The resonance histories are derived from
the phase-space setup. This implies that the method is tied to the OMega
matrix element generator and to the wood phase space method.
The processes are collected in a new process library that is generated
on-the-fly.
The [[resonant_subprocess_t]] object is intended as a component of the event
record, which manages all operations regarding resonance handling.
The run-time calculations are delegated to an event transform
([[evt_resonance_t]]), as a part of the event transform chain. The transform
selects one (or none) of the resonance histories, given the momentum
configuration, computes matrix elements and inserts resonances into the
particle set.
<<[[restricted_subprocesses.f90]]>>=
<<File header>>
module restricted_subprocesses
<<Use kinds>>
<<Use strings>>
use diagnostics, only: msg_message, msg_fatal, msg_bug
use diagnostics, only: signal_is_pending
use io_units, only: given_output_unit
use format_defs, only: FMT_14, FMT_19
use string_utils, only: str
use lorentz, only: vector4_t
use particle_specifiers, only: prt_spec_t
use particles, only: particle_set_t
use resonances, only: resonance_history_t, resonance_history_set_t
use variables, only: var_list_t
use models, only: model_t
use process_libraries, only: process_component_def_t
use process_libraries, only: process_library_t
use process_libraries, only: STAT_ACTIVE
use prclib_stacks, only: prclib_entry_t
use event_transforms, only: evt_t
use resonance_insertion, only: evt_resonance_t
use rt_data, only: rt_data_t
use compilations, only: compile_library
use process_configurations, only: process_configuration_t
use process, only: process_t, process_ptr_t
use instances, only: process_instance_t, process_instance_ptr_t
use integrations, only: integrate_process
<<Use mpi f08>>
<<Standard module head>>
<<Restricted subprocesses: public>>
<<Restricted subprocesses: types>>
<<Restricted subprocesses: interfaces>>
contains
<<Restricted subprocesses: procedures>>
end module restricted_subprocesses
@ %def restricted_subprocesses
@
\subsection{Process configuration}
We extend the [[process_configuration_t]] by another method for initialization
that takes into account a resonance history.
<<Restricted subprocesses: public>>=
public :: restricted_process_configuration_t
<<Restricted subprocesses: types>>=
type, extends (process_configuration_t) :: restricted_process_configuration_t
private
contains
<<Restricted subprocesses: restricted process configuration: TBP>>
end type restricted_process_configuration_t
@ %def restricted_process_configuration_t
@
Resonance history as an argument. We use it to override the [[restrictions]]
setting in a local variable list. Since we can construct the restricted
process only by using OMega, we enforce it as the ME method. Other settings
are taken from the variable list. The model will most likely be set, but we
insert a safeguard just in case.
Also, the resonant subprocess should not itself spawn resonant
subprocesses, so we unset [[?resonance_history]].
We have to create a local copy of the model here, via pointer
allocation. The reason is that the model as stored (via pointer) in
the base type will be finalized and deallocated.
The current implementation will generate a LO process, the optional
[[nlo_process]] is unset. (It is not obvious
whether the construction makes sense beyond LO.)
<<Restricted subprocesses: restricted process configuration: TBP>>=
procedure :: init_resonant_process
<<Restricted subprocesses: procedures>>=
subroutine init_resonant_process &
(prc_config, prc_name, prt_in, prt_out, res_history, model, var_list)
class(restricted_process_configuration_t), intent(out) :: prc_config
type(string_t), intent(in) :: prc_name
type(prt_spec_t), dimension(:), intent(in) :: prt_in
type(prt_spec_t), dimension(:), intent(in) :: prt_out
type(resonance_history_t), intent(in) :: res_history
type(model_t), intent(in), target :: model
type(var_list_t), intent(in), target :: var_list
type(model_t), pointer :: local_model
type(var_list_t) :: local_var_list
allocate (local_model)
call local_model%init_instance (model)
call local_var_list%link (var_list)
call local_var_list%append_string (var_str ("$model_name"), &
sval = local_model%get_name (), &
intrinsic=.true.)
call local_var_list%append_string (var_str ("$method"), &
sval = var_str ("omega"), &
intrinsic=.true.)
call local_var_list%append_string (var_str ("$restrictions"), &
sval = res_history%as_omega_string (size (prt_in)), &
intrinsic = .true.)
call local_var_list%append_log (var_str ("?resonance_history"), &
lval = .false., &
intrinsic = .true.)
call prc_config%init (prc_name, size (prt_in), 1, &
local_model, local_var_list)
call prc_config%setup_component (1, &
prt_in, prt_out, &
local_model, local_var_list)
end subroutine init_resonant_process
@ %def init_resonant_process
@
\subsection{Resonant-subprocess set manager}
This data type enables generation of a library of resonant subprocesses for a
given master process, and it allows for convenient access. The matrix
elements from the subprocesses can be used as channel weights to activate a
selector, which then returns a preferred channel via some random number
generator.
<<Restricted subprocesses: public>>=
public :: resonant_subprocess_set_t
<<Restricted subprocesses: types>>=
type :: resonant_subprocess_set_t
private
integer, dimension(:), allocatable :: n_history
type(resonance_history_set_t), dimension(:), allocatable :: res_history_set
logical :: lib_active = .false.
type(string_t) :: libname
type(string_t), dimension(:), allocatable :: proc_id
type(process_ptr_t), dimension(:), allocatable :: subprocess
type(process_instance_ptr_t), dimension(:), allocatable :: instance
logical :: filled = .false.
type(evt_resonance_t), pointer :: evt => null ()
contains
<<Restricted subprocesses: resonant subprocess set: TBP>>
end type resonant_subprocess_set_t
@ %def resonant_subprocess_set_t
@ Output
<<Restricted subprocesses: resonant subprocess set: TBP>>=
procedure :: write => resonant_subprocess_set_write
<<Restricted subprocesses: procedures>>=
subroutine resonant_subprocess_set_write (prc_set, unit, testflag)
class(resonant_subprocess_set_t), intent(in) :: prc_set
integer, intent(in), optional :: unit
logical, intent(in), optional :: testflag
logical :: truncate
integer :: u, i
u = given_output_unit (unit)
truncate = .false.; if (present (testflag)) truncate = testflag
write (u, "(1x,A)") "Resonant subprocess set:"
if (allocated (prc_set%n_history)) then
if (any (prc_set%n_history > 0)) then
do i = 1, size (prc_set%n_history)
if (prc_set%n_history(i) > 0) then
write (u, "(1x,A,I0)") "Component #", i
call prc_set%res_history_set(i)%write (u, indent=1)
end if
end do
if (prc_set%lib_active) then
write (u, "(3x,A,A,A)") "Process library = '", &
char (prc_set%libname), "'"
else
write (u, "(3x,A)") "Process library: [inactive]"
end if
if (associated (prc_set%evt)) then
if (truncate) then
write (u, "(3x,A,1x," // FMT_14 // ")") &
"Process sqme =", prc_set%get_master_sqme ()
else
write (u, "(3x,A,1x," // FMT_19 // ")") &
"Process sqme =", prc_set%get_master_sqme ()
end if
end if
if (associated (prc_set%evt)) then
write (u, "(3x,A)") "Event transform: associated"
write (u, "(2x)", advance="no")
call prc_set%evt%write_selector (u, testflag)
else
write (u, "(3x,A)") "Event transform: not associated"
end if
else
write (u, "(2x,A)") "[empty]"
end if
else
write (u, "(3x,A)") "[not allocated]"
end if
end subroutine resonant_subprocess_set_write
@ %def resonant_subprocess_set_write
@
\subsection{Resonance history set}
Initialize subprocess set with an array of pre-created resonance
history sets.
Safeguard: if there are no resonances in the input, initialize the local set
as empty, but complete.
<<Restricted subprocesses: resonant subprocess set: TBP>>=
procedure :: init => resonant_subprocess_set_init
procedure :: fill_resonances => resonant_subprocess_set_fill_resonances
<<Restricted subprocesses: procedures>>=
subroutine resonant_subprocess_set_init (prc_set, n_component)
class(resonant_subprocess_set_t), intent(out) :: prc_set
integer, intent(in) :: n_component
allocate (prc_set%res_history_set (n_component))
allocate (prc_set%n_history (n_component), source = 0)
end subroutine resonant_subprocess_set_init
subroutine resonant_subprocess_set_fill_resonances (prc_set, &
res_history_set, i_component)
class(resonant_subprocess_set_t), intent(inout) :: prc_set
type(resonance_history_set_t), intent(in) :: res_history_set
integer, intent(in) :: i_component
prc_set%n_history(i_component) = res_history_set%get_n_history ()
if (prc_set%n_history(i_component) > 0) then
prc_set%res_history_set(i_component) = res_history_set
else
call prc_set%res_history_set(i_component)%init (initial_size = 0)
call prc_set%res_history_set(i_component)%freeze ()
end if
end subroutine resonant_subprocess_set_fill_resonances
@ %def resonant_subprocess_set_init
@ %def resonant_subprocess_set_fill_resonances
@ Return the resonance history set.
<<Restricted subprocesses: resonant subprocess set: TBP>>=
procedure :: get_resonance_history_set &
=> resonant_subprocess_set_get_resonance_history_set
<<Restricted subprocesses: procedures>>=
function resonant_subprocess_set_get_resonance_history_set (prc_set) &
result (res_history_set)
class(resonant_subprocess_set_t), intent(in) :: prc_set
type(resonance_history_set_t), dimension(:), allocatable :: res_history_set
res_history_set = prc_set%res_history_set
end function resonant_subprocess_set_get_resonance_history_set
@ %def resonant_subprocess_set_get_resonance_history_set
@
\subsection{Library for the resonance history set}
The recommended library name: append [[_R]] to the process name.
<<Restricted subprocesses: public>>=
public :: get_libname_res
<<Restricted subprocesses: procedures>>=
elemental function get_libname_res (proc_id) result (libname)
type(string_t), intent(in) :: proc_id
type(string_t) :: libname
libname = proc_id // "_R"
end function get_libname_res
@ %def get_libname_res
@ Here we scan the global process library whether any
processes require resonant subprocesses to be constructed. If yes,
create process objects with phase space and construct the process
libraries as usual. Then append the library names to the array.
The temporary integration objects should carry the [[phs_only]]
flag. We set this in the local environment.
Once a process object with resonance histories (derived from phase
space) has been created, we extract the resonance histories and use
them, together with the process definition, to create the new library.
Finally, compile the library.
<<Restricted subprocesses: public>>=
public :: spawn_resonant_subprocess_libraries
<<Restricted subprocesses: procedures>>=
subroutine spawn_resonant_subprocess_libraries &
(libname, local, global, libname_res)
type(string_t), intent(in) :: libname
type(rt_data_t), intent(inout), target :: local
type(rt_data_t), intent(inout), target :: global
type(string_t), dimension(:), allocatable, intent(inout) :: libname_res
type(process_library_t), pointer :: lib
type(string_t), dimension(:), allocatable :: process_id_res
type(process_t), pointer :: process
type(resonance_history_set_t) :: res_history_set
type(process_component_def_t), pointer :: process_component_def
logical :: phs_only_saved, exist
integer :: i_proc, i_component
lib => global%prclib_stack%get_library_ptr (libname)
call lib%get_process_id_req_resonant (process_id_res)
if (size (process_id_res) > 0) then
call msg_message ("Creating resonant-subprocess libraries &
&for library '" // char (libname) // "'")
libname_res = get_libname_res (process_id_res)
phs_only_saved = local%var_list%get_lval (var_str ("?phs_only"))
call local%var_list%set_log &
(var_str ("?phs_only"), .true., is_known=.true.)
do i_proc = 1, size (process_id_res)
associate (proc_id => process_id_res (i_proc))
call msg_message ("Process '" // char (proc_id) // "': &
&constructing phase space for resonance structure")
call integrate_process (proc_id, local, global)
process => global%process_stack%get_process_ptr (proc_id)
call create_library (libname_res(i_proc), global, exist)
if (.not. exist) then
do i_component = 1, process%get_n_components ()
call process%extract_resonance_history_set &
(res_history_set, i_component = i_component)
process_component_def &
=> process%get_component_def_ptr (i_component)
call add_to_library (libname_res(i_proc), &
res_history_set, &
process_component_def%get_prt_spec_in (), &
process_component_def%get_prt_spec_out (), &
global)
end do
call msg_message ("Process library '" &
// char (libname_res(i_proc)) &
// "': created")
end if
call global%update_prclib (lib)
end associate
end do
call local%var_list%set_log &
(var_str ("?phs_only"), phs_only_saved, is_known=.true.)
end if
end subroutine spawn_resonant_subprocess_libraries
@ %def spawn_resonant_subprocess_libraries
@ This is another version of the library constructor, bound to a
restricted-subprocess set object. Create the appropriate
process library, add processes, and close the library.
<<Restricted subprocesses: resonant subprocess set: TBP>>=
procedure :: create_library => resonant_subprocess_set_create_library
procedure :: add_to_library => resonant_subprocess_set_add_to_library
procedure :: freeze_library => resonant_subprocess_set_freeze_library
<<Restricted subprocesses: procedures>>=
subroutine resonant_subprocess_set_create_library (prc_set, &
libname, global, exist)
class(resonant_subprocess_set_t), intent(inout) :: prc_set
type(string_t), intent(in) :: libname
type(rt_data_t), intent(inout), target :: global
logical, intent(out) :: exist
prc_set%libname = libname
call create_library (prc_set%libname, global, exist)
end subroutine resonant_subprocess_set_create_library
subroutine resonant_subprocess_set_add_to_library (prc_set, &
i_component, prt_in, prt_out, global)
class(resonant_subprocess_set_t), intent(inout) :: prc_set
integer, intent(in) :: i_component
type(prt_spec_t), dimension(:), intent(in) :: prt_in
type(prt_spec_t), dimension(:), intent(in) :: prt_out
type(rt_data_t), intent(inout), target :: global
call add_to_library (prc_set%libname, &
prc_set%res_history_set(i_component), &
prt_in, prt_out, global)
end subroutine resonant_subprocess_set_add_to_library
subroutine resonant_subprocess_set_freeze_library (prc_set, global)
class(resonant_subprocess_set_t), intent(inout) :: prc_set
type(rt_data_t), intent(inout), target :: global
type(prclib_entry_t), pointer :: lib_entry
type(process_library_t), pointer :: lib
lib => global%prclib_stack%get_library_ptr (prc_set%libname)
call lib%get_process_id_list (prc_set%proc_id)
prc_set%lib_active = .true.
end subroutine resonant_subprocess_set_freeze_library
@ %def resonant_subprocess_set_create_library
@ %def resonant_subprocess_set_add_to_library
@ %def resonant_subprocess_set_freeze_library
@ The common parts of the procedures above: (i) create a new process
library or recover it, (ii) for each history, create a
process configuration and record it.
<<Restricted subprocesses: procedures>>=
subroutine create_library (libname, global, exist)
type(string_t), intent(in) :: libname
type(rt_data_t), intent(inout), target :: global
logical, intent(out) :: exist
type(prclib_entry_t), pointer :: lib_entry
type(process_library_t), pointer :: lib
type(resonance_history_t) :: res_history
type(string_t), dimension(:), allocatable :: proc_id
type(restricted_process_configuration_t) :: prc_config
integer :: i
lib => global%prclib_stack%get_library_ptr (libname)
exist = associated (lib)
if (.not. exist) then
call msg_message ("Creating library for resonant subprocesses '" &
// char (libname) // "'")
allocate (lib_entry)
call lib_entry%init (libname)
lib => lib_entry%process_library_t
call global%add_prclib (lib_entry)
else
call msg_message ("Using library for resonant subprocesses '" &
// char (libname) // "'")
call global%update_prclib (lib)
end if
end subroutine create_library
subroutine add_to_library (libname, res_history_set, prt_in, prt_out, global)
type(string_t), intent(in) :: libname
type(resonance_history_set_t), intent(in) :: res_history_set
type(prt_spec_t), dimension(:), intent(in) :: prt_in
type(prt_spec_t), dimension(:), intent(in) :: prt_out
type(rt_data_t), intent(inout), target :: global
type(prclib_entry_t), pointer :: lib_entry
type(process_library_t), pointer :: lib
type(resonance_history_t) :: res_history
type(string_t), dimension(:), allocatable :: proc_id
type(restricted_process_configuration_t) :: prc_config
integer :: n0, i
lib => global%prclib_stack%get_library_ptr (libname)
if (associated (lib)) then
n0 = lib%get_n_processes ()
allocate (proc_id (res_history_set%get_n_history ()))
do i = 1, size (proc_id)
proc_id(i) = libname // str (n0 + i)
res_history = res_history_set%get_history(i)
call prc_config%init_resonant_process (proc_id(i), &
prt_in, prt_out, &
res_history, &
global%model, global%var_list)
call msg_message ("Resonant subprocess #" &
// char (str(n0+i)) // ": " &
// char (res_history%as_omega_string (size (prt_in))))
call prc_config%record (global)
if (signal_is_pending ()) return
end do
else
call msg_bug ("Adding subprocesses: library '" &
// char (libname) // "' not found")
end if
end subroutine add_to_library
@ %def create_library
@ %def add_to_library
@ Compile the generated library, required settings taken from the
[[global]] data set.
<<Restricted subprocesses: resonant subprocess set: TBP>>=
procedure :: compile_library => resonant_subprocess_set_compile_library
<<Restricted subprocesses: procedures>>=
subroutine resonant_subprocess_set_compile_library (prc_set, global)
class(resonant_subprocess_set_t), intent(in) :: prc_set
type(rt_data_t), intent(inout), target :: global
type(process_library_t), pointer :: lib
lib => global%prclib_stack%get_library_ptr (prc_set%libname)
if (lib%get_status () < STAT_ACTIVE) then
call compile_library (prc_set%libname, global)
end if
end subroutine resonant_subprocess_set_compile_library
@ %def resonant_subprocess_set_compile_library
@ Check if the library has been created / the process has been evaluated.
<<Restricted subprocesses: resonant subprocess set: TBP>>=
procedure :: is_active => resonant_subprocess_set_is_active
<<Restricted subprocesses: procedures>>=
function resonant_subprocess_set_is_active (prc_set) result (flag)
class(resonant_subprocess_set_t), intent(in) :: prc_set
logical :: flag
flag = prc_set%lib_active
end function resonant_subprocess_set_is_active
@ %def resonant_subprocess_set_is_active
@ Return number of generated process objects, library, and process IDs.
<<Restricted subprocesses: resonant subprocess set: TBP>>=
procedure :: get_n_process => resonant_subprocess_set_get_n_process
procedure :: get_libname => resonant_subprocess_set_get_libname
procedure :: get_proc_id => resonant_subprocess_set_get_proc_id
<<Restricted subprocesses: procedures>>=
function resonant_subprocess_set_get_n_process (prc_set) result (n)
class(resonant_subprocess_set_t), intent(in) :: prc_set
integer :: n
if (prc_set%lib_active) then
n = size (prc_set%proc_id)
else
n = 0
end if
end function resonant_subprocess_set_get_n_process
function resonant_subprocess_set_get_libname (prc_set) result (libname)
class(resonant_subprocess_set_t), intent(in) :: prc_set
type(string_t) :: libname
if (prc_set%lib_active) then
libname = prc_set%libname
else
libname = ""
end if
end function resonant_subprocess_set_get_libname
function resonant_subprocess_set_get_proc_id (prc_set, i) result (proc_id)
class(resonant_subprocess_set_t), intent(in) :: prc_set
integer, intent(in) :: i
type(string_t) :: proc_id
if (allocated (prc_set%proc_id)) then
proc_id = prc_set%proc_id(i)
else
proc_id = ""
end if
end function resonant_subprocess_set_get_proc_id
@ %def resonant_subprocess_set_get_n_process
@ %def resonant_subprocess_set_get_libname
@ %def resonant_subprocess_set_get_proc_id
@
\subsection{Process objects and instances}
Prepare process objects for all entries in the resonant-subprocesses
library. The process objects are appended to the global process
stack. A local environment can be used where we place temporary
variable settings that affect process-object generation. We
initialize the processes, such that we can evaluate matrix elements,
but we do not need to integrate them.
The internal procedure [[prepare_process]] is an abridged version of
the procedure with this name in the [[simulations]] module.
<<Restricted subprocesses: resonant subprocess set: TBP>>=
procedure :: prepare_process_objects &
=> resonant_subprocess_set_prepare_process_objects
<<Restricted subprocesses: procedures>>=
subroutine resonant_subprocess_set_prepare_process_objects &
(prc_set, local, global)
class(resonant_subprocess_set_t), intent(inout) :: prc_set
type(rt_data_t), intent(inout), target :: local
type(rt_data_t), intent(inout), optional, target :: global
type(rt_data_t), pointer :: current
type(process_library_t), pointer :: lib
type(string_t) :: proc_id, libname_cur, libname_res
integer :: i, n
if (.not. prc_set%is_active ()) return
if (present (global)) then
current => global
else
current => local
end if
libname_cur = current%prclib%get_name ()
libname_res = prc_set%get_libname ()
lib => current%prclib_stack%get_library_ptr (libname_res)
if (associated (lib)) call current%update_prclib (lib)
call local%set_string (var_str ("$phs_method"), &
var_str ("none"), is_known = .true.)
call local%set_string (var_str ("$integration_method"), &
var_str ("none"), is_known = .true.)
n = prc_set%get_n_process ()
allocate (prc_set%subprocess (n))
do i = 1, n
proc_id = prc_set%get_proc_id (i)
call prepare_process (prc_set%subprocess(i)%p, proc_id)
if (signal_is_pending ()) return
end do
lib => current%prclib_stack%get_library_ptr (libname_cur)
if (associated (lib)) call current%update_prclib (lib)
contains
subroutine prepare_process (process, process_id)
type(process_t), pointer, intent(out) :: process
type(string_t), intent(in) :: process_id
call msg_message ("Simulate: initializing resonant subprocess '" &
// char (process_id) // "'")
if (present (global)) then
call integrate_process (process_id, local, global, &
init_only = .true.)
else
call integrate_process (process_id, local, local_stack = .true., &
init_only = .true.)
end if
process => current%process_stack%get_process_ptr (process_id)
if (.not. associated (process)) then
call msg_fatal ("Simulate: resonant subprocess '" &
// char (process_id) // "' could not be initialized: aborting")
end if
end subroutine prepare_process
end subroutine resonant_subprocess_set_prepare_process_objects
@ %def resonant_subprocess_set_prepare_process_objects
@ Workspace for the resonant subprocesses.
<<Restricted subprocesses: resonant subprocess set: TBP>>=
procedure :: prepare_process_instances &
=> resonant_subprocess_set_prepare_process_instances
<<Restricted subprocesses: procedures>>=
subroutine resonant_subprocess_set_prepare_process_instances (prc_set, global)
class(resonant_subprocess_set_t), intent(inout) :: prc_set
type(rt_data_t), intent(in), target :: global
integer :: i, n
if (.not. prc_set%is_active ()) return
n = size (prc_set%subprocess)
allocate (prc_set%instance (n))
do i = 1, n
allocate (prc_set%instance(i)%p)
call prc_set%instance(i)%p%init (prc_set%subprocess(i)%p)
call prc_set%instance(i)%p%setup_event_data (global%model)
end do
end subroutine resonant_subprocess_set_prepare_process_instances
@ %def resonant_subprocess_set_prepare_process_instances
@
\subsection{Event transform connection}
The idea is that the resonance-insertion event transform has been
allocated somewhere (namely, in the standard event-transform chain),
but we maintain a link such that we can inject matrix-element results
event by event. The event transform holds a selector, to choose one
of the resonance histories (or none), and it manages resonance
insertion for the particle set.
The data that the event transform requires can be provided here. The
resonance history set has already been assigned with the [[dispatch]]
initializer. Here, we supply the set of subprocess instances that we
have generated (see above). The master-process instance is set
when we [[connect]] the transform by the standard method.
<<Restricted subprocesses: resonant subprocess set: TBP>>=
procedure :: connect_transform => &
resonant_subprocess_set_connect_transform
<<Restricted subprocesses: procedures>>=
subroutine resonant_subprocess_set_connect_transform (prc_set, evt)
class(resonant_subprocess_set_t), intent(inout) :: prc_set
class(evt_t), intent(in), target :: evt
select type (evt)
type is (evt_resonance_t)
prc_set%evt => evt
call prc_set%evt%set_subprocess_instances (prc_set%instance)
class default
call msg_bug ("Resonant subprocess set: event transform has wrong type")
end select
end subroutine resonant_subprocess_set_connect_transform
@ %def resonant_subprocess_set_connect_transform
@ Set the on-shell limit value in the connected transform.
<<Restricted subprocesses: resonant subprocess set: TBP>>=
procedure :: set_on_shell_limit => resonant_subprocess_set_on_shell_limit
<<Restricted subprocesses: procedures>>=
subroutine resonant_subprocess_set_on_shell_limit (prc_set, on_shell_limit)
class(resonant_subprocess_set_t), intent(inout) :: prc_set
real(default), intent(in) :: on_shell_limit
call prc_set%evt%set_on_shell_limit (on_shell_limit)
end subroutine resonant_subprocess_set_on_shell_limit
@ %def resonant_subprocess_set_on_shell_limit
@ Set the Gaussian turnoff parameter in the connected transform.
<<Restricted subprocesses: resonant subprocess set: TBP>>=
procedure :: set_on_shell_turnoff => resonant_subprocess_set_on_shell_turnoff
<<Restricted subprocesses: procedures>>=
subroutine resonant_subprocess_set_on_shell_turnoff &
(prc_set, on_shell_turnoff)
class(resonant_subprocess_set_t), intent(inout) :: prc_set
real(default), intent(in) :: on_shell_turnoff
call prc_set%evt%set_on_shell_turnoff (on_shell_turnoff)
end subroutine resonant_subprocess_set_on_shell_turnoff
@ %def resonant_subprocess_set_on_shell_turnoff
@ Reweight (suppress) the background contribution probability, for the
kinematics where a resonance history is active.
<<Restricted subprocesses: resonant subprocess set: TBP>>=
procedure :: set_background_factor &
=> resonant_subprocess_set_background_factor
<<Restricted subprocesses: procedures>>=
subroutine resonant_subprocess_set_background_factor &
(prc_set, background_factor)
class(resonant_subprocess_set_t), intent(inout) :: prc_set
real(default), intent(in) :: background_factor
call prc_set%evt%set_background_factor (background_factor)
end subroutine resonant_subprocess_set_background_factor
@ %def resonant_subprocess_set_background_factor
@
\subsection{Wrappers for runtime calculations}
All runtime calculations are delegated to the event transform. The
following procedures are essentially redundant wrappers. We retain
them for a unit test below.
Debugging aid:
<<Restricted subprocesses: resonant subprocess set: TBP>>=
procedure :: dump_instances => resonant_subprocess_set_dump_instances
<<Restricted subprocesses: procedures>>=
subroutine resonant_subprocess_set_dump_instances (prc_set, unit, testflag)
class(resonant_subprocess_set_t), intent(inout) :: prc_set
integer, intent(in), optional :: unit
logical, intent(in), optional :: testflag
integer :: i, n, u
u = given_output_unit (unit)
write (u, "(A)") "*** Process instances of resonant subprocesses"
write (u, *)
n = size (prc_set%subprocess)
do i = 1, n
associate (instance => prc_set%instance(i)%p)
call instance%write (u, testflag)
write (u, *)
write (u, *)
end associate
end do
end subroutine resonant_subprocess_set_dump_instances
@ %def resonant_subprocess_set_dump_instances
@ Inject the current kinematics configuration, reading from the
previous event transform or from the process instance.
<<Restricted subprocesses: resonant subprocess set: TBP>>=
procedure :: fill_momenta => resonant_subprocess_set_fill_momenta
<<Restricted subprocesses: procedures>>=
subroutine resonant_subprocess_set_fill_momenta (prc_set)
class(resonant_subprocess_set_t), intent(inout) :: prc_set
integer :: i, n
call prc_set%evt%fill_momenta ()
end subroutine resonant_subprocess_set_fill_momenta
@ %def resonant_subprocess_set_fill_momenta
@ Determine the indices of the resonance histories that can be
considered on-shell for the current kinematics.
<<Restricted subprocesses: resonant subprocess set: TBP>>=
procedure :: determine_on_shell_histories &
=> resonant_subprocess_set_determine_on_shell_histories
<<Restricted subprocesses: procedures>>=
subroutine resonant_subprocess_set_determine_on_shell_histories &
(prc_set, i_component, index_array)
class(resonant_subprocess_set_t), intent(in) :: prc_set
integer, intent(in) :: i_component
integer, dimension(:), allocatable, intent(out) :: index_array
call prc_set%evt%determine_on_shell_histories (index_array)
end subroutine resonant_subprocess_set_determine_on_shell_histories
@ %def resonant_subprocess_set_determine_on_shell_histories
@ Evaluate selected subprocesses. (In actual operation, the ones that
have been tagged as on-shell.)
<<Restricted subprocesses: resonant subprocess set: TBP>>=
procedure :: evaluate_subprocess &
=> resonant_subprocess_set_evaluate_subprocess
<<Restricted subprocesses: procedures>>=
subroutine resonant_subprocess_set_evaluate_subprocess (prc_set, index_array)
class(resonant_subprocess_set_t), intent(inout) :: prc_set
integer, dimension(:), intent(in) :: index_array
call prc_set%evt%evaluate_subprocess (index_array)
end subroutine resonant_subprocess_set_evaluate_subprocess
@ %def resonant_subprocess_set_evaluate_subprocess
@ Extract the matrix elements of the master process / the resonant
subprocesses. After the previous routine has been executed, they
should be available and stored in the corresponding process instances.
<<Restricted subprocesses: resonant subprocess set: TBP>>=
procedure :: get_master_sqme &
=> resonant_subprocess_set_get_master_sqme
procedure :: get_subprocess_sqme &
=> resonant_subprocess_set_get_subprocess_sqme
<<Restricted subprocesses: procedures>>=
function resonant_subprocess_set_get_master_sqme (prc_set) result (sqme)
class(resonant_subprocess_set_t), intent(in) :: prc_set
real(default) :: sqme
sqme = prc_set%evt%get_master_sqme ()
end function resonant_subprocess_set_get_master_sqme
subroutine resonant_subprocess_set_get_subprocess_sqme (prc_set, sqme)
class(resonant_subprocess_set_t), intent(in) :: prc_set
real(default), dimension(:), intent(inout) :: sqme
integer :: i
call prc_set%evt%get_subprocess_sqme (sqme)
end subroutine resonant_subprocess_set_get_subprocess_sqme
@ %def resonant_subprocess_set_get_master_sqme
@ %def resonant_subprocess_set_get_subprocess_sqme
@ We use the calculations of resonant matrix elements to determine
probabilities for all resonance configurations.
<<Restricted subprocesses: resonant subprocess set: TBP>>=
procedure :: compute_probabilities &
=> resonant_subprocess_set_compute_probabilities
<<Restricted subprocesses: procedures>>=
subroutine resonant_subprocess_set_compute_probabilities (prc_set, prob_array)
class(resonant_subprocess_set_t), intent(inout) :: prc_set
real(default), dimension(:), allocatable, intent(out) :: prob_array
integer, dimension(:), allocatable :: index_array
real(default) :: sqme, sqme_sum, sqme_bg
real(default), dimension(:), allocatable :: sqme_res
integer :: n
n = size (prc_set%subprocess)
allocate (prob_array (0:n), source = 0._default)
call prc_set%evt%compute_probabilities ()
call prc_set%evt%get_selector_weights (prob_array)
end subroutine resonant_subprocess_set_compute_probabilities
@ %def resonant_subprocess_set_compute_probabilities
@
\subsection{Unit tests}
Test module, followed by the stand-alone unit-test procedures.
<<[[restricted_subprocesses_ut.f90]]>>=
<<File header>>
module restricted_subprocesses_ut
use unit_tests
use restricted_subprocesses_uti
<<Standard module head>>
<<Restricted subprocesses: public test>>
contains
<<Restricted subprocesses: test driver>>
end module restricted_subprocesses_ut
@ %def restricted_subprocesses_ut
@
<<[[restricted_subprocesses_uti.f90]]>>=
<<File header>>
module restricted_subprocesses_uti
<<Use kinds>>
<<Use strings>>
use io_units, only: free_unit
use format_defs, only: FMT_10, FMT_12
use lorentz, only: vector4_t, vector3_moving, vector4_moving
use particle_specifiers, only: new_prt_spec
use process_libraries, only: process_library_t
use resonances, only: resonance_info_t
use resonances, only: resonance_history_t
use resonances, only: resonance_history_set_t
use state_matrices, only: FM_IGNORE_HELICITY
use particles, only: particle_set_t
use model_data, only: model_data_t
use models, only: syntax_model_file_init, syntax_model_file_final
use models, only: model_t
use rng_base_ut, only: rng_test_factory_t
use mci_base, only: mci_t
use mci_none, only: mci_none_t
use phs_base, only: phs_config_t
use phs_forests, only: syntax_phs_forest_init, syntax_phs_forest_final
use phs_wood, only: phs_wood_config_t
use process_libraries, only: process_def_entry_t
use process_libraries, only: process_component_def_t
use prclib_stacks, only: prclib_entry_t
use prc_core_def, only: prc_core_def_t
use prc_omega, only: omega_def_t
use process, only: process_t
use instances, only: process_instance_t
use process_stacks, only: process_entry_t
use event_transforms, only: evt_trivial_t
use resonance_insertion, only: evt_resonance_t
use integrations, only: integrate_process
use rt_data, only: rt_data_t
use restricted_subprocesses
<<Standard module head>>
<<Restricted subprocesses: test declarations>>
<<Restricted subprocesses: test auxiliary types>>
<<Restricted subprocesses: public test auxiliary>>
contains
<<Restricted subprocesses: tests>>
<<Restricted subprocesses: test auxiliary>>
end module restricted_subprocesses_uti
@ %def restricted_subprocesses_uti
@ API: driver for the unit tests below.
<<Restricted subprocesses: public test>>=
public :: restricted_subprocesses_test
<<Restricted subprocesses: test driver>>=
subroutine restricted_subprocesses_test (u, results)
integer, intent(in) :: u
type(test_results_t), intent(inout) :: results
<<Restricted subprocesses: execute tests>>
end subroutine restricted_subprocesses_test
@ %def restricted_subprocesses_test
@
\subsubsection{subprocess configuration}
Initialize a [[restricted_subprocess_configuration_t]] object which represents
a given process with a defined resonance history.
<<Restricted subprocesses: execute tests>>=
call test (restricted_subprocesses_1, "restricted_subprocesses_1", &
"single subprocess", &
u, results)
<<Restricted subprocesses: test declarations>>=
public :: restricted_subprocesses_1
<<Restricted subprocesses: tests>>=
subroutine restricted_subprocesses_1 (u)
integer, intent(in) :: u
type(rt_data_t) :: global
type(resonance_info_t) :: res_info
type(resonance_history_t) :: res_history
type(string_t) :: prc_name
type(string_t), dimension(2) :: prt_in
type(string_t), dimension(3) :: prt_out
type(restricted_process_configuration_t) :: prc_config
write (u, "(A)") "* Test output: restricted_subprocesses_1"
write (u, "(A)") "* Purpose: create subprocess list from resonances"
write (u, "(A)")
call syntax_model_file_init ()
call global%global_init ()
call global%set_log (var_str ("?omega_openmp"), &
.false., is_known = .true.)
call global%select_model (var_str ("SM"))
write (u, "(A)") "* Create resonance history"
write (u, "(A)")
call res_info%init (3, -24, global%model, 5)
call res_history%add_resonance (res_info)
call res_history%write (u)
write (u, "(A)")
write (u, "(A)") "* Create process configuration"
write (u, "(A)")
prc_name = "restricted_subprocesses_1_p"
prt_in(1) = "e-"
prt_in(2) = "e+"
prt_out(1) = "d"
prt_out(2) = "u"
prt_out(3) = "W+"
call prc_config%init_resonant_process (prc_name, &
new_prt_spec (prt_in), new_prt_spec (prt_out), &
res_history, global%model, global%var_list)
call prc_config%write (u)
write (u, *)
write (u, "(A)") "* Cleanup"
call global%final ()
call syntax_model_file_final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: restricted_subprocesses_1"
end subroutine restricted_subprocesses_1
@ %def restricted_subprocesses_1
@
\subsubsection{Subprocess library configuration}
Create a process library that represents restricted subprocesses for a given
set of resonance histories
<<Restricted subprocesses: execute tests>>=
call test (restricted_subprocesses_2, "restricted_subprocesses_2", &
"subprocess library", &
u, results)
<<Restricted subprocesses: test declarations>>=
public :: restricted_subprocesses_2
<<Restricted subprocesses: tests>>=
subroutine restricted_subprocesses_2 (u)
integer, intent(in) :: u
type(rt_data_t), target :: global
type(resonance_info_t) :: res_info
type(resonance_history_t), dimension(2) :: res_history
type(resonance_history_set_t) :: res_history_set
type(string_t) :: libname
type(string_t), dimension(2) :: prt_in
type(string_t), dimension(3) :: prt_out
type(resonant_subprocess_set_t) :: prc_set
type(process_library_t), pointer :: lib
logical :: exist
write (u, "(A)") "* Test output: restricted_subprocesses_2"
write (u, "(A)") "* Purpose: create subprocess library from resonances"
write (u, "(A)")
call syntax_model_file_init ()
call global%global_init ()
call global%set_log (var_str ("?omega_openmp"), &
.false., is_known = .true.)
call global%select_model (var_str ("SM"))
write (u, "(A)") "* Create resonance histories"
write (u, "(A)")
call res_info%init (3, -24, global%model, 5)
call res_history(1)%add_resonance (res_info)
call res_history(1)%write (u)
call res_info%init (7, 23, global%model, 5)
call res_history(2)%add_resonance (res_info)
call res_history(2)%write (u)
call res_history_set%init ()
call res_history_set%enter (res_history(1))
call res_history_set%enter (res_history(2))
call res_history_set%freeze ()
write (u, "(A)")
write (u, "(A)") "* Empty restricted subprocess set"
write (u, "(A)")
write (u, "(A,1x,L1)") "active =", prc_set%is_active ()
write (u, "(A)")
call prc_set%write (u, testflag=.true.)
write (u, "(A)")
write (u, "(A)") "* Fill restricted subprocess set"
write (u, "(A)")
libname = "restricted_subprocesses_2_p_R"
prt_in(1) = "e-"
prt_in(2) = "e+"
prt_out(1) = "d"
prt_out(2) = "u"
prt_out(3) = "W+"
call prc_set%init (1)
call prc_set%fill_resonances (res_history_set, 1)
call prc_set%create_library (libname, global, exist)
if (.not. exist) then
call prc_set%add_to_library (1, &
new_prt_spec (prt_in), new_prt_spec (prt_out), &
global)
end if
call prc_set%freeze_library (global)
write (u, "(A,1x,L1)") "active =", prc_set%is_active ()
write (u, "(A)")
call prc_set%write (u, testflag=.true.)
write (u, "(A)")
write (u, "(A)") "* Queries"
write (u, "(A)")
write (u, "(A,1x,I0)") "n_process =", prc_set%get_n_process ()
write (u, "(A)")
write (u, "(A,A,A)") "libname = '", char (prc_set%get_libname ()), "'"
write (u, "(A)")
write (u, "(A,A,A)") "proc_id(1) = '", char (prc_set%get_proc_id (1)), "'"
write (u, "(A,A,A)") "proc_id(2) = '", char (prc_set%get_proc_id (2)), "'"
write (u, "(A)")
write (u, "(A)") "* Process library"
write (u, "(A)")
call prc_set%compile_library (global)
lib => global%prclib_stack%get_library_ptr (libname)
if (associated (lib)) call lib%write (u, libpath=.false.)
write (u, *)
write (u, "(A)") "* Cleanup"
call global%final ()
call syntax_model_file_final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: restricted_subprocesses_2"
end subroutine restricted_subprocesses_2
@ %def restricted_subprocesses_2
@
\subsubsection{Auxiliary: Test processes}
Auxiliary subroutine that constructs the process library for the above test.
This parallels a similar subroutine in [[processes_uti]], but this time we
want an \oMega\ process.
<<Restricted subprocesses: public test auxiliary>>=
public :: prepare_resonance_test_library
<<Restricted subprocesses: test auxiliary>>=
subroutine prepare_resonance_test_library &
(lib, libname, procname, model, global, u)
type(process_library_t), target, intent(out) :: lib
type(string_t), intent(in) :: libname
type(string_t), intent(in) :: procname
class(model_data_t), intent(in), pointer :: model
type(rt_data_t), intent(in), target :: global
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 (omega_def_t :: def)
select type (def)
type is (omega_def_t)
call def%init (model%get_name (), prt_in, prt_out, &
ovm=.false., ufo=.false.)
end select
allocate (entry)
call entry%init (procname, &
model_name = model%get_name (), &
n_in = 2, n_components = 1, &
requires_resonances = .true.)
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 ("omega"), &
variant = def)
call entry%write (u)
call lib%append (entry)
call lib%configure (global%os_data)
call lib%write_makefile (global%os_data, force = .true., verbose = .false.)
call lib%clean (global%os_data, distclean = .false.)
call lib%write_driver (force = .true.)
call lib%load (global%os_data)
end subroutine prepare_resonance_test_library
@ %def prepare_resonance_test_library
@
\subsubsection{Kinematics and resonance selection}
Prepare an actual process with resonant subprocesses. Insert
kinematics and apply the resonance selector in an associated event
transform.
<<Restricted subprocesses: execute tests>>=
call test (restricted_subprocesses_3, "restricted_subprocesses_3", &
"resonance kinematics and probability", &
u, results)
<<Restricted subprocesses: test declarations>>=
public :: restricted_subprocesses_3
<<Restricted subprocesses: tests>>=
subroutine restricted_subprocesses_3 (u)
integer, intent(in) :: u
type(rt_data_t), target :: global
class(model_t), pointer :: model
class(model_data_t), pointer :: model_data
type(string_t) :: libname, libname_res
type(string_t) :: procname
type(process_component_def_t), pointer :: process_component_def
type(prclib_entry_t), pointer :: lib_entry
type(process_library_t), pointer :: lib
logical :: exist
type(process_t), pointer :: process
type(process_instance_t), target :: process_instance
type(resonance_history_set_t), dimension(1) :: res_history_set
type(resonant_subprocess_set_t) :: prc_set
type(particle_set_t) :: pset
real(default) :: sqrts, mw, pp
real(default), dimension(3) :: p3
type(vector4_t), dimension(:), allocatable :: p
real(default), dimension(:), allocatable :: m
integer, dimension(:), allocatable :: pdg
real(default), dimension(:), allocatable :: sqme
logical, dimension(:), allocatable :: mask
real(default) :: on_shell_limit
integer, dimension(:), allocatable :: i_array
real(default), dimension(:), allocatable :: prob_array
type(evt_resonance_t), target :: evt_resonance
integer :: i, u_dump
write (u, "(A)") "* Test output: restricted_subprocesses_3"
write (u, "(A)") "* Purpose: handle process and resonance kinematics"
write (u, "(A)")
call syntax_model_file_init ()
call syntax_phs_forest_init ()
call global%global_init ()
call global%append_log (&
var_str ("?rebuild_phase_space"), .true., intrinsic = .true.)
call global%set_log (var_str ("?omega_openmp"), &
.false., is_known = .true.)
call global%set_int (var_str ("seed"), &
0, is_known = .true.)
call global%set_real (var_str ("sqrts"),&
1000._default, is_known = .true.)
call global%set_log (var_str ("?resonance_history"), &
.true., is_known = .true.)
call global%select_model (var_str ("SM"))
allocate (model)
call model%init_instance (global%model)
model_data => model
libname = "restricted_subprocesses_3_lib"
libname_res = "restricted_subprocesses_3_lib_res"
procname = "restricted_subprocesses_3_p"
write (u, "(A)") "* Initialize process library and process"
write (u, "(A)")
allocate (lib_entry)
call lib_entry%init (libname)
lib => lib_entry%process_library_t
call global%add_prclib (lib_entry)
call prepare_resonance_test_library &
(lib, libname, procname, model_data, global, u)
call integrate_process (procname, global, &
local_stack = .true., init_only = .true.)
process => global%process_stack%get_process_ptr (procname)
call process_instance%init (process)
call process_instance%setup_event_data ()
write (u, "(A)")
write (u, "(A)") "* Extract resonance history set"
write (u, "(A)")
call process%extract_resonance_history_set &
(res_history_set(1), include_trivial=.true., i_component=1)
call res_history_set(1)%write (u)
write (u, "(A)")
write (u, "(A)") "* Build resonant-subprocess library"
write (u, "(A)")
call prc_set%init (1)
call prc_set%fill_resonances (res_history_set(1), 1)
process_component_def => process%get_component_def_ptr (1)
call prc_set%create_library (libname_res, global, exist)
if (.not. exist) then
call prc_set%add_to_library (1, &
process_component_def%get_prt_spec_in (), &
process_component_def%get_prt_spec_out (), &
global)
end if
call prc_set%freeze_library (global)
call prc_set%compile_library (global)
call prc_set%write (u, testflag=.true.)
write (u, "(A)")
write (u, "(A)") "* Build particle set"
write (u, "(A)")
sqrts = global%get_rval (var_str ("sqrts"))
mw = 80._default ! deliberately slightly different from true mw
pp = sqrt (sqrts**2 - 4 * mw**2) / 2
allocate (pdg (5), p (5), m (5))
pdg(1) = -11
p(1) = vector4_moving (sqrts/2, sqrts/2, 3)
m(1) = 0
pdg(2) = 11
p(2) = vector4_moving (sqrts/2,-sqrts/2, 3)
m(2) = 0
pdg(3) = 1
p3(1) = pp/2
p3(2) = mw/2
p3(3) = 0
p(3) = vector4_moving (sqrts/4, vector3_moving (p3))
m(3) = 0
p3(2) = -mw/2
pdg(4) = -2
p(4) = vector4_moving (sqrts/4, vector3_moving (p3))
m(4) = 0
pdg(5) = 24
p(5) = vector4_moving (sqrts/2,-pp, 1)
m(5) = mw
call pset%init_direct (0, 2, 0, 0, 3, pdg, model)
call pset%set_momentum (p, m**2)
call pset%write (u, testflag=.true.)
write (u, "(A)")
write (u, "(A)") "* Fill process instance"
! workflow from event_recalculate
call process_instance%choose_mci (1)
call process_instance%set_trace (pset, 1)
call process_instance%recover &
(1, 1, update_sqme=.true., recover_phs=.false.)
call process_instance%evaluate_event_data (weight = 1._default)
write (u, "(A)")
write (u, "(A)") "* Prepare resonant subprocesses"
call prc_set%prepare_process_objects (global)
call prc_set%prepare_process_instances (global)
call evt_resonance%set_resonance_data (res_history_set)
call evt_resonance%select_component (1)
call prc_set%connect_transform (evt_resonance)
call evt_resonance%connect (process_instance, model)
call prc_set%fill_momenta ()
write (u, "(A)")
write (u, "(A)") "* Show squared matrix element of master process,"
write (u, "(A)") " should coincide with 2nd subprocess sqme"
write (u, "(A)")
write (u, "(1x,I0,1x," // FMT_12 // ")") 0, prc_set%get_master_sqme ()
write (u, "(A)")
write (u, "(A)") "* Compute squared matrix elements &
&of selected resonant subprocesses [1,2]"
write (u, "(A)")
call prc_set%evaluate_subprocess ([1,2])
allocate (sqme (3), source = 0._default)
call prc_set%get_subprocess_sqme (sqme)
do i = 1, size (sqme)
write (u, "(1x,I0,1x," // FMT_12 // ")") i, sqme(i)
end do
deallocate (sqme)
write (u, "(A)")
write (u, "(A)") "* Compute squared matrix elements &
&of all resonant subprocesses"
write (u, "(A)")
call prc_set%evaluate_subprocess ([1,2,3])
allocate (sqme (3), source = 0._default)
call prc_set%get_subprocess_sqme (sqme)
do i = 1, size (sqme)
write (u, "(1x,I0,1x," // FMT_12 // ")") i, sqme(i)
end do
deallocate (sqme)
write (u, "(A)")
write (u, "(A)") "* Write process instances to file &
&restricted_subprocesses_3_lib_res.dat"
u_dump = free_unit ()
open (unit = u_dump, file = "restricted_subprocesses_3_lib_res.dat", &
action = "write", status = "replace")
call prc_set%dump_instances (u_dump)
close (u_dump)
write (u, "(A)")
write (u, "(A)") "* Determine on-shell resonant subprocesses"
write (u, "(A)")
on_shell_limit = 0
write (u, "(1x,A,1x," // FMT_10 // ")") "on_shell_limit =", on_shell_limit
call prc_set%set_on_shell_limit (on_shell_limit)
call prc_set%determine_on_shell_histories (1, i_array)
write (u, "(1x,A,9(1x,I0))") "resonant =", i_array
on_shell_limit = 0.1_default
write (u, "(1x,A,1x," // FMT_10 // ")") "on_shell_limit =", on_shell_limit
call prc_set%set_on_shell_limit (on_shell_limit)
call prc_set%determine_on_shell_histories (1, i_array)
write (u, "(1x,A,9(1x,I0))") "resonant =", i_array
on_shell_limit = 10._default
write (u, "(1x,A,1x," // FMT_10 // ")") "on_shell_limit =", on_shell_limit
call prc_set%set_on_shell_limit (on_shell_limit)
call prc_set%determine_on_shell_histories (1, i_array)
write (u, "(1x,A,9(1x,I0))") "resonant =", i_array
on_shell_limit = 10000._default
write (u, "(1x,A,1x," // FMT_10 // ")") "on_shell_limit =", on_shell_limit
call prc_set%set_on_shell_limit (on_shell_limit)
call prc_set%determine_on_shell_histories (1, i_array)
write (u, "(1x,A,9(1x,I0))") "resonant =", i_array
write (u, "(A)")
write (u, "(A)") "* Compute probabilities for applicable resonances"
write (u, "(A)") " and initialize the process selector"
write (u, "(A)") " (The first number is the probability for background)"
write (u, "(A)")
on_shell_limit = 0
write (u, "(1x,A,1x," // FMT_10 // ")") "on_shell_limit =", on_shell_limit
call prc_set%set_on_shell_limit (on_shell_limit)
call prc_set%determine_on_shell_histories (1, i_array)
call prc_set%compute_probabilities (prob_array)
write (u, "(1x,A,9(1x,"// FMT_12 // "))") "resonant =", prob_array
call prc_set%write (u, testflag=.true.)
write (u, *)
on_shell_limit = 10._default
write (u, "(1x,A,1x," // FMT_10 // ")") "on_shell_limit =", on_shell_limit
call prc_set%set_on_shell_limit (on_shell_limit)
call prc_set%determine_on_shell_histories (1, i_array)
call prc_set%compute_probabilities (prob_array)
write (u, "(1x,A,9(1x,"// FMT_12 // "))") "resonant =", prob_array
call prc_set%write (u, testflag=.true.)
write (u, *)
on_shell_limit = 10000._default
write (u, "(1x,A,1x," // FMT_10 // ")") "on_shell_limit =", on_shell_limit
call prc_set%set_on_shell_limit (on_shell_limit)
call prc_set%determine_on_shell_histories (1, i_array)
call prc_set%compute_probabilities (prob_array)
write (u, "(1x,A,9(1x,"// FMT_12 // "))") "resonant =", prob_array
write (u, *)
call prc_set%write (u, testflag=.true.)
write (u, *)
write (u, "(A)") "* Cleanup"
call global%final ()
call syntax_phs_forest_final ()
call syntax_model_file_final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: restricted_subprocesses_3"
end subroutine restricted_subprocesses_3
@ %def restricted_subprocesses_3
@
\subsubsection{Event transform}
Prepare an actual process with resonant subprocesses. Prepare the
resonance selector for a fixed event and apply the resonance-insertion
event transform.
<<Restricted subprocesses: execute tests>>=
call test (restricted_subprocesses_4, "restricted_subprocesses_4", &
"event transform", &
u, results)
<<Restricted subprocesses: test declarations>>=
public :: restricted_subprocesses_4
<<Restricted subprocesses: tests>>=
subroutine restricted_subprocesses_4 (u)
integer, intent(in) :: u
type(rt_data_t), target :: global
class(model_t), pointer :: model
class(model_data_t), pointer :: model_data
type(string_t) :: libname, libname_res
type(string_t) :: procname
type(process_component_def_t), pointer :: process_component_def
type(prclib_entry_t), pointer :: lib_entry
type(process_library_t), pointer :: lib
logical :: exist
type(process_t), pointer :: process
type(process_instance_t), target :: process_instance
type(resonance_history_set_t), dimension(1) :: res_history_set
type(resonant_subprocess_set_t) :: prc_set
type(particle_set_t) :: pset
real(default) :: sqrts, mw, pp
real(default), dimension(3) :: p3
type(vector4_t), dimension(:), allocatable :: p
real(default), dimension(:), allocatable :: m
integer, dimension(:), allocatable :: pdg
real(default) :: on_shell_limit
type(evt_trivial_t), target :: evt_trivial
type(evt_resonance_t), target :: evt_resonance
real(default) :: probability
integer :: i
write (u, "(A)") "* Test output: restricted_subprocesses_4"
write (u, "(A)") "* Purpose: employ event transform"
write (u, "(A)")
call syntax_model_file_init ()
call syntax_phs_forest_init ()
call global%global_init ()
call global%append_log (&
var_str ("?rebuild_phase_space"), .true., intrinsic = .true.)
call global%set_log (var_str ("?omega_openmp"), &
.false., is_known = .true.)
call global%set_int (var_str ("seed"), &
0, is_known = .true.)
call global%set_real (var_str ("sqrts"),&
1000._default, is_known = .true.)
call global%set_log (var_str ("?resonance_history"), &
.true., is_known = .true.)
call global%select_model (var_str ("SM"))
allocate (model)
call model%init_instance (global%model)
model_data => model
libname = "restricted_subprocesses_4_lib"
libname_res = "restricted_subprocesses_4_lib_res"
procname = "restricted_subprocesses_4_p"
write (u, "(A)") "* Initialize process library and process"
write (u, "(A)")
allocate (lib_entry)
call lib_entry%init (libname)
lib => lib_entry%process_library_t
call global%add_prclib (lib_entry)
call prepare_resonance_test_library &
(lib, libname, procname, model_data, global, u)
call integrate_process (procname, global, &
local_stack = .true., init_only = .true.)
process => global%process_stack%get_process_ptr (procname)
call process_instance%init (process)
call process_instance%setup_event_data ()
write (u, "(A)")
write (u, "(A)") "* Extract resonance history set"
call process%extract_resonance_history_set &
(res_history_set(1), include_trivial=.false., i_component=1)
write (u, "(A)")
write (u, "(A)") "* Build resonant-subprocess library"
call prc_set%init (1)
call prc_set%fill_resonances (res_history_set(1), 1)
process_component_def => process%get_component_def_ptr (1)
call prc_set%create_library (libname_res, global, exist)
if (.not. exist) then
call prc_set%add_to_library (1, &
process_component_def%get_prt_spec_in (), &
process_component_def%get_prt_spec_out (), &
global)
end if
call prc_set%freeze_library (global)
call prc_set%compile_library (global)
write (u, "(A)")
write (u, "(A)") "* Build particle set"
write (u, "(A)")
sqrts = global%get_rval (var_str ("sqrts"))
mw = 80._default ! deliberately slightly different from true mw
pp = sqrt (sqrts**2 - 4 * mw**2) / 2
allocate (pdg (5), p (5), m (5))
pdg(1) = -11
p(1) = vector4_moving (sqrts/2, sqrts/2, 3)
m(1) = 0
pdg(2) = 11
p(2) = vector4_moving (sqrts/2,-sqrts/2, 3)
m(2) = 0
pdg(3) = 1
p3(1) = pp/2
p3(2) = mw/2
p3(3) = 0
p(3) = vector4_moving (sqrts/4, vector3_moving (p3))
m(3) = 0
p3(2) = -mw/2
pdg(4) = -2
p(4) = vector4_moving (sqrts/4, vector3_moving (p3))
m(4) = 0
pdg(5) = 24
p(5) = vector4_moving (sqrts/2,-pp, 1)
m(5) = mw
call pset%init_direct (0, 2, 0, 0, 3, pdg, model)
call pset%set_momentum (p, m**2)
write (u, "(A)") "* Fill process instance"
write (u, "(A)")
! workflow from event_recalculate
call process_instance%choose_mci (1)
call process_instance%set_trace (pset, 1)
call process_instance%recover &
(1, 1, update_sqme=.true., recover_phs=.false.)
call process_instance%evaluate_event_data (weight = 1._default)
write (u, "(A)") "* Prepare resonant subprocesses"
write (u, "(A)")
call prc_set%prepare_process_objects (global)
call prc_set%prepare_process_instances (global)
write (u, "(A)") "* Fill trivial event transform (deliberately w/o color)"
write (u, "(A)")
call evt_trivial%connect (process_instance, model)
call evt_trivial%set_particle_set (pset, 1, 1)
call evt_trivial%write (u)
write (u, "(A)")
write (u, "(A)") "* Initialize resonance-insertion event transform"
write (u, "(A)")
evt_trivial%next => evt_resonance
evt_resonance%previous => evt_trivial
call evt_resonance%set_resonance_data (res_history_set)
call evt_resonance%select_component (1)
call evt_resonance%connect (process_instance, model)
call prc_set%connect_transform (evt_resonance)
call evt_resonance%write (u)
write (u, "(A)")
write (u, "(A)") "* Compute probabilities for applicable resonances"
write (u, "(A)") " and initialize the process selector"
write (u, "(A)")
on_shell_limit = 10._default
write (u, "(1x,A,1x," // FMT_10 // ")") "on_shell_limit =", on_shell_limit
call evt_resonance%set_on_shell_limit (on_shell_limit)
write (u, "(A)")
write (u, "(A)") "* Evaluate resonance-insertion event transform"
write (u, "(A)")
call evt_resonance%prepare_new_event (1, 1)
call evt_resonance%generate_weighted (probability)
call evt_resonance%make_particle_set (1, .false.)
call evt_resonance%write (u, testflag=.true.)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call global%final ()
call syntax_phs_forest_final ()
call syntax_model_file_final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: restricted_subprocesses_4"
end subroutine restricted_subprocesses_4
@ %def restricted_subprocesses_4
@
\subsubsection{Gaussian turnoff}
Identical to the previous process, except that we apply a Gaussian
turnoff to the resonance kinematics, which affects the subprocess selector.
<<Restricted subprocesses: execute tests>>=
call test (restricted_subprocesses_5, "restricted_subprocesses_5", &
"event transform with gaussian turnoff", &
u, results)
<<Restricted subprocesses: test declarations>>=
public :: restricted_subprocesses_5
<<Restricted subprocesses: tests>>=
subroutine restricted_subprocesses_5 (u)
integer, intent(in) :: u
type(rt_data_t), target :: global
class(model_t), pointer :: model
class(model_data_t), pointer :: model_data
type(string_t) :: libname, libname_res
type(string_t) :: procname
type(process_component_def_t), pointer :: process_component_def
type(prclib_entry_t), pointer :: lib_entry
type(process_library_t), pointer :: lib
logical :: exist
type(process_t), pointer :: process
type(process_instance_t), target :: process_instance
type(resonance_history_set_t), dimension(1) :: res_history_set
type(resonant_subprocess_set_t) :: prc_set
type(particle_set_t) :: pset
real(default) :: sqrts, mw, pp
real(default), dimension(3) :: p3
type(vector4_t), dimension(:), allocatable :: p
real(default), dimension(:), allocatable :: m
integer, dimension(:), allocatable :: pdg
real(default) :: on_shell_limit
real(default) :: on_shell_turnoff
type(evt_trivial_t), target :: evt_trivial
type(evt_resonance_t), target :: evt_resonance
real(default) :: probability
integer :: i
write (u, "(A)") "* Test output: restricted_subprocesses_5"
write (u, "(A)") "* Purpose: employ event transform &
&with gaussian turnoff"
write (u, "(A)")
call syntax_model_file_init ()
call syntax_phs_forest_init ()
call global%global_init ()
call global%append_log (&
var_str ("?rebuild_phase_space"), .true., intrinsic = .true.)
call global%set_log (var_str ("?omega_openmp"), &
.false., is_known = .true.)
call global%set_int (var_str ("seed"), &
0, is_known = .true.)
call global%set_real (var_str ("sqrts"),&
1000._default, is_known = .true.)
call global%set_log (var_str ("?resonance_history"), &
.true., is_known = .true.)
call global%select_model (var_str ("SM"))
allocate (model)
call model%init_instance (global%model)
model_data => model
libname = "restricted_subprocesses_5_lib"
libname_res = "restricted_subprocesses_5_lib_res"
procname = "restricted_subprocesses_5_p"
write (u, "(A)") "* Initialize process library and process"
write (u, "(A)")
allocate (lib_entry)
call lib_entry%init (libname)
lib => lib_entry%process_library_t
call global%add_prclib (lib_entry)
call prepare_resonance_test_library &
(lib, libname, procname, model_data, global, u)
call integrate_process (procname, global, &
local_stack = .true., init_only = .true.)
process => global%process_stack%get_process_ptr (procname)
call process_instance%init (process)
call process_instance%setup_event_data ()
write (u, "(A)")
write (u, "(A)") "* Extract resonance history set"
call process%extract_resonance_history_set &
(res_history_set(1), include_trivial=.false., i_component=1)
write (u, "(A)")
write (u, "(A)") "* Build resonant-subprocess library"
call prc_set%init (1)
call prc_set%fill_resonances (res_history_set(1), 1)
process_component_def => process%get_component_def_ptr (1)
call prc_set%create_library (libname_res, global, exist)
if (.not. exist) then
call prc_set%add_to_library (1, &
process_component_def%get_prt_spec_in (), &
process_component_def%get_prt_spec_out (), &
global)
end if
call prc_set%freeze_library (global)
call prc_set%compile_library (global)
write (u, "(A)")
write (u, "(A)") "* Build particle set"
write (u, "(A)")
sqrts = global%get_rval (var_str ("sqrts"))
mw = 80._default ! deliberately slightly different from true mw
pp = sqrt (sqrts**2 - 4 * mw**2) / 2
allocate (pdg (5), p (5), m (5))
pdg(1) = -11
p(1) = vector4_moving (sqrts/2, sqrts/2, 3)
m(1) = 0
pdg(2) = 11
p(2) = vector4_moving (sqrts/2,-sqrts/2, 3)
m(2) = 0
pdg(3) = 1
p3(1) = pp/2
p3(2) = mw/2
p3(3) = 0
p(3) = vector4_moving (sqrts/4, vector3_moving (p3))
m(3) = 0
p3(2) = -mw/2
pdg(4) = -2
p(4) = vector4_moving (sqrts/4, vector3_moving (p3))
m(4) = 0
pdg(5) = 24
p(5) = vector4_moving (sqrts/2,-pp, 1)
m(5) = mw
call pset%init_direct (0, 2, 0, 0, 3, pdg, model)
call pset%set_momentum (p, m**2)
write (u, "(A)") "* Fill process instance"
write (u, "(A)")
! workflow from event_recalculate
call process_instance%choose_mci (1)
call process_instance%set_trace (pset, 1)
call process_instance%recover &
(1, 1, update_sqme=.true., recover_phs=.false.)
call process_instance%evaluate_event_data (weight = 1._default)
write (u, "(A)") "* Prepare resonant subprocesses"
write (u, "(A)")
call prc_set%prepare_process_objects (global)
call prc_set%prepare_process_instances (global)
write (u, "(A)") "* Fill trivial event transform (deliberately w/o color)"
write (u, "(A)")
call evt_trivial%connect (process_instance, model)
call evt_trivial%set_particle_set (pset, 1, 1)
call evt_trivial%write (u)
write (u, "(A)")
write (u, "(A)") "* Initialize resonance-insertion event transform"
write (u, "(A)")
evt_trivial%next => evt_resonance
evt_resonance%previous => evt_trivial
call evt_resonance%set_resonance_data (res_history_set)
call evt_resonance%select_component (1)
call evt_resonance%connect (process_instance, model)
call prc_set%connect_transform (evt_resonance)
call evt_resonance%write (u)
write (u, "(A)")
write (u, "(A)") "* Compute probabilities for applicable resonances"
write (u, "(A)") " and initialize the process selector"
write (u, "(A)")
on_shell_limit = 10._default
write (u, "(1x,A,1x," // FMT_10 // ")") "on_shell_limit =", &
on_shell_limit
call evt_resonance%set_on_shell_limit (on_shell_limit)
on_shell_turnoff = 1._default
write (u, "(1x,A,1x," // FMT_10 // ")") "on_shell_turnoff =", &
on_shell_turnoff
call evt_resonance%set_on_shell_turnoff (on_shell_turnoff)
write (u, "(A)")
write (u, "(A)") "* Evaluate resonance-insertion event transform"
write (u, "(A)")
call evt_resonance%prepare_new_event (1, 1)
call evt_resonance%generate_weighted (probability)
call evt_resonance%make_particle_set (1, .false.)
call evt_resonance%write (u, testflag=.true.)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call global%final ()
call syntax_phs_forest_final ()
call syntax_model_file_final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: restricted_subprocesses_5"
end subroutine restricted_subprocesses_5
@ %def restricted_subprocesses_5
@
\subsubsection{Event transform}
The same process and event again. This time, switch off the background
contribution, so the selector becomes trivial.
<<Restricted subprocesses: execute tests>>=
call test (restricted_subprocesses_6, "restricted_subprocesses_6", &
"event transform with background switched off", &
u, results)
<<Restricted subprocesses: test declarations>>=
public :: restricted_subprocesses_6
<<Restricted subprocesses: tests>>=
subroutine restricted_subprocesses_6 (u)
integer, intent(in) :: u
type(rt_data_t), target :: global
class(model_t), pointer :: model
class(model_data_t), pointer :: model_data
type(string_t) :: libname, libname_res
type(string_t) :: procname
type(process_component_def_t), pointer :: process_component_def
type(prclib_entry_t), pointer :: lib_entry
type(process_library_t), pointer :: lib
logical :: exist
type(process_t), pointer :: process
type(process_instance_t), target :: process_instance
type(resonance_history_set_t), dimension(1) :: res_history_set
type(resonant_subprocess_set_t) :: prc_set
type(particle_set_t) :: pset
real(default) :: sqrts, mw, pp
real(default), dimension(3) :: p3
type(vector4_t), dimension(:), allocatable :: p
real(default), dimension(:), allocatable :: m
integer, dimension(:), allocatable :: pdg
real(default) :: on_shell_limit
real(default) :: background_factor
type(evt_trivial_t), target :: evt_trivial
type(evt_resonance_t), target :: evt_resonance
real(default) :: probability
integer :: i
write (u, "(A)") "* Test output: restricted_subprocesses_6"
write (u, "(A)") "* Purpose: employ event transform &
&with background switched off"
write (u, "(A)")
call syntax_model_file_init ()
call syntax_phs_forest_init ()
call global%global_init ()
call global%append_log (&
var_str ("?rebuild_phase_space"), .true., intrinsic = .true.)
call global%set_log (var_str ("?omega_openmp"), &
.false., is_known = .true.)
call global%set_int (var_str ("seed"), &
0, is_known = .true.)
call global%set_real (var_str ("sqrts"),&
1000._default, is_known = .true.)
call global%set_log (var_str ("?resonance_history"), &
.true., is_known = .true.)
call global%select_model (var_str ("SM"))
allocate (model)
call model%init_instance (global%model)
model_data => model
libname = "restricted_subprocesses_6_lib"
libname_res = "restricted_subprocesses_6_lib_res"
procname = "restricted_subprocesses_6_p"
write (u, "(A)") "* Initialize process library and process"
write (u, "(A)")
allocate (lib_entry)
call lib_entry%init (libname)
lib => lib_entry%process_library_t
call global%add_prclib (lib_entry)
call prepare_resonance_test_library &
(lib, libname, procname, model_data, global, u)
call integrate_process (procname, global, &
local_stack = .true., init_only = .true.)
process => global%process_stack%get_process_ptr (procname)
call process_instance%init (process)
call process_instance%setup_event_data ()
write (u, "(A)")
write (u, "(A)") "* Extract resonance history set"
call process%extract_resonance_history_set &
(res_history_set(1), include_trivial=.false., i_component=1)
write (u, "(A)")
write (u, "(A)") "* Build resonant-subprocess library"
call prc_set%init (1)
call prc_set%fill_resonances (res_history_set(1), 1)
process_component_def => process%get_component_def_ptr (1)
call prc_set%create_library (libname_res, global, exist)
if (.not. exist) then
call prc_set%add_to_library (1, &
process_component_def%get_prt_spec_in (), &
process_component_def%get_prt_spec_out (), &
global)
end if
call prc_set%freeze_library (global)
call prc_set%compile_library (global)
write (u, "(A)")
write (u, "(A)") "* Build particle set"
write (u, "(A)")
sqrts = global%get_rval (var_str ("sqrts"))
mw = 80._default ! deliberately slightly different from true mw
pp = sqrt (sqrts**2 - 4 * mw**2) / 2
allocate (pdg (5), p (5), m (5))
pdg(1) = -11
p(1) = vector4_moving (sqrts/2, sqrts/2, 3)
m(1) = 0
pdg(2) = 11
p(2) = vector4_moving (sqrts/2,-sqrts/2, 3)
m(2) = 0
pdg(3) = 1
p3(1) = pp/2
p3(2) = mw/2
p3(3) = 0
p(3) = vector4_moving (sqrts/4, vector3_moving (p3))
m(3) = 0
p3(2) = -mw/2
pdg(4) = -2
p(4) = vector4_moving (sqrts/4, vector3_moving (p3))
m(4) = 0
pdg(5) = 24
p(5) = vector4_moving (sqrts/2,-pp, 1)
m(5) = mw
call pset%init_direct (0, 2, 0, 0, 3, pdg, model)
call pset%set_momentum (p, m**2)
write (u, "(A)") "* Fill process instance"
write (u, "(A)")
! workflow from event_recalculate
call process_instance%choose_mci (1)
call process_instance%set_trace (pset, 1)
call process_instance%recover &
(1, 1, update_sqme=.true., recover_phs=.false.)
call process_instance%evaluate_event_data (weight = 1._default)
write (u, "(A)") "* Prepare resonant subprocesses"
write (u, "(A)")
call prc_set%prepare_process_objects (global)
call prc_set%prepare_process_instances (global)
write (u, "(A)") "* Fill trivial event transform (deliberately w/o color)"
write (u, "(A)")
call evt_trivial%connect (process_instance, model)
call evt_trivial%set_particle_set (pset, 1, 1)
call evt_trivial%write (u)
write (u, "(A)")
write (u, "(A)") "* Initialize resonance-insertion event transform"
write (u, "(A)")
evt_trivial%next => evt_resonance
evt_resonance%previous => evt_trivial
call evt_resonance%set_resonance_data (res_history_set)
call evt_resonance%select_component (1)
call evt_resonance%connect (process_instance, model)
call prc_set%connect_transform (evt_resonance)
call evt_resonance%write (u)
write (u, "(A)")
write (u, "(A)") "* Compute probabilities for applicable resonances"
write (u, "(A)") " and initialize the process selector"
write (u, "(A)")
on_shell_limit = 10._default
write (u, "(1x,A,1x," // FMT_10 // ")") &
"on_shell_limit =", on_shell_limit
call evt_resonance%set_on_shell_limit (on_shell_limit)
background_factor = 0
write (u, "(1x,A,1x," // FMT_10 // ")") &
"background_factor =", background_factor
call evt_resonance%set_background_factor (background_factor)
write (u, "(A)")
write (u, "(A)") "* Evaluate resonance-insertion event transform"
write (u, "(A)")
call evt_resonance%prepare_new_event (1, 1)
call evt_resonance%generate_weighted (probability)
call evt_resonance%make_particle_set (1, .false.)
call evt_resonance%write (u, testflag=.true.)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call global%final ()
call syntax_phs_forest_final ()
call syntax_model_file_final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: restricted_subprocesses_6"
end subroutine restricted_subprocesses_6
@ %def restricted_subprocesses_6
@
\clearpage
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{Simulation}
This module manages simulation: event generation and reading/writing of event
files. The [[simulation]] object is intended to be used (via a pointer)
outside of \whizard, if events are generated individually by an external
driver.
<<[[simulations.f90]]>>=
<<File header>>
module simulations
<<Use kinds>>
<<Use strings>>
<<Use debug>>
use io_units
use format_utils, only: write_separator
use format_defs, only: FMT_15, FMT_19
use os_interface
use numeric_utils
use string_utils, only: str
use diagnostics
use lorentz, only: vector4_t
use sm_qcd
use md5
use variables, only: var_list_t
use eval_trees
use model_data
use flavors
use particles
use state_matrices, only: FM_IGNORE_HELICITY
use beam_structures, only: beam_structure_t
use beams
use rng_base
use rng_stream, only: rng_stream_t
use selectors
use resonances, only: resonance_history_set_t
use process_libraries, only: process_library_t
use process_libraries, only: process_component_def_t
use prc_core
! TODO: (bcn 2016-09-13) should be ideally only pcm_base
use pcm, only: pcm_nlo_t, pcm_instance_nlo_t
! TODO: (bcn 2016-09-13) details of process config should not be necessary here
use process_config, only: COMP_REAL_FIN
use process
use instances
use event_base
use event_handles, only: event_handle_t
use events
use event_transforms
use shower
use eio_data
use eio_base
use rt_data
use dispatch_beams, only: dispatch_qcd
use dispatch_rng, only: dispatch_rng_factory
use dispatch_rng, only: update_rng_seed_in_var_list
use dispatch_me_methods, only: dispatch_core_update, dispatch_core_restore
use dispatch_transforms, only: dispatch_evt_isr_epa_handler
use dispatch_transforms, only: dispatch_evt_resonance
use dispatch_transforms, only: dispatch_evt_decay
use dispatch_transforms, only: dispatch_evt_shower
use dispatch_transforms, only: dispatch_evt_hadrons
use dispatch_transforms, only: dispatch_evt_nlo
use integrations
use event_streams
use restricted_subprocesses, only: resonant_subprocess_set_t
use restricted_subprocesses, only: get_libname_res
use evt_nlo
<<Use mpi f08>>
<<Standard module head>>
<<Simulations: public>>
<<Simulations: types>>
<<Simulations: interfaces>>
contains
<<Simulations: procedures>>
end module simulations
@ %def simulations
@
\subsection{Event counting}
In this object we collect statistical information about an event
sample or sub-sample.
<<Simulations: types>>=
type :: counter_t
integer :: total = 0
integer :: generated = 0
integer :: read = 0
integer :: positive = 0
integer :: negative = 0
integer :: zero = 0
integer :: excess = 0
integer :: dropped = 0
real(default) :: max_excess = 0
real(default) :: sum_excess = 0
logical :: reproduce_xsection = .false.
real(default) :: mean = 0
real(default) :: varsq = 0
integer :: nlo_weight_counter = 0
contains
<<Simulations: counter: TBP>>
end type counter_t
@ %def simulation_counter_t
@ Output.
<<Simulations: counter: TBP>>=
procedure :: write => counter_write
<<Simulations: procedures>>=
subroutine counter_write (counter, unit)
class(counter_t), intent(in) :: counter
integer, intent(in), optional :: unit
integer :: u
u = given_output_unit (unit)
1 format (3x,A,I0)
2 format (5x,A,I0)
3 format (5x,A,ES19.12)
write (u, 1) "Events total = ", counter%total
write (u, 2) "generated = ", counter%generated
write (u, 2) "read = ", counter%read
write (u, 2) "positive weight = ", counter%positive
write (u, 2) "negative weight = ", counter%negative
write (u, 2) "zero weight = ", counter%zero
write (u, 2) "excess weight = ", counter%excess
if (counter%excess /= 0) then
write (u, 3) "max excess = ", counter%max_excess
write (u, 3) "avg excess = ", counter%sum_excess / counter%total
end if
write (u, 1) "Events dropped = ", counter%dropped
end subroutine counter_write
@ %def counter_write
@ This is a screen message: if there was an excess, display statistics.
<<Simulations: counter: TBP>>=
procedure :: show_excess => counter_show_excess
<<Simulations: procedures>>=
subroutine counter_show_excess (counter)
class(counter_t), intent(in) :: counter
if (counter%excess > 0) then
write (msg_buffer, "(A,1x,I0,1x,A,1x,'(',F7.3,' %)')") &
"Encountered events with excess weight:", counter%excess, &
"events", 100 * counter%excess / real (counter%total)
call msg_warning ()
write (msg_buffer, "(A,ES10.3)") &
"Maximum excess weight =", counter%max_excess
call msg_message ()
write (msg_buffer, "(A,ES10.3)") &
"Average excess weight =", counter%sum_excess / counter%total
call msg_message ()
end if
end subroutine counter_show_excess
@ %def counter_show_excess
@ If events have been dropped during simulation of weighted events,
issue a message here.
If a fraction [[n_dropped / n_total]] of the events fail the cuts, we keep
generating new ones until we have [[n_total]] events with [[weight > 0]].
Thus, the total sum of weights will be a fraction of [[n_dropped / n_total]]
too large. However, we do not know how many events will pass or fail the cuts
prior to generating them so we leave it to the user to correct for this factor.
<<Simulations: counter: TBP>>=
procedure :: show_dropped => counter_show_dropped
<<Simulations: procedures>>=
subroutine counter_show_dropped (counter)
class(counter_t), intent(in) :: counter
if (counter%dropped > 0) then
write (msg_buffer, "(A,1x,I0,1x,'(',A,1x,I0,')')") &
"Dropped events (weight zero) =", &
counter%dropped, "total", counter%dropped + counter%total
call msg_message ()
write (msg_buffer, "(A,ES15.8)") &
"All event weights must be rescaled by f =", &
real (counter%total, default) &
/ real (counter%dropped + counter%total, default)
call msg_warning ()
end if
end subroutine counter_show_dropped
@ %def counter_show_dropped
@
<<Simulations: counter: TBP>>=
procedure :: show_mean_and_variance => counter_show_mean_and_variance
<<Simulations: procedures>>=
subroutine counter_show_mean_and_variance (counter)
class(counter_t), intent(in) :: counter
if (counter%reproduce_xsection .and. counter%nlo_weight_counter > 1) then
print *, "Reconstructed cross-section from event weights: "
print *, counter%mean, '+-', sqrt (counter%varsq / (counter%nlo_weight_counter - 1))
end if
end subroutine counter_show_mean_and_variance
@ %def counter_show_mean_and_variance
@ Count an event. The weight and event source are optional; by
default we assume that the event has been generated and has positive
weight.
The optional integer [[n_dropped]] counts weighted events with weight
zero that were encountered while generating the current event, but
dropped (because of their zero weight). Accumulating this number
allows for renormalizing event weight sums in histograms, after the
generation step has been completed.
<<Simulations: counter: TBP>>=
procedure :: record => counter_record
<<Simulations: procedures>>=
subroutine counter_record (counter, weight, excess, n_dropped, from_file)
class(counter_t), intent(inout) :: counter
real(default), intent(in), optional :: weight, excess
integer, intent(in), optional :: n_dropped
logical, intent(in), optional :: from_file
counter%total = counter%total + 1
if (present (from_file)) then
if (from_file) then
counter%read = counter%read + 1
else
counter%generated = counter%generated + 1
end if
else
counter%generated = counter%generated + 1
end if
if (present (weight)) then
if (weight > 0) then
counter%positive = counter%positive + 1
else if (weight < 0) then
counter%negative = counter%negative + 1
else
counter%zero = counter%zero + 1
end if
else
counter%positive = counter%positive + 1
end if
if (present (excess)) then
if (excess > 0) then
counter%excess = counter%excess + 1
counter%max_excess = max (counter%max_excess, excess)
counter%sum_excess = counter%sum_excess + excess
end if
end if
if (present (n_dropped)) then
counter%dropped = counter%dropped + n_dropped
end if
end subroutine counter_record
@ %def counter_record
<<MPI: Simulations: counter: TBP>>=
procedure :: allreduce_record => counter_allreduce_record
<<MPI: Simulations: procedures>>=
subroutine counter_allreduce_record (counter)
class(counter_t), intent(inout) :: counter
integer :: read, generated
integer :: positive, negative, zero, excess, dropped
real(default) :: max_excess, sum_excess
read = counter%read
generated = counter%generated
positive = counter%positive
negative = counter%negative
zero = counter%zero
excess = counter%excess
max_excess = counter%max_excess
sum_excess = counter%sum_excess
dropped = counter%dropped
call MPI_ALLREDUCE (read, counter%read, 1, MPI_INTEGER, MPI_SUM, MPI_COMM_WORLD)
call MPI_ALLREDUCE (generated, counter%generated, 1, MPI_INTEGER, MPI_SUM, MPI_COMM_WORLD)
call MPI_ALLREDUCE (positive, counter%positive, 1, MPI_INTEGER, MPI_SUM, MPI_COMM_WORLD)
call MPI_ALLREDUCE (negative, counter%negative, 1, MPI_INTEGER, MPI_SUM, MPI_COMM_WORLD)
call MPI_ALLREDUCE (zero, counter%zero, 1, MPI_INTEGER, MPI_SUM, MPI_COMM_WORLD)
call MPI_ALLREDUCE (excess, counter%excess, 1, MPI_INTEGER, MPI_SUM, MPI_COMM_WORLD)
call MPI_ALLREDUCE (max_excess, counter%max_excess, 1, MPI_DOUBLE_PRECISION, MPI_MAX, MPI_COMM_WORLD)
call MPI_ALLREDUCE (sum_excess, counter%sum_excess, 1, MPI_DOUBLE_PRECISION, MPI_SUM, MPI_COMM_WORLD)
call MPI_ALLREDUCE (dropped, counter%dropped, 1, MPI_INTEGER, MPI_SUM, MPI_COMM_WORLD)
!! \todo{sbrass - Implement allreduce of mean and variance, relevant for weighted events.}
end subroutine counter_allreduce_record
@
<<Simulations: counter: TBP>>=
procedure :: record_mean_and_variance => &
counter_record_mean_and_variance
<<Simulations: procedures>>=
subroutine counter_record_mean_and_variance (counter, weight, i_nlo)
class(counter_t), intent(inout) :: counter
real(default), intent(in) :: weight
integer, intent(in) :: i_nlo
real(default), save :: weight_buffer = 0._default
integer, save :: nlo_count = 1
if (.not. counter%reproduce_xsection) return
if (i_nlo == 1) then
call flush_weight_buffer (weight_buffer, nlo_count)
weight_buffer = weight
nlo_count = 1
else
weight_buffer = weight_buffer + weight
nlo_count = nlo_count + 1
end if
contains
subroutine flush_weight_buffer (w, n_nlo)
real(default), intent(in) :: w
integer, intent(in) :: n_nlo
integer :: n
real(default) :: mean_new
counter%nlo_weight_counter = counter%nlo_weight_counter + 1
!!! Minus 1 to take into account offset from initialization
n = counter%nlo_weight_counter - 1
if (n > 0) then
mean_new = counter%mean + (w / n_nlo - counter%mean) / n
if (n > 1) &
counter%varsq = counter%varsq - counter%varsq / (n - 1) + &
n * (mean_new - counter%mean)**2
counter%mean = mean_new
end if
end subroutine flush_weight_buffer
end subroutine counter_record_mean_and_variance
@ %def counter_record_mean_and_variance
@
\subsection{Simulation: component sets}
For each set of process components that share a MCI entry in the
process configuration, we keep a separate event record.
<<Simulations: types>>=
type :: mci_set_t
private
integer :: n_components = 0
integer, dimension(:), allocatable :: i_component
type(string_t), dimension(:), allocatable :: component_id
logical :: has_integral = .false.
real(default) :: integral = 0
real(default) :: error = 0
real(default) :: weight_mci = 0
type(counter_t) :: counter
contains
<<Simulations: mci set: TBP>>
end type mci_set_t
@ %def mci_set_t
@ Output.
<<Simulations: mci set: TBP>>=
procedure :: write => mci_set_write
<<Simulations: procedures>>=
subroutine mci_set_write (object, unit, pacified)
class(mci_set_t), intent(in) :: object
integer, intent(in), optional :: unit
logical, intent(in), optional :: pacified
logical :: pacify
integer :: u, i
u = given_output_unit (unit)
pacify = .false.; if (present (pacified)) pacify = pacified
write (u, "(3x,A)") "Components:"
do i = 1, object%n_components
write (u, "(5x,I0,A,A,A)") object%i_component(i), &
": '", char (object%component_id(i)), "'"
end do
if (object%has_integral) then
if (pacify) then
write (u, "(3x,A," // FMT_15 // ")") "Integral = ", object%integral
write (u, "(3x,A," // FMT_15 // ")") "Error = ", object%error
write (u, "(3x,A,F9.6)") "Weight =", object%weight_mci
else
write (u, "(3x,A," // FMT_19 // ")") "Integral = ", object%integral
write (u, "(3x,A," // FMT_19 // ")") "Error = ", object%error
write (u, "(3x,A,F13.10)") "Weight =", object%weight_mci
end if
else
write (u, "(3x,A)") "Integral = [undefined]"
end if
call object%counter%write (u)
end subroutine mci_set_write
@ %def mci_set_write
@ Initialize: Get the indices and names for the process components
that will contribute to this set.
<<Simulations: mci set: TBP>>=
procedure :: init => mci_set_init
<<Simulations: procedures>>=
subroutine mci_set_init (object, i_mci, process)
class(mci_set_t), intent(out) :: object
integer, intent(in) :: i_mci
type(process_t), intent(in), target :: process
integer :: i
call process%get_i_component (i_mci, object%i_component)
object%n_components = size (object%i_component)
allocate (object%component_id (object%n_components))
do i = 1, size (object%component_id)
object%component_id(i) = &
process%get_component_id (object%i_component(i))
end do
if (process%has_integral (i_mci)) then
object%integral = process%get_integral (i_mci)
object%error = process%get_error (i_mci)
object%has_integral = .true.
end if
end subroutine mci_set_init
@ %def mci_set_init
@
\subsection{Process-core Safe}
This is an object that temporarily holds a process core object. We
need this while rescanning a process with modified parameters. After
the rescan, we want to restore the original state.
<<Simulations: types>>=
type :: core_safe_t
class(prc_core_t), allocatable :: core
end type core_safe_t
@ %def core_safe_t
@
\subsection{Process Object}
The simulation works on process objects. This subroutine makes a
process object available for simulation. The process is in the
process stack. [[use_process]] implies that the process should
already exist as an object in the process stack. If integration is
not yet done, do it. Any generated process object should be put on
the global stack, if it is separate from the local one.
<<Simulations: procedures>>=
subroutine prepare_process &
(process, process_id, use_process, integrate, local, global)
type(process_t), pointer, intent(out) :: process
type(string_t), intent(in) :: process_id
logical, intent(in) :: use_process, integrate
type(rt_data_t), intent(inout), target :: local
type(rt_data_t), intent(inout), optional, target :: global
type(rt_data_t), pointer :: current
if (debug_on) call msg_debug (D_CORE, "prepare_process")
if (debug_on) call msg_debug (D_CORE, "global present", present (global))
if (present (global)) then
current => global
else
current => local
end if
process => current%process_stack%get_process_ptr (process_id)
if (debug_on) call msg_debug (D_CORE, "use_process", use_process)
if (debug_on) call msg_debug (D_CORE, "associated process", associated (process))
if (use_process .and. .not. associated (process)) then
if (integrate) then
call msg_message ("Simulate: process '" &
// char (process_id) // "' needs integration")
else
call msg_message ("Simulate: process '" &
// char (process_id) // "' needs initialization")
end if
if (present (global)) then
call integrate_process (process_id, local, global, &
init_only = .not. integrate)
else
call integrate_process (process_id, local, &
local_stack = .true., init_only = .not. integrate)
end if
if (signal_is_pending ()) return
process => current%process_stack%get_process_ptr (process_id)
if (associated (process)) then
if (integrate) then
call msg_message ("Simulate: integration done")
call current%process_stack%fill_result_vars (process_id)
else
call msg_message ("Simulate: process initialization done")
end if
else
call msg_fatal ("Simulate: process '" &
// char (process_id) // "' could not be initialized: aborting")
end if
else if (.not. associated (process)) then
if (present (global)) then
call integrate_process (process_id, local, global, &
init_only = .true.)
else
call integrate_process (process_id, local, &
local_stack = .true., init_only = .true.)
end if
process => current%process_stack%get_process_ptr (process_id)
call msg_message &
("Simulate: process '" &
// char (process_id) // "': enabled for rescan only")
end if
end subroutine prepare_process
@ %def prepare_process
@
\subsection{Simulation-entry object}
For each process that we consider for event generation, we need a
separate entry. The entry separately records the process ID and run ID. The
[[weight_mci]] array is used for selecting a component set (which
shares an MCI record inside the process container) when generating an
event for the current process.
The simulation entry is an extension of the [[event_t]] event record.
This core object contains configuration data, pointers to the process
and process instance, the expressions, flags and values that are
evaluated at runtime, and the resulting particle set.
The entry explicitly allocates the [[process_instance]], which becomes
the process-specific workspace for the event record.
If entries with differing environments are present simultaneously, we
may need to switch QCD parameters and/or the model event by event. In
this case, the [[qcd]] and/or [[model]] components are present.
For the purpose of NLO events, [[entry_t]] contains a pointer list
to other simulation-entries. This is due to the fact that we have to
associate an event for each component of the fixed order simulation,
i.e. one $N$-particle event and $N_\text{phs}$ $N+1$-particle events.
However, all entries share the same event transforms.
<<Simulations: types>>=
type, extends (event_t) :: entry_t
private
type(string_t) :: process_id
type(string_t) :: library
type(string_t) :: run_id
logical :: has_integral = .false.
real(default) :: integral = 0
real(default) :: error = 0
real(default) :: process_weight = 0
logical :: valid = .false.
type(counter_t) :: counter
integer :: n_in = 0
integer :: n_mci = 0
type(mci_set_t), dimension(:), allocatable :: mci_sets
type(selector_t) :: mci_selector
logical :: has_resonant_subprocess_set = .false.
type(resonant_subprocess_set_t) :: resonant_subprocess_set
type(core_safe_t), dimension(:), allocatable :: core_safe
class(model_data_t), pointer :: model => null ()
type(qcd_t) :: qcd
type(entry_t), pointer :: first => null ()
type(entry_t), pointer :: next => null ()
class(evt_t), pointer :: evt_powheg => null ()
contains
<<Simulations: entry: TBP>>
end type entry_t
@ %def entry_t
@ Output. Write just the configuration, the event is written by a
separate routine.
The [[verbose]] option is unused, it is required by the interface of
the base-object method.
<<Simulations: entry: TBP>>=
procedure :: write_config => entry_write_config
<<Simulations: procedures>>=
subroutine entry_write_config (object, unit, pacified)
class(entry_t), intent(in) :: object
integer, intent(in), optional :: unit
logical, intent(in), optional :: pacified
logical :: pacify
integer :: u, i
u = given_output_unit (unit)
pacify = .false.; if (present (pacified)) pacify = pacified
write (u, "(3x,A,A,A)") "Process = '", char (object%process_id), "'"
write (u, "(3x,A,A,A)") "Library = '", char (object%library), "'"
write (u, "(3x,A,A,A)") "Run = '", char (object%run_id), "'"
write (u, "(3x,A,L1)") "is valid = ", object%valid
if (object%has_integral) then
if (pacify) then
write (u, "(3x,A," // FMT_15 // ")") "Integral = ", object%integral
write (u, "(3x,A," // FMT_15 // ")") "Error = ", object%error
write (u, "(3x,A,F9.6)") "Weight =", object%process_weight
else
write (u, "(3x,A," // FMT_19 // ")") "Integral = ", object%integral
write (u, "(3x,A," // FMT_19 // ")") "Error = ", object%error
write (u, "(3x,A,F13.10)") "Weight =", object%process_weight
end if
else
write (u, "(3x,A)") "Integral = [undefined]"
end if
write (u, "(3x,A,I0)") "MCI sets = ", object%n_mci
call object%counter%write (u)
do i = 1, size (object%mci_sets)
write (u, "(A)")
write (u, "(1x,A,I0,A)") "MCI set #", i, ":"
call object%mci_sets(i)%write (u, pacified)
end do
if (object%resonant_subprocess_set%is_active ()) then
write (u, "(A)")
call object%write_resonant_subprocess_data (u)
end if
if (allocated (object%core_safe)) then
do i = 1, size (object%core_safe)
write (u, "(1x,A,I0,A)") "Saved process-component core #", i, ":"
call object%core_safe(i)%core%write (u)
end do
end if
end subroutine entry_write_config
@ %def entry_write_config
@ Finalizer. The [[instance]] pointer component of the [[event_t]]
base type points to a target which we did explicitly allocate in the
[[entry_init]] procedure. Therefore, we finalize and explicitly
deallocate it here. Then we call the finalizer of the base type.
<<Simulations: entry: TBP>>=
procedure :: final => entry_final
<<Simulations: procedures>>=
subroutine entry_final (object)
class(entry_t), intent(inout) :: object
integer :: i
if (associated (object%instance)) then
do i = 1, object%n_mci
call object%instance%final_simulation (i)
end do
call object%instance%final ()
deallocate (object%instance)
end if
call object%event_t%final ()
end subroutine entry_final
@ %def entry_final
@ Copy the content of an entry into another one, except for the next-pointer
<<Simulations: entry: TBP>>=
procedure :: copy_entry => entry_copy_entry
<<Simulations: procedures>>=
subroutine entry_copy_entry (entry1, entry2)
class(entry_t), intent(in), target :: entry1
type(entry_t), intent(inout), target :: entry2
call entry1%event_t%clone (entry2%event_t)
entry2%process_id = entry1%process_id
entry2%library = entry1%library
entry2%run_id = entry1%run_id
entry2%has_integral = entry1%has_integral
entry2%integral = entry1%integral
entry2%error = entry1%error
entry2%process_weight = entry1%process_weight
entry2%valid = entry1%valid
entry2%counter = entry1%counter
entry2%n_in = entry1%n_in
entry2%n_mci = entry1%n_mci
if (allocated (entry1%mci_sets)) then
allocate (entry2%mci_sets (size (entry1%mci_sets)))
entry2%mci_sets = entry1%mci_sets
end if
entry2%mci_selector = entry1%mci_selector
if (allocated (entry1%core_safe)) then
allocate (entry2%core_safe (size (entry1%core_safe)))
entry2%core_safe = entry1%core_safe
end if
entry2%model => entry1%model
entry2%qcd = entry1%qcd
end subroutine entry_copy_entry
@ %def entry_copy_entry
@
\subsubsection{Simulation-entry initialization}
Search for a process entry and allocate a process
instance as an anonymous object, temporarily accessible via the
[[process_instance]] pointer. Assign data by looking at the process
object and at the environment.
If [[n_alt]] is set, we prepare for additional alternate sqme and weight
entries.
The [[compile]] flag is only false if we do not need the Whizard
process at all, just its definition. In that case, we skip process
initialization.
Otherwise, and if the process object is not found initially: if
[[integrate]] is set, attempt an integration pass and try again.
Otherwise, just initialize the object.
If [[generate]] is set, prepare the MCI objects for generating new events.
For pure rescanning, this is not necessary.
If [[resonance_history]] is set, we create a separate process library
which contains all possible restricted subprocesses with distinct
resonance histories. These processes will not be integrated, but
their matrix element codes are used for determining probabilities of
resonance histories. Note that this can work only if the process
method is OMega, and the phase-space method is 'wood'.
When done, we assign the [[instance]] and [[process]] pointers of the
base type by the [[connect]] method, so we can reference them later.
TODO: In case of NLO event generation, copying the configuration from the
master process is rather intransparent. For instance, we override the process
var list by the global var list.
<<Simulations: entry: TBP>>=
procedure :: init => entry_init
<<Simulations: procedures>>=
subroutine entry_init &
(entry, process_id, &
use_process, integrate, generate, update_sqme, &
support_resonance_history, &
local, global, n_alt)
class(entry_t), intent(inout), target :: entry
type(string_t), intent(in) :: process_id
logical, intent(in) :: use_process, integrate, generate, update_sqme
logical, intent(in) :: support_resonance_history
type(rt_data_t), intent(inout), target :: local
type(rt_data_t), intent(inout), optional, target :: global
integer, intent(in), optional :: n_alt
type(process_t), pointer :: process, master_process
type(process_instance_t), pointer :: process_instance
type(process_library_t), pointer :: prclib_saved
integer :: i
logical :: res_include_trivial
logical :: combined_integration
integer :: selected_mci
selected_mci = 0
if (debug_on) call msg_debug (D_CORE, "entry_init")
if (debug_on) call msg_debug (D_CORE, "process_id", process_id)
call prepare_process &
(master_process, process_id, use_process, integrate, local, global)
if (signal_is_pending ()) return
if (associated (master_process)) then
if (.not. master_process%has_matrix_element ()) then
entry%has_integral = .true.
entry%process_id = process_id
entry%valid = .false.
return
end if
else
call entry%basic_init (local%var_list)
entry%has_integral = .false.
entry%process_id = process_id
call entry%import_process_def_characteristics (local%prclib, process_id)
entry%valid = .true.
return
end if
call entry%basic_init (local%var_list, n_alt)
entry%process_id = process_id
if (generate .or. integrate) then
entry%run_id = master_process%get_run_id ()
process => master_process
else
call local%set_log (var_str ("?rebuild_phase_space"), &
.false., is_known = .true.)
call local%set_log (var_str ("?check_phs_file"), &
.false., is_known = .true.)
call local%set_log (var_str ("?rebuild_grids"), &
.false., is_known = .true.)
entry%run_id = &
local%var_list%get_sval (var_str ("$run_id"))
if (update_sqme) then
call prepare_local_process (process, process_id, local)
else
process => master_process
end if
end if
call entry%import_process_characteristics (process)
allocate (entry%mci_sets (entry%n_mci))
do i = 1, size (entry%mci_sets)
call entry%mci_sets(i)%init (i, master_process)
end do
call entry%import_process_results (master_process)
call entry%prepare_expressions (local)
if (process%is_nlo_calculation ()) then
call process%init_nlo_settings (global%var_list)
end if
combined_integration = local%get_lval (var_str ("?combined_nlo_integration"))
if (.not. combined_integration &
.and. local%get_lval (var_str ("?fixed_order_nlo_events"))) &
selected_mci = process%extract_active_component_mci ()
call prepare_process_instance (process_instance, process, local%model, &
local = local)
if (generate) then
if (selected_mci > 0) then
call process%prepare_simulation (selected_mci)
call process_instance%init_simulation (selected_mci, entry%config%safety_factor, &
local%get_lval (var_str ("?keep_failed_events")))
else
do i = 1, entry%n_mci
call process%prepare_simulation (i)
call process_instance%init_simulation (i, entry%config%safety_factor, &
local%get_lval (var_str ("?keep_failed_events")))
end do
end if
end if
if (support_resonance_history) then
prclib_saved => local%prclib
call entry%setup_resonant_subprocesses (local, process)
if (entry%has_resonant_subprocess_set) then
if (signal_is_pending ()) return
call entry%compile_resonant_subprocesses (local)
if (signal_is_pending ()) return
call entry%prepare_resonant_subprocesses (local, global)
if (signal_is_pending ()) return
call entry%prepare_resonant_subprocess_instances (local)
end if
if (signal_is_pending ()) return
if (associated (prclib_saved)) call local%update_prclib (prclib_saved)
end if
call entry%setup_event_transforms (process, local)
call dispatch_qcd (entry%qcd, local%get_var_list_ptr (), local%os_data)
call entry%connect_qcd ()
select type (pcm => process_instance%pcm)
class is (pcm_instance_nlo_t)
select type (config => pcm%config)
type is (pcm_nlo_t)
if (config%settings%fixed_order_nlo) &
call pcm%set_fixed_order_event_mode ()
end select
end select
if (present (global)) then
call entry%connect (process_instance, local%model, global%process_stack)
else
call entry%connect (process_instance, local%model, local%process_stack)
end if
call entry%setup_expressions ()
entry%model => process%get_model_ptr ()
entry%valid = .true.
end subroutine entry_init
@ %def entry_init
@
<<Simulations: entry: TBP>>=
procedure :: set_active_real_components => entry_set_active_real_components
<<Simulations: procedures>>=
subroutine entry_set_active_real_components (entry)
class(entry_t), intent(inout) :: entry
integer :: i_active_real
select type (pcm => entry%instance%pcm)
class is (pcm_instance_nlo_t)
i_active_real = entry%instance%get_real_of_mci ()
if (debug_on) call msg_debug2 (D_CORE, "i_active_real", i_active_real)
if (associated (entry%evt_powheg)) then
select type (evt => entry%evt_powheg)
type is (evt_shower_t)
if (entry%process%get_component_type(i_active_real) == COMP_REAL_FIN) then
if (debug_on) call msg_debug (D_CORE, "Disabling Powheg matching for ", i_active_real)
call evt%disable_powheg_matching ()
else
if (debug_on) call msg_debug (D_CORE, "Enabling Powheg matching for ", i_active_real)
call evt%enable_powheg_matching ()
end if
class default
call msg_fatal ("powheg-evt should be evt_shower_t!")
end select
end if
end select
end subroutine entry_set_active_real_components
@ %def entry_set_active_real_components
@ Part of simulation-entry initialization: set up a process object for
local use.
<<Simulations: procedures>>=
subroutine prepare_local_process (process, process_id, local)
type(process_t), pointer, intent(inout) :: process
type(string_t), intent(in) :: process_id
type(rt_data_t), intent(inout), target :: local
type(integration_t) :: intg
call intg%create_process (process_id)
call intg%init_process (local)
call intg%setup_process (local, verbose=.false.)
process => intg%get_process_ptr ()
end subroutine prepare_local_process
@ %def prepare_local_process
@ Part of simulation-entry initialization: set up a process instance
matching the selected process object.
The model that we can provide as an extra argument can modify particle
settings (polarization) in the density matrices that will be constructed. It
does not affect parameters.
<<Simulations: procedures>>=
subroutine prepare_process_instance &
(process_instance, process, model, local)
type(process_instance_t), pointer, intent(inout) :: process_instance
type(process_t), intent(inout), target :: process
class(model_data_t), intent(in), optional :: model
type(rt_data_t), intent(in), optional, target :: local
allocate (process_instance)
call process_instance%init (process)
if (process%is_nlo_calculation ()) then
select type (pcm => process_instance%pcm)
type is (pcm_instance_nlo_t)
select type (config => pcm%config)
type is (pcm_nlo_t)
if (.not. config%settings%combined_integration) &
call pcm%set_radiation_event ()
end select
end select
call process%prepare_any_external_code ()
end if
call process_instance%setup_event_data (model)
end subroutine prepare_process_instance
@ %def prepare_process_instance
@ Part of simulation-entry initialization: query the
process for basic information.
<<Simulations: entry: TBP>>=
procedure, private :: import_process_characteristics &
=> entry_import_process_characteristics
<<Simulations: procedures>>=
subroutine entry_import_process_characteristics (entry, process)
class(entry_t), intent(inout) :: entry
type(process_t), intent(in), target :: process
entry%library = process%get_library_name ()
entry%n_in = process%get_n_in ()
entry%n_mci = process%get_n_mci ()
end subroutine entry_import_process_characteristics
@ %def entry_import_process_characteristics
@ This is the alternative form which applies if there is no process
entry, but just a process definition which we take from the provided
[[prclib]] definition library.
<<Simulations: entry: TBP>>=
procedure, private :: import_process_def_characteristics &
=> entry_import_process_def_characteristics
<<Simulations: procedures>>=
subroutine entry_import_process_def_characteristics (entry, prclib, id)
class(entry_t), intent(inout) :: entry
type(process_library_t), intent(in), target :: prclib
type(string_t), intent(in) :: id
entry%library = prclib%get_name ()
entry%n_in = prclib%get_n_in (id)
end subroutine entry_import_process_def_characteristics
@ %def entry_import_process_def_characteristics
@ Part of simulation-entry initialization: query the
process for integration results.
<<Simulations: entry: TBP>>=
procedure, private :: import_process_results &
=> entry_import_process_results
<<Simulations: procedures>>=
subroutine entry_import_process_results (entry, process)
class(entry_t), intent(inout) :: entry
type(process_t), intent(in), target :: process
if (process%has_integral ()) then
entry%integral = process%get_integral ()
entry%error = process%get_error ()
call entry%set_sigma (entry%integral)
entry%has_integral = .true.
end if
end subroutine entry_import_process_results
@ %def entry_import_process_characteristics
@ Part of simulation-entry initialization: create expression factory
objects and store them.
<<Simulations: entry: TBP>>=
procedure, private :: prepare_expressions &
=> entry_prepare_expressions
<<Simulations: procedures>>=
subroutine entry_prepare_expressions (entry, local)
class(entry_t), intent(inout) :: entry
type(rt_data_t), intent(in), target :: local
type(eval_tree_factory_t) :: expr_factory
call expr_factory%init (local%pn%selection_lexpr)
call entry%set_selection (expr_factory)
call expr_factory%init (local%pn%reweight_expr)
call entry%set_reweight (expr_factory)
call expr_factory%init (local%pn%analysis_lexpr)
call entry%set_analysis (expr_factory)
end subroutine entry_prepare_expressions
@ %def entry_prepare_expressions
@
\subsubsection{Extra (NLO) entries}
Initializes the list of additional NLO entries. The routine gets the
information about how many entries to associate from [[region_data]].
<<Simulations: entry: TBP>>=
procedure :: setup_additional_entries => entry_setup_additional_entries
<<Simulations: procedures>>=
subroutine entry_setup_additional_entries (entry)
class(entry_t), intent(inout), target :: entry
type(entry_t), pointer :: current_entry
integer :: i, n_phs
type(evt_nlo_t), pointer :: evt
integer :: mode
evt => null ()
select type (pcm => entry%instance%pcm)
class is (pcm_instance_nlo_t)
select type (config => pcm%config)
type is (pcm_nlo_t)
n_phs = config%region_data%n_phs
end select
end select
select type (entry)
type is (entry_t)
current_entry => entry
current_entry%first => entry
call get_nlo_evt_ptr (current_entry, evt, mode)
if (mode > EVT_NLO_SEPARATE_BORNLIKE) then
allocate (evt%particle_set_nlo (n_phs + 1))
evt%event_deps%n_phs = n_phs
evt%qcd = entry%qcd
do i = 1, n_phs
allocate (current_entry%next)
current_entry%next%first => current_entry%first
current_entry => current_entry%next
call entry%copy_entry (current_entry)
current_entry%i_event = i
end do
else
allocate (evt%particle_set_nlo (1))
end if
end select
contains
subroutine get_nlo_evt_ptr (entry, evt, mode)
type(entry_t), intent(in), target :: entry
type(evt_nlo_t), intent(out), pointer :: evt
integer, intent(out) :: mode
class(evt_t), pointer :: current_evt
evt => null ()
current_evt => entry%transform_first
do
select type (current_evt)
type is (evt_nlo_t)
evt => current_evt
mode = evt%mode
exit
end select
if (associated (current_evt%next)) then
current_evt => current_evt%next
else
call msg_fatal ("evt_nlo not in list of event transforms")
end if
end do
end subroutine get_nlo_evt_ptr
end subroutine entry_setup_additional_entries
@ %def entry_setup_additional_entries
@
<<Simulations: entry: TBP>>=
procedure :: get_first => entry_get_first
<<Simulations: procedures>>=
function entry_get_first (entry) result (entry_out)
class(entry_t), intent(in), target :: entry
type(entry_t), pointer :: entry_out
entry_out => null ()
select type (entry)
type is (entry_t)
if (entry%is_nlo ()) then
entry_out => entry%first
else
entry_out => entry
end if
end select
end function entry_get_first
@ %def entry_get_first
@
<<Simulations: entry: TBP>>=
procedure :: get_next => entry_get_next
<<Simulations: procedures>>=
function entry_get_next (entry) result (next_entry)
class(entry_t), intent(in) :: entry
type(entry_t), pointer :: next_entry
next_entry => null ()
if (associated (entry%next)) then
next_entry => entry%next
else
call msg_fatal ("Get next entry: No next entry")
end if
end function entry_get_next
@ %def entry_get_next
@
<<Simulations: entry: TBP>>=
procedure :: count_nlo_entries => entry_count_nlo_entries
<<Simulations: procedures>>=
function entry_count_nlo_entries (entry) result (n)
class(entry_t), intent(in), target :: entry
integer :: n
type(entry_t), pointer :: current_entry
n = 1
if (.not. associated (entry%next)) then
return
else
current_entry => entry%next
do
n = n + 1
if (.not. associated (current_entry%next)) exit
current_entry => current_entry%next
end do
end if
end function entry_count_nlo_entries
@ %def entry_count_nlo_entries
@
<<Simulations: entry: TBP>>=
procedure :: reset_nlo_counter => entry_reset_nlo_counter
<<Simulations: procedures>>=
subroutine entry_reset_nlo_counter (entry)
class(entry_t), intent(inout) :: entry
class(evt_t), pointer :: evt
evt => entry%transform_first
do
select type (evt)
type is (evt_nlo_t)
evt%i_evaluation = 0
exit
end select
if (associated (evt%next)) evt => evt%next
end do
end subroutine entry_reset_nlo_counter
@ %def entry_reset_nlo_counter
@
<<Simulations: entry: TBP>>=
procedure :: determine_if_powheg_matching => entry_determine_if_powheg_matching
<<Simulations: procedures>>=
subroutine entry_determine_if_powheg_matching (entry)
class(entry_t), intent(inout) :: entry
class(evt_t), pointer :: current_transform
if (associated (entry%transform_first)) then
current_transform => entry%transform_first
do
select type (current_transform)
type is (evt_shower_t)
if (current_transform%contains_powheg_matching ()) &
entry%evt_powheg => current_transform
exit
end select
if (associated (current_transform%next)) then
current_transform => current_transform%next
else
exit
end if
end do
end if
end subroutine entry_determine_if_powheg_matching
@ %def entry_determine_if_powheg_matching
@
\subsubsection{Event-transform initialization}
Part of simulation-entry initialization: dispatch event transforms
(decay, shower) as requested. If a transform is not applicable or
switched off via some variable, it will be skipped.
Regarding resonances/decays: these two transforms are currently mutually
exclusive. Resonance insertion will not be applied if there is an
unstable particle in the game.
The initial particle set is the output of the trivial transform; this
has already been applied when the transforms listed here are
encountered. Each transform takes a particle set and produces a new
one, with one exception: the decay module takes its input from the
process object, ignoring the trivial transform. (Reason: spin
correlations.) Therefore, the decay module must be first in line.
Settings that we don't or can't support (yet) are rejected by the
embedded call to [[event_transforms_check]].
<<Simulations: entry: TBP>>=
procedure, private :: setup_event_transforms &
=> entry_setup_event_transforms
<<Simulations: procedures>>=
subroutine entry_setup_event_transforms (entry, process, local)
class(entry_t), intent(inout) :: entry
type(process_t), intent(inout), target :: process
type(rt_data_t), intent(in), target :: local
class(evt_t), pointer :: evt
type(var_list_t), pointer :: var_list
logical :: enable_isr_handler
logical :: enable_epa_handler
logical :: enable_fixed_order
logical :: enable_shower
character(len=7) :: sample_normalization
call event_transforms_check (entry, process, local)
var_list => local%get_var_list_ptr ()
if (process%contains_unstable (local%model)) then
call dispatch_evt_decay (evt, local%var_list)
if (associated (evt)) call entry%import_transform (evt)
end if
if (entry%resonant_subprocess_set%is_active ()) then
call dispatch_evt_resonance (evt, local%var_list, &
entry%resonant_subprocess_set%get_resonance_history_set (), &
entry%resonant_subprocess_set%get_libname ())
if (associated (evt)) then
call entry%resonant_subprocess_set%connect_transform (evt)
call entry%resonant_subprocess_set%set_on_shell_limit &
(local%get_rval (var_str ("resonance_on_shell_limit")))
call entry%resonant_subprocess_set%set_on_shell_turnoff &
(local%get_rval (var_str ("resonance_on_shell_turnoff")))
call entry%resonant_subprocess_set%set_background_factor &
(local%get_rval (var_str ("resonance_background_factor")))
call entry%import_transform (evt)
end if
end if
enable_fixed_order = local%get_lval (var_str ("?fixed_order_nlo_events"))
if (enable_fixed_order) then
call dispatch_evt_nlo &
(evt, local%get_lval (var_str ("?keep_failed_events")))
call entry%import_transform (evt)
end if
enable_isr_handler = local%get_lval (var_str ("?isr_handler"))
enable_epa_handler = local%get_lval (var_str ("?epa_handler"))
if (enable_isr_handler .or. enable_epa_handler) then
call dispatch_evt_isr_epa_handler (evt, local%var_list)
if (associated (evt)) call entry%import_transform (evt)
end if
enable_shower = local%get_lval (var_str ("?allow_shower")) .and. &
(local%get_lval (var_str ("?ps_isr_active")) &
.or. local%get_lval (var_str ("?ps_fsr_active")) &
.or. local%get_lval (var_str ("?muli_active")) &
.or. local%get_lval (var_str ("?mlm_matching")) &
.or. local%get_lval (var_str ("?ckkw_matching")) &
.or. local%get_lval (var_str ("?powheg_matching")))
if (enable_shower) then
call dispatch_evt_shower (evt, var_list, local%model, &
local%fallback_model, local%os_data, local%beam_structure, &
process)
call entry%import_transform (evt)
end if
if (local%get_lval (var_str ("?hadronization_active"))) then
call dispatch_evt_hadrons (evt, var_list, local%fallback_model)
call entry%import_transform (evt)
end if
end subroutine entry_setup_event_transforms
@ %def entry_setup_event_transforms
@
This routine rejects all event-transform settings which we don't
support at present.
<<Simulations: procedures>>=
subroutine event_transforms_check (entry, process, local)
class(entry_t), intent(in) :: entry
type(process_t), intent(in), target :: process
type(rt_data_t), intent(in), target :: local
if (local%get_lval (var_str ("?fixed_order_nlo_events"))) then
if (local%get_lval (var_str ("?unweighted"))) then
call msg_fatal ("NLO fixed-order events have to be generated with &
&?unweighted = false")
end if
select case (char (local%get_sval (var_str ("$sample_normalization"))))
case ("sigma", "auto")
case default
call msg_fatal ("NLO fixed-order events: only &
&$sample_normalization = 'sigma' is supported.")
end select
if (process%contains_unstable (local%model)) then
call msg_fatal ("NLO fixed-order events: unstable final-state &
&particles not supported yet")
end if
if (entry%resonant_subprocess_set%is_active ()) then
call msg_fatal ("NLO fixed-order events: resonant subprocess &
&insertion not supported")
end if
if (local%get_lval (var_str ("?isr_handler")) &
.or. local%get_lval (var_str ("?epa_handler"))) then
call msg_fatal ("NLO fixed-order events: ISR handler for &
&photon-pT generation not supported yet")
end if
end if
if (process%contains_unstable (local%model) &
.and. entry%resonant_subprocess_set%is_active ()) then
call msg_fatal ("Simulation: resonant subprocess insertion with &
&unstable final-state particles not supported")
end if
end subroutine event_transforms_check
@ %def event_transforms_check
@
\subsubsection{Process/MCI selector}
Compute weights. The integral in the argument is the sum of integrals for
all processes in the sample. After computing the process weights, we repeat
the normalization procedure for the process components.
<<Simulations: entry: TBP>>=
procedure :: init_mci_selector => entry_init_mci_selector
<<Simulations: procedures>>=
subroutine entry_init_mci_selector (entry, negative_weights)
class(entry_t), intent(inout), target :: entry
logical, intent(in), optional :: negative_weights
type(entry_t), pointer :: current_entry
integer :: i, j, k
if (debug_on) call msg_debug (D_CORE, "entry_init_mci_selector")
if (entry%has_integral) then
select type (entry)
type is (entry_t)
current_entry => entry
do j = 1, current_entry%count_nlo_entries ()
if (j > 1) current_entry => current_entry%get_next ()
do k = 1, size(current_entry%mci_sets%integral)
if (debug_on) call msg_debug (D_CORE, "current_entry%mci_sets(k)%integral", &
current_entry%mci_sets(k)%integral)
end do
call current_entry%mci_selector%init &
(current_entry%mci_sets%integral, negative_weights)
do i = 1, current_entry%n_mci
current_entry%mci_sets(i)%weight_mci = &
current_entry%mci_selector%get_weight (i)
end do
end do
end select
end if
end subroutine entry_init_mci_selector
@ %def entry_init_mci_selector
@ Select a MCI entry, using the embedded random-number generator.
<<Simulations: entry: TBP>>=
procedure :: select_mci => entry_select_mci
<<Simulations: procedures>>=
function entry_select_mci (entry) result (i_mci)
class(entry_t), intent(inout) :: entry
integer :: i_mci
if (debug_on) call msg_debug2 (D_CORE, "entry_select_mci")
i_mci = entry%process%extract_active_component_mci ()
if (i_mci == 0) call entry%mci_selector%generate (entry%rng, i_mci)
if (debug_on) call msg_debug2 (D_CORE, "i_mci", i_mci)
end function entry_select_mci
@ %def entry_select_mci
@
\subsubsection{Entries: event-wise updates}
Record an event for this entry, i.e., increment the appropriate counters.
<<Simulations: entry: TBP>>=
procedure :: record => entry_record
<<Simulations: procedures>>=
subroutine entry_record (entry, i_mci, from_file)
class(entry_t), intent(inout) :: entry
integer, intent(in) :: i_mci
logical, intent(in), optional :: from_file
real(default) :: weight, excess
integer :: n_dropped
weight = entry%get_weight_prc ()
excess = entry%get_excess_prc ()
n_dropped = entry%get_n_dropped ()
call entry%counter%record (weight, excess, n_dropped, from_file)
if (i_mci > 0) then
call entry%mci_sets(i_mci)%counter%record (weight, excess)
end if
end subroutine entry_record
@ %def entry_record
@ Update and restore the process core that this entry accesses, when
parameters change. If explicit arguments [[model]], [[qcd]], or
[[helicity_selection]] are provided, use those. Otherwise use the
parameters stored in the process object.
These two procedures come with a caching mechanism which guarantees
that the current core object is saved when calling [[update_process]],
and restored by calling [[restore_process]]. If the flag [[saved]] is
unset, saving is skipped, and the [[restore]] procedure should not be
called.
<<Simulations: entry: TBP>>=
procedure :: update_process => entry_update_process
procedure :: restore_process => entry_restore_process
<<Simulations: procedures>>=
subroutine entry_update_process &
(entry, model, qcd, helicity_selection, saved)
class(entry_t), intent(inout) :: entry
class(model_data_t), intent(in), optional, target :: model
type(qcd_t), intent(in), optional :: qcd
type(helicity_selection_t), intent(in), optional :: helicity_selection
logical, intent(in), optional :: saved
type(process_t), pointer :: process
class(prc_core_t), allocatable :: core
integer :: i, n_terms
class(model_data_t), pointer :: model_local
type(qcd_t) :: qcd_local
logical :: use_saved
if (present (model)) then
model_local => model
else
model_local => entry%model
end if
if (present (qcd)) then
qcd_local = qcd
else
qcd_local = entry%qcd
end if
use_saved = .true.; if (present (saved)) use_saved = saved
process => entry%get_process_ptr ()
n_terms = process%get_n_terms ()
if (use_saved) allocate (entry%core_safe (n_terms))
do i = 1, n_terms
if (process%has_matrix_element (i, is_term_index = .true.)) then
call process%extract_core (i, core)
if (use_saved) then
call dispatch_core_update (core, &
model_local, helicity_selection, qcd_local, &
entry%core_safe(i)%core)
else
call dispatch_core_update (core, &
model_local, helicity_selection, qcd_local)
end if
call process%restore_core (i, core)
end if
end do
end subroutine entry_update_process
subroutine entry_restore_process (entry)
class(entry_t), intent(inout) :: entry
type(process_t), pointer :: process
class(prc_core_t), allocatable :: core
integer :: i, n_terms
process => entry%get_process_ptr ()
n_terms = process%get_n_terms ()
do i = 1, n_terms
if (process%has_matrix_element (i, is_term_index = .true.)) then
call process%extract_core (i, core)
call dispatch_core_restore (core, entry%core_safe(i)%core)
call process%restore_core (i, core)
end if
end do
deallocate (entry%core_safe)
end subroutine entry_restore_process
@ %def entry_update_process
@ %def entry_restore_process
<<Simulations: entry: TBP>>=
procedure :: connect_qcd => entry_connect_qcd
<<Simulations: procedures>>=
subroutine entry_connect_qcd (entry)
class(entry_t), intent(inout), target :: entry
class(evt_t), pointer :: evt
evt => entry%transform_first
do while (associated (evt))
select type (evt)
type is (evt_shower_t)
evt%qcd = entry%qcd
if (allocated (evt%matching)) then
evt%matching%qcd = entry%qcd
end if
end select
evt => evt%next
end do
end subroutine entry_connect_qcd
@ %def entry_connect_qcd
@
\subsection{Handling resonant subprocesses}
Resonant subprocesses are required if we want to determine resonance histories
when generating events. The feature is optional, to be switched on by
the user.
This procedure initializes a new, separate process library that
contains copies of the current process, restricted to the relevant
resonance histories. (If this library exists already, it is just
kept.) The histories can be extracted from the process object.
The code has to match the assignments in
[[create_resonant_subprocess_library]]. The library may already
exist -- in that case, here it will be recovered without recompilation.
<<Simulations: entry: TBP>>=
procedure :: setup_resonant_subprocesses &
=> entry_setup_resonant_subprocesses
<<Simulations: procedures>>=
subroutine entry_setup_resonant_subprocesses (entry, global, process)
class(entry_t), intent(inout) :: entry
type(rt_data_t), intent(inout), target :: global
type(process_t), intent(in), target :: process
type(string_t) :: libname
type(resonance_history_set_t) :: res_history_set
type(process_library_t), pointer :: lib
type(process_component_def_t), pointer :: process_component_def
logical :: req_resonant, library_exist
integer :: i_component
libname = process%get_library_name ()
lib => global%prclib_stack%get_library_ptr (libname)
entry%has_resonant_subprocess_set = lib%req_resonant (process%get_id ())
if (entry%has_resonant_subprocess_set) then
libname = get_libname_res (process%get_id ())
call entry%resonant_subprocess_set%init (process%get_n_components ())
call entry%resonant_subprocess_set%create_library &
(libname, global, library_exist)
do i_component = 1, process%get_n_components ()
call process%extract_resonance_history_set &
(res_history_set, i_component = i_component)
call entry%resonant_subprocess_set%fill_resonances &
(res_history_set, i_component)
if (.not. library_exist) then
process_component_def &
=> process%get_component_def_ptr (i_component)
call entry%resonant_subprocess_set%add_to_library &
(i_component, &
process_component_def%get_prt_spec_in (), &
process_component_def%get_prt_spec_out (), &
global)
end if
end do
call entry%resonant_subprocess_set%freeze_library (global)
end if
end subroutine entry_setup_resonant_subprocesses
@ %def entry_setup_resonant_subprocesses
@ Compile the resonant-subprocesses library. The library is assumed
to be the current library in the [[global]] object. This is a simple wrapper.
<<Simulations: entry: TBP>>=
procedure :: compile_resonant_subprocesses &
=> entry_compile_resonant_subprocesses
<<Simulations: procedures>>=
subroutine entry_compile_resonant_subprocesses (entry, global)
class(entry_t), intent(inout) :: entry
type(rt_data_t), intent(inout), target :: global
call entry%resonant_subprocess_set%compile_library (global)
end subroutine entry_compile_resonant_subprocesses
@ %def entry_compile_resonant_subprocesses
@ Prepare process objects for the resonant-subprocesses library. The
process objects are appended to the global process stack. We
initialize the processes, such that we can evaluate matrix elements,
but we do not need to integrate them.
<<Simulations: entry: TBP>>=
procedure :: prepare_resonant_subprocesses &
=> entry_prepare_resonant_subprocesses
<<Simulations: procedures>>=
subroutine entry_prepare_resonant_subprocesses (entry, local, global)
class(entry_t), intent(inout) :: entry
type(rt_data_t), intent(inout), target :: local
type(rt_data_t), intent(inout), optional, target :: global
call entry%resonant_subprocess_set%prepare_process_objects (local, global)
end subroutine entry_prepare_resonant_subprocesses
@ %def entry_prepare_resonant_subprocesses
@ Prepare process instances. They are linked to their corresponding process
objects. Both, process and instance objects, are allocated as anonymous
targets inside the [[resonant_subprocess_set]] component.
NOTE: those anonymous object are likely forgotten during finalization of the
parent [[event_t]] (extended as [[entry_t]]) object. This should be checked!
The memory leak is probably harmless as long as the event object is created
once per run, not once per event.
<<Simulations: entry: TBP>>=
procedure :: prepare_resonant_subprocess_instances &
=> entry_prepare_resonant_subprocess_instances
<<Simulations: procedures>>=
subroutine entry_prepare_resonant_subprocess_instances (entry, global)
class(entry_t), intent(inout) :: entry
type(rt_data_t), intent(in), target :: global
call entry%resonant_subprocess_set%prepare_process_instances (global)
end subroutine entry_prepare_resonant_subprocess_instances
@ %def entry_prepare_resonant_subprocess_instances
@ Display the resonant subprocesses. This includes, upon request, the
resonance set that defines those subprocess, and a short or long account of the
process objects themselves.
<<Simulations: entry: TBP>>=
procedure :: write_resonant_subprocess_data &
=> entry_write_resonant_subprocess_data
<<Simulations: procedures>>=
subroutine entry_write_resonant_subprocess_data (entry, unit)
class(entry_t), intent(in) :: entry
integer, intent(in), optional :: unit
integer :: u, i
u = given_output_unit (unit)
call entry%resonant_subprocess_set%write (unit)
write (u, "(1x,A,I0)") "Resonant subprocesses refer to &
&process component #", 1
end subroutine entry_write_resonant_subprocess_data
@ %def entry_write_resonant_subprocess_data
@ Display of the master process for the current event, for diagnostics.
<<Simulations: entry: TBP>>=
procedure :: write_process_data => entry_write_process_data
<<Simulations: procedures>>=
subroutine entry_write_process_data &
(entry, unit, show_process, show_instance, verbose)
class(entry_t), intent(in) :: entry
integer, intent(in), optional :: unit
logical, intent(in), optional :: show_process
logical, intent(in), optional :: show_instance
logical, intent(in), optional :: verbose
integer :: u, i
logical :: s_proc, s_inst, verb
type(process_t), pointer :: process
type(process_instance_t), pointer :: instance
u = given_output_unit (unit)
s_proc = .false.; if (present (show_process)) s_proc = show_process
s_inst = .false.; if (present (show_instance)) s_inst = show_instance
verb = .false.; if (present (verbose)) verb = verbose
if (s_proc .or. s_inst) then
write (u, "(1x,A,':')") "Process data"
if (s_proc) then
process => entry%process
if (associated (process)) then
if (verb) then
call write_separator (u, 2)
call process%write (.false., u)
else
call process%show (u, verbose=.false.)
end if
else
write (u, "(3x,A)") "[not associated]"
end if
end if
if (s_inst) then
instance => entry%instance
if (associated (instance)) then
if (verb) then
call instance%write (u)
else
call instance%write_header (u)
end if
else
write (u, "(3x,A)") "Process instance: [not associated]"
end if
end if
end if
end subroutine entry_write_process_data
@ %def entry_write_process_data
@
\subsection{Entries for alternative environment}
Entries for alternate environments. [No additional components
anymore, so somewhat redundant.]
<<Simulations: types>>=
type, extends (entry_t) :: alt_entry_t
contains
<<Simulations: alt entry: TBP>>
end type alt_entry_t
@ %def alt_entry_t
@ The alternative entries are there to re-evaluate the event, given
momenta, in a different context.
Therefore, we allocate a local process object and use this as the
reference for the local process instance, when initializing the entry.
We temporarily import the [[process]] object into an [[integration_t]]
wrapper, to take advantage of the associated methods. The local
process object is built in the context of the current environment,
here called [[global]]. Then, we initialize the process instance.
The [[master_process]] object contains the integration results to which we
refer when recalculating an event. Therefore, we use this object instead of
the locally built [[process]] when we extract the integration results.
The locally built [[process]] object should be finalized when done. It
remains accessible via the [[event_t]] base object of [[entry]], which
contains pointers to the process and instance.
<<Simulations: alt entry: TBP>>=
procedure :: init_alt => alt_entry_init
<<Simulations: procedures>>=
subroutine alt_entry_init (entry, process_id, master_process, local)
class(alt_entry_t), intent(inout), target :: entry
type(string_t), intent(in) :: process_id
type(process_t), intent(in), target :: master_process
type(rt_data_t), intent(inout), target :: local
type(process_t), pointer :: process
type(process_instance_t), pointer :: process_instance
type(string_t) :: run_id
integer :: i
call msg_message ("Simulate: initializing alternate process setup ...")
run_id = &
local%var_list%get_sval (var_str ("$run_id"))
call local%set_log (var_str ("?rebuild_phase_space"), &
.false., is_known = .true.)
call local%set_log (var_str ("?check_phs_file"), &
.false., is_known = .true.)
call local%set_log (var_str ("?rebuild_grids"), &
.false., is_known = .true.)
call entry%basic_init (local%var_list)
call prepare_local_process (process, process_id, local)
entry%process_id = process_id
entry%run_id = run_id
call entry%import_process_characteristics (process)
allocate (entry%mci_sets (entry%n_mci))
do i = 1, size (entry%mci_sets)
call entry%mci_sets(i)%init (i, master_process)
end do
call entry%import_process_results (master_process)
call entry%prepare_expressions (local)
call prepare_process_instance (process_instance, process, local%model)
call entry%setup_event_transforms (process, local)
call entry%connect (process_instance, local%model, local%process_stack)
call entry%setup_expressions ()
entry%model => process%get_model_ptr ()
call msg_message ("... alternate process setup complete.")
end subroutine alt_entry_init
@ %def alt_entry_init
@ Copy the particle set from the master entry to the alternate entry.
This is the particle set of the hard process.
<<Simulations: alt entry: TBP>>=
procedure :: fill_particle_set => entry_fill_particle_set
<<Simulations: procedures>>=
subroutine entry_fill_particle_set (alt_entry, entry)
class(alt_entry_t), intent(inout) :: alt_entry
class(entry_t), intent(in), target :: entry
type(particle_set_t) :: pset
call entry%get_hard_particle_set (pset)
call alt_entry%set_hard_particle_set (pset)
call pset%final ()
end subroutine entry_fill_particle_set
@ %def particle_set_copy_prt
@
\subsection{The simulation object}
Each simulation object corresponds to an event sample, identified by
the [[sample_id]].
The simulation may cover several processes simultaneously. All
process-specific data, including the event records, are stored in the
[[entry]] subobjects. The [[current]] index indicates which record
was selected last. [[version]] is foreseen to contain a tag on the \whizard\
event file version. It can be
<<Simulations: public>>=
public :: simulation_t
<<Simulations: types>>=
type :: simulation_t
private
type(rt_data_t), pointer :: local => null ()
type(string_t) :: sample_id
logical :: unweighted = .true.
logical :: negative_weights = .false.
logical :: support_resonance_history = .false.
logical :: respect_selection = .true.
integer :: norm_mode = NORM_UNDEFINED
logical :: update_sqme = .false.
logical :: update_weight = .false.
logical :: update_event = .false.
logical :: recover_beams = .false.
logical :: pacify = .false.
integer :: n_max_tries = 10000
integer :: n_prc = 0
integer :: n_alt = 0
logical :: has_integral = .false.
logical :: valid = .false.
real(default) :: integral = 0
real(default) :: error = 0
integer :: version = 1
character(32) :: md5sum_prc = ""
character(32) :: md5sum_cfg = ""
character(32), dimension(:), allocatable :: md5sum_alt
type(entry_t), dimension(:), allocatable :: entry
type(alt_entry_t), dimension(:,:), allocatable :: alt_entry
type(selector_t) :: process_selector
integer :: n_evt_requested = 0
integer :: event_index_offset = 0
logical :: event_index_set = .false.
integer :: event_index = 0
integer :: split_n_evt = 0
integer :: split_n_kbytes = 0
integer :: split_index = 0
type(counter_t) :: counter
class(rng_t), allocatable :: rng
integer :: i_prc = 0
integer :: i_mci = 0
real(default) :: weight = 0
real(default) :: excess = 0
integer :: n_dropped = 0
contains
<<Simulations: simulation: TBP>>
end type simulation_t
@ %def simulation_t
@
\subsubsection{Output of the simulation data}
[[write_config]] writes just the configuration. [[write]]
as a method of the base type [[event_t]]
writes the current event and process instance, depending on options.
<<Simulations: simulation: TBP>>=
procedure :: write => simulation_write
<<Simulations: procedures>>=
subroutine simulation_write (object, unit, testflag)
class(simulation_t), intent(in) :: object
integer, intent(in), optional :: unit
logical, intent(in), optional :: testflag
logical :: pacified
integer :: u, i
u = given_output_unit (unit)
pacified = object%pacify; if (present (testflag)) pacified = testflag
call write_separator (u, 2)
write (u, "(1x,A,A,A)") "Event sample: '", char (object%sample_id), "'"
write (u, "(3x,A,I0)") "Processes = ", object%n_prc
if (object%n_alt > 0) then
write (u, "(3x,A,I0)") "Alt.wgts = ", object%n_alt
end if
write (u, "(3x,A,L1)") "Unweighted = ", object%unweighted
write (u, "(3x,A,A)") "Event norm = ", &
char (event_normalization_string (object%norm_mode))
write (u, "(3x,A,L1)") "Neg. weights = ", object%negative_weights
write (u, "(3x,A,L1)") "Res. history = ", object%support_resonance_history
write (u, "(3x,A,L1)") "Respect sel. = ", object%respect_selection
write (u, "(3x,A,L1)") "Update sqme = ", object%update_sqme
write (u, "(3x,A,L1)") "Update wgt = ", object%update_weight
write (u, "(3x,A,L1)") "Update event = ", object%update_event
write (u, "(3x,A,L1)") "Recov. beams = ", object%recover_beams
write (u, "(3x,A,L1)") "Pacify = ", object%pacify
write (u, "(3x,A,I0)") "Max. tries = ", object%n_max_tries
if (object%has_integral) then
if (pacified) then
write (u, "(3x,A," // FMT_15 // ")") &
"Integral = ", object%integral
write (u, "(3x,A," // FMT_15 // ")") &
"Error = ", object%error
else
write (u, "(3x,A," // FMT_19 // ")") &
"Integral = ", object%integral
write (u, "(3x,A," // FMT_19 // ")") &
"Error = ", object%error
end if
else
write (u, "(3x,A)") "Integral = [undefined]"
end if
write (u, "(3x,A,L1)") "Sim. valid = ", object%valid
write (u, "(3x,A,I0)") "Ev.file ver. = ", object%version
if (object%md5sum_prc /= "") then
write (u, "(3x,A,A,A)") "MD5 sum (proc) = '", object%md5sum_prc, "'"
end if
if (object%md5sum_cfg /= "") then
write (u, "(3x,A,A,A)") "MD5 sum (config) = '", object%md5sum_cfg, "'"
end if
write (u, "(3x,A,I0)") "Events requested = ", object%n_evt_requested
if (object%event_index_offset /= 0) then
write (u, "(3x,A,I0)") "Event index offset= ", object%event_index_offset
end if
if (object%event_index_set) then
write (u, "(3x,A,I0)") "Event index = ", object%event_index
end if
if (object%split_n_evt > 0 .or. object%split_n_kbytes > 0) then
write (u, "(3x,A,I0)") "Events per file = ", object%split_n_evt
write (u, "(3x,A,I0)") "KBytes per file = ", object%split_n_kbytes
write (u, "(3x,A,I0)") "First file index = ", object%split_index
end if
call object%counter%write (u)
call write_separator (u)
if (object%i_prc /= 0) then
write (u, "(1x,A)") "Current event:"
write (u, "(3x,A,I0,A,A)") "Process #", &
object%i_prc, ": ", &
char (object%entry(object%i_prc)%process_id)
write (u, "(3x,A,I0)") "MCI set #", object%i_mci
write (u, "(3x,A," // FMT_19 // ")") "Weight = ", object%weight
if (.not. vanishes (object%excess)) &
write (u, "(3x,A," // FMT_19 // ")") "Excess = ", object%excess
write (u, "(3x,A,I0)") "Zero-weight events dropped = ", object%n_dropped
else
write (u, "(1x,A,I0,A,A)") "Current event: [undefined]"
end if
call write_separator (u)
if (allocated (object%rng)) then
call object%rng%write (u)
else
write (u, "(3x,A)") "Random-number generator: [undefined]"
end if
if (allocated (object%entry)) then
do i = 1, size (object%entry)
if (i == 1) then
call write_separator (u, 2)
else
call write_separator (u)
end if
write (u, "(1x,A,I0,A)") "Process #", i, ":"
call object%entry(i)%write_config (u, pacified)
end do
end if
call write_separator (u, 2)
end subroutine simulation_write
@ %def simulation_write
@ Write the current event record. If an explicit index is given,
write that event record.
We implement writing to [[unit]] (event contents / debugging format)
and writing to an [[eio]] event stream (storage). We include a [[testflag]]
in order to suppress numerical noise in the testsuite.
<<Simulations: simulation: TBP>>=
generic :: write_event => write_event_unit
procedure :: write_event_unit => simulation_write_event_unit
<<Simulations: procedures>>=
subroutine simulation_write_event_unit &
(object, unit, i_prc, verbose, testflag)
class(simulation_t), intent(in) :: object
integer, intent(in), optional :: unit
logical, intent(in), optional :: verbose
integer, intent(in), optional :: i_prc
logical, intent(in), optional :: testflag
logical :: pacified
integer :: current
pacified = .false.; if (present(testflag)) pacified = testflag
pacified = pacified .or. object%pacify
if (present (i_prc)) then
current = i_prc
else
current = object%i_prc
end if
if (current > 0) then
call object%entry(current)%write (unit, verbose = verbose, &
testflag = pacified)
else
call msg_fatal ("Simulation: write event: no process selected")
end if
end subroutine simulation_write_event_unit
@ %def simulation_write_event
@ This writes one of the alternate events, if allocated.
<<Simulations: simulation: TBP>>=
procedure :: write_alt_event => simulation_write_alt_event
<<Simulations: procedures>>=
subroutine simulation_write_alt_event (object, unit, j_alt, i_prc, &
verbose, testflag)
class(simulation_t), intent(in) :: object
integer, intent(in), optional :: unit
integer, intent(in), optional :: j_alt
integer, intent(in), optional :: i_prc
logical, intent(in), optional :: verbose
logical, intent(in), optional :: testflag
integer :: i, j
if (present (j_alt)) then
j = j_alt
else
j = 1
end if
if (present (i_prc)) then
i = i_prc
else
i = object%i_prc
end if
if (i > 0) then
if (j> 0 .and. j <= object%n_alt) then
call object%alt_entry(i,j)%write (unit, verbose = verbose, &
testflag = testflag)
else
call msg_fatal ("Simulation: write alternate event: out of range")
end if
else
call msg_fatal ("Simulation: write alternate event: no process selected")
end if
end subroutine simulation_write_alt_event
@ %def simulation_write_alt_event
@ This writes the contents of the resonant subprocess set in the current event
record.
<<Simulations: simulation: TBP>>=
procedure :: write_resonant_subprocess_data &
=> simulation_write_resonant_subprocess_data
<<Simulations: procedures>>=
subroutine simulation_write_resonant_subprocess_data (object, unit, i_prc)
class(simulation_t), intent(in) :: object
integer, intent(in), optional :: unit
integer, intent(in), optional :: i_prc
integer :: i
if (present (i_prc)) then
i = i_prc
else
i = object%i_prc
end if
call object%entry(i)%write_resonant_subprocess_data (unit)
end subroutine simulation_write_resonant_subprocess_data
@ %def simulation_write_resonant_subprocess_data
@ The same for the master process, as an additional debugging aid.
<<Simulations: simulation: TBP>>=
procedure :: write_process_data &
=> simulation_write_process_data
<<Simulations: procedures>>=
subroutine simulation_write_process_data &
(object, unit, i_prc, &
show_process, show_instance, verbose)
class(simulation_t), intent(in) :: object
integer, intent(in), optional :: unit
integer, intent(in), optional :: i_prc
logical, intent(in), optional :: show_process
logical, intent(in), optional :: show_instance
logical, intent(in), optional :: verbose
integer :: i
if (present (i_prc)) then
i = i_prc
else
i = object%i_prc
end if
call object%entry(i)%write_process_data &
(unit, show_process, show_instance, verbose)
end subroutine simulation_write_process_data
@ %def simulation_write_process_data
@ Write the actual efficiency of the simulation run. We get the total
number of events stored in the simulation counter and compare this
with the total number of calls stored in the event entries.
In order not to miscount samples that are partly read from file, use
the [[generated]] counter, not the [[total]] counter.
<<Simulations: simulation: TBP>>=
procedure :: show_efficiency => simulation_show_efficiency
<<Simulations: procedures>>=
subroutine simulation_show_efficiency (simulation)
class(simulation_t), intent(inout) :: simulation
integer :: n_events, n_calls
real(default) :: eff
n_events = simulation%counter%generated
n_calls = sum (simulation%entry%get_actual_calls_total ())
if (n_calls > 0) then
eff = real (n_events, kind=default) / n_calls
write (msg_buffer, "(A,1x,F6.2,1x,A)") &
"Events: actual unweighting efficiency =", 100 * eff, "%"
call msg_message ()
end if
end subroutine simulation_show_efficiency
@ %def simulation_show_efficiency
@ Compute the checksum of the process set. We retrieve the MD5 sums
of all processes. This depends only on the process definitions, while
parameters are not considered. The configuration checksum is
retrieved from the MCI records in the process objects and furthermore
includes beams, parameters, integration results, etc., so matching the
latter should guarantee identical physics.
<<Simulations: simulation: TBP>>=
procedure :: compute_md5sum => simulation_compute_md5sum
<<Simulations: procedures>>=
subroutine simulation_compute_md5sum (simulation)
class(simulation_t), intent(inout) :: simulation
type(process_t), pointer :: process
type(string_t) :: buffer
integer :: j, i, n_mci, i_mci, n_component, i_component
if (simulation%md5sum_prc == "") then
buffer = ""
do i = 1, simulation%n_prc
if (.not. simulation%entry(i)%valid) cycle
process => simulation%entry(i)%get_process_ptr ()
if (associated (process)) then
n_component = process%get_n_components ()
do i_component = 1, n_component
if (process%has_matrix_element (i_component)) then
buffer = buffer // process%get_md5sum_prc (i_component)
end if
end do
end if
end do
simulation%md5sum_prc = md5sum (char (buffer))
end if
if (simulation%md5sum_cfg == "") then
buffer = ""
do i = 1, simulation%n_prc
if (.not. simulation%entry(i)%valid) cycle
process => simulation%entry(i)%get_process_ptr ()
if (associated (process)) then
n_mci = process%get_n_mci ()
do i_mci = 1, n_mci
buffer = buffer // process%get_md5sum_mci (i_mci)
end do
end if
end do
simulation%md5sum_cfg = md5sum (char (buffer))
end if
do j = 1, simulation%n_alt
if (simulation%md5sum_alt(j) == "") then
buffer = ""
do i = 1, simulation%n_prc
process => simulation%alt_entry(i,j)%get_process_ptr ()
if (associated (process)) then
buffer = buffer // process%get_md5sum_cfg ()
end if
end do
simulation%md5sum_alt(j) = md5sum (char (buffer))
end if
end do
end subroutine simulation_compute_md5sum
@ %def simulation_compute_md5sum
@
\subsubsection{Simulation-object finalizer}
<<Simulations: simulation: TBP>>=
procedure :: final => simulation_final
<<Simulations: procedures>>=
subroutine simulation_final (object)
class(simulation_t), intent(inout) :: object
integer :: i, j
if (allocated (object%entry)) then
do i = 1, size (object%entry)
call object%entry(i)%final ()
end do
end if
if (allocated (object%alt_entry)) then
do j = 1, size (object%alt_entry, 2)
do i = 1, size (object%alt_entry, 1)
call object%alt_entry(i,j)%final ()
end do
end do
end if
if (allocated (object%rng)) call object%rng%final ()
end subroutine simulation_final
@ %def simulation_final
@
\subsubsection{Simulation-object initialization}
We can deduce all data from the given list of
process IDs and the global data set. The process objects are taken
from the stack. Once the individual integrals are known, we add them (and the
errors), to get the sample integral.
If there are alternative environments, we suspend initialization for
setting up alternative process objects, then restore the master
process and its parameters. The generator or rescanner can then
switch rapidly between processes.
If [[integrate]] is set, we make sure that all affected processes are
integrated before simulation. This is necessary if we want to actually
generate events. If [[integrate]] is unset, we do not need the integral
because we just rescan existing events. In that case, we just need compiled
matrix elements.
If [[generate]] is set, we prepare for actually generating events. Otherwise,
we may only read and rescan events.
<<Simulations: simulation: TBP>>=
procedure :: init => simulation_init
<<Simulations: procedures>>=
subroutine simulation_init (simulation, &
process_id, integrate, generate, local, global, alt_env)
class(simulation_t), intent(out), target :: simulation
type(string_t), dimension(:), intent(in) :: process_id
logical, intent(in) :: integrate, generate
type(rt_data_t), intent(inout), target :: local
type(rt_data_t), intent(inout), optional, target :: global
type(rt_data_t), dimension(:), intent(inout), optional, target :: alt_env
class(rng_factory_t), allocatable :: rng_factory
integer :: next_rng_seed
type(string_t) :: norm_string, version_string
logical :: use_process
integer :: i, j
type(string_t) :: sample_suffix
<<Simulations: simulation init: extra variables>>
sample_suffix = ""
<<Simulations: simulation init: extra init>>
simulation%local => local
simulation%sample_id = &
local%get_sval (var_str ("$sample"))
simulation%unweighted = &
local%get_lval (var_str ("?unweighted"))
simulation%negative_weights = &
local%get_lval (var_str ("?negative_weights"))
simulation%support_resonance_history = &
local%get_lval (var_str ("?resonance_history"))
simulation%respect_selection = &
local%get_lval (var_str ("?sample_select"))
version_string = &
local%get_sval (var_str ("$event_file_version"))
norm_string = &
local%get_sval (var_str ("$sample_normalization"))
simulation%norm_mode = &
event_normalization_mode (norm_string, simulation%unweighted)
simulation%pacify = &
local%get_lval (var_str ("?sample_pacify"))
simulation%event_index_offset = &
local%get_ival (var_str ("event_index_offset"))
simulation%n_max_tries = &
local%get_ival (var_str ("sample_max_tries"))
simulation%split_n_evt = &
local%get_ival (var_str ("sample_split_n_evt"))
simulation%split_n_kbytes = &
local%get_ival (var_str ("sample_split_n_kbytes"))
simulation%split_index = &
local%get_ival (var_str ("sample_split_index"))
simulation%update_sqme = &
local%get_lval (var_str ("?update_sqme"))
simulation%update_weight = &
local%get_lval (var_str ("?update_weight"))
simulation%update_event = &
local%get_lval (var_str ("?update_event"))
simulation%recover_beams = &
local%get_lval (var_str ("?recover_beams"))
simulation%counter%reproduce_xsection = &
local%get_lval (var_str ("?check_event_weights_against_xsection"))
use_process = &
integrate .or. generate &
.or. simulation%update_sqme &
.or. simulation%update_weight &
.or. simulation%update_event &
.or. present (alt_env)
select case (size (process_id))
case (0)
call msg_error ("Simulation: no process selected")
case (1)
write (msg_buffer, "(A,A,A)") &
"Starting simulation for process '", &
char (process_id(1)), "'"
call msg_message ()
case default
write (msg_buffer, "(A,A,A)") &
"Starting simulation for processes '", &
char (process_id(1)), "' etc."
call msg_message ()
end select
select case (char (version_string))
case ("", "2.2.4")
simulation%version = 2
case ("2.2")
simulation%version = 1
case default
simulation%version = 0
end select
if (simulation%version == 0) then
call msg_fatal ("Event file format '" &
// char (version_string) &
// "' is not compatible with this version.")
end if
simulation%n_prc = size (process_id)
allocate (simulation%entry (simulation%n_prc))
if (present (alt_env)) then
simulation%n_alt = size (alt_env)
do i = 1, simulation%n_prc
call simulation%entry(i)%init (process_id(i), &
use_process, integrate, generate, &
simulation%update_sqme, &
simulation%support_resonance_history, &
local, global, simulation%n_alt)
if (signal_is_pending ()) return
end do
simulation%valid = any (simulation%entry%valid)
if (.not. simulation%valid) then
call msg_error ("Simulate: no process has a valid matrix element.")
return
end if
call simulation%update_processes ()
allocate (simulation%alt_entry (simulation%n_prc, simulation%n_alt))
allocate (simulation%md5sum_alt (simulation%n_alt))
simulation%md5sum_alt = ""
do j = 1, simulation%n_alt
do i = 1, simulation%n_prc
call simulation%alt_entry(i,j)%init_alt (process_id(i), &
simulation%entry(i)%get_process_ptr (), alt_env(j))
if (signal_is_pending ()) return
end do
end do
call simulation%restore_processes ()
else
do i = 1, simulation%n_prc
call simulation%entry(i)%init &
(process_id(i), &
use_process, integrate, generate, &
simulation%update_sqme, &
simulation%support_resonance_history, &
local, global)
call simulation%entry(i)%determine_if_powheg_matching ()
if (signal_is_pending ()) return
if (simulation%entry(i)%is_nlo ()) &
call simulation%entry(i)%setup_additional_entries ()
end do
simulation%valid = any (simulation%entry%valid)
if (.not. simulation%valid) then
call msg_error ("Simulate: " &
// "no process has a valid matrix element.")
return
end if
end if
!!! if this becomes conditional, some ref files will need update (seed change)
! if (generate) then
call dispatch_rng_factory (rng_factory, local%var_list, next_rng_seed)
call update_rng_seed_in_var_list (local%var_list, next_rng_seed)
call rng_factory%make (simulation%rng)
<<Simulations: simulation init: extra RNG init>>
! end if
if (all (simulation%entry%has_integral)) then
simulation%integral = sum (simulation%entry%integral)
simulation%error = sqrt (sum (simulation%entry%error ** 2))
simulation%has_integral = .true.
if (integrate .and. generate) then
do i = 1, simulation%n_prc
if (simulation%entry(i)%integral < 0 .and. .not. &
simulation%negative_weights) then
call msg_fatal ("Integral of process '" // &
char (process_id (i)) // "'is negative.")
end if
end do
end if
else
if (integrate .and. generate) &
call msg_error ("Simulation contains undefined integrals.")
end if
if (simulation%integral > 0 .or. &
(simulation%integral < 0 .and. simulation%negative_weights)) then
simulation%valid = .true.
else if (generate) then
call msg_error ("Simulate: " &
// "sum of process integrals must be positive; skipping.")
simulation%valid = .false.
else
simulation%valid = .true.
end if
if (simulation%sample_id == "") then
simulation%sample_id = simulation%get_default_sample_name ()
end if
simulation%sample_id = simulation%sample_id // sample_suffix
if (simulation%valid) call simulation%compute_md5sum ()
end subroutine simulation_init
@ %def simulation_init
@ The RNG initialization depends on serial/MPI mode.
<<Simulations: simulation init: extra variables>>=
<<MPI: Simulations: simulation init: extra variables>>=
integer :: rank, n_size
<<Simulations: simulation init: extra init>>=
<<MPI: Simulations: simulation init: extra init>>=
call mpi_get_comm_id (n_size, rank)
if (n_size > 1) then
sample_suffix = var_str ("_") // str (rank)
end if
<<Simulations: simulation init: extra RNG init>>=
<<MPI: Simulations: simulation init: extra RNG init>>=
do i = 2, rank + 1
select type (rng => simulation%rng)
type is (rng_stream_t)
call rng%next_substream ()
if (i == rank) &
call msg_message ("Simulate: Advance RNG for parallel event generation")
class default
call rng%write ()
call msg_bug ("Parallel event generation: random-number generator &
&must be 'rng_stream'.")
end select
end do
@ The number of events that we want to simulate is determined by the
settings of [[n_events]], [[luminosity]], and [[?unweighted]]. For
weighted events, we take [[n_events]] at face value as the number of
matrix element calls. For unweighted events, if the process is a
decay, [[n_events]] is the number of unweighted events. In these
cases, the luminosity setting is ignored.
For unweighted events with a scattering process, we calculate the
event number that corresponds to the luminosity, given the current
value of the integral. We then compare this with [[n_events]] and
choose the larger number.
<<Simulations: simulation: TBP>>=
procedure :: compute_n_events => simulation_compute_n_events
<<Simulations: procedures>>=
subroutine simulation_compute_n_events (simulation, n_events)
class(simulation_t), intent(in) :: simulation
integer, intent(out) :: n_events
real(default) :: lumi, x_events_lumi
integer :: n_events_lumi
logical :: is_scattering
n_events = &
simulation%local%get_ival (var_str ("n_events"))
lumi = &
simulation%local%get_rval (var_str ("luminosity"))
if (simulation%unweighted) then
is_scattering = simulation%entry(1)%n_in == 2
if (is_scattering) then
x_events_lumi = abs (simulation%integral * lumi)
if (x_events_lumi < huge (n_events)) then
n_events_lumi = nint (x_events_lumi)
else
call msg_message ("Simulation: luminosity too large, &
&limiting number of events")
n_events_lumi = huge (n_events)
end if
if (n_events_lumi > n_events) then
call msg_message ("Simulation: using n_events as computed from &
&luminosity value")
n_events = n_events_lumi
else
write (msg_buffer, "(A,1x,I0)") &
"Simulation: requested number of events =", n_events
call msg_message ()
if (.not. vanishes (simulation%integral)) then
write (msg_buffer, "(A,1x,ES11.4)") &
" corr. to luminosity [fb-1] = ", &
n_events / simulation%integral
call msg_message ()
end if
end if
end if
end if
end subroutine simulation_compute_n_events
@ %def simulation_compute_n_events
@ Configuration of the OpenMP parameters, in case OpenMP is active. We use
the settings accessible via the local environment.
<<Simulations: simulation: TBP>>=
procedure :: setup_openmp => simulation_setup_openmp
<<Simulations: procedures>>=
subroutine simulation_setup_openmp (simulation)
class(simulation_t), intent(inout) :: simulation
call openmp_set_num_threads_verbose &
(simulation%local%get_ival (var_str ("openmp_num_threads")), &
simulation%local%get_lval (var_str ("?openmp_logging")))
end subroutine simulation_setup_openmp
@ %def simulation_setup_openmp
@ Configuration of the event-stream array -- i.e., the setup of
output file formats.
<<Simulations: simulation: TBP>>=
procedure :: prepare_event_streams => simulation_prepare_event_streams
<<Simulations: procedures>>=
subroutine simulation_prepare_event_streams (sim, es_array)
class(simulation_t), intent(inout) :: sim
type(event_stream_array_t), intent(out) :: es_array
integer :: n_events
logical :: rebuild_events, read_raw, write_raw
integer :: checkpoint, callback
integer :: n_fmt
type(event_sample_data_t) :: data
type(string_t), dimension(:), allocatable :: sample_fmt
n_events = &
sim%n_evt_requested
rebuild_events = &
sim%local%get_lval (var_str ("?rebuild_events"))
read_raw = &
sim%local%get_lval (var_str ("?read_raw")) .and. .not. rebuild_events
write_raw = &
sim%local%get_lval (var_str ("?write_raw"))
checkpoint = &
sim%local%get_ival (var_str ("checkpoint"))
callback = &
sim%local%get_ival (var_str ("event_callback_interval"))
if (read_raw) then
inquire (file = char (sim%sample_id) // ".evx", exist = read_raw)
end if
if (allocated (sim%local%sample_fmt)) then
n_fmt = size (sim%local%sample_fmt)
else
n_fmt = 0
end if
data = sim%get_data ()
data%n_evt = n_events
data%nlo_multiplier = sim%get_n_nlo_entries (1)
if (read_raw) then
allocate (sample_fmt (n_fmt))
if (n_fmt > 0) sample_fmt = sim%local%sample_fmt
call es_array%init (sim%sample_id, &
sample_fmt, sim%local, &
data = data, &
input = var_str ("raw"), &
allow_switch = write_raw, &
checkpoint = checkpoint, &
callback = callback)
else if (write_raw) then
allocate (sample_fmt (n_fmt + 1))
if (n_fmt > 0) sample_fmt(:n_fmt) = sim%local%sample_fmt
sample_fmt(n_fmt+1) = var_str ("raw")
call es_array%init (sim%sample_id, &
sample_fmt, sim%local, &
data = data, &
checkpoint = checkpoint, &
callback = callback)
else if (allocated (sim%local%sample_fmt) &
.or. checkpoint > 0 &
.or. callback > 0) then
allocate (sample_fmt (n_fmt))
if (n_fmt > 0) sample_fmt = sim%local%sample_fmt
call es_array%init (sim%sample_id, &
sample_fmt, sim%local, &
data = data, &
checkpoint = checkpoint, &
callback = callback)
end if
end subroutine simulation_prepare_event_streams
@ %def simulation_prepare_event_streams
@
<<Simulations: simulation: TBP>>=
procedure :: get_n_nlo_entries => simulation_get_n_nlo_entries
<<Simulations: procedures>>=
function simulation_get_n_nlo_entries (simulation, i_prc) result (n_extra)
class(simulation_t), intent(in) :: simulation
integer, intent(in) :: i_prc
integer :: n_extra
n_extra = simulation%entry(i_prc)%count_nlo_entries ()
end function simulation_get_n_nlo_entries
@ %def simulation_get_n_nlo_entries
@ Initialize the process selector, using the entry integrals as process
weights.
<<Simulations: simulation: TBP>>=
procedure :: init_process_selector => simulation_init_process_selector
<<Simulations: procedures>>=
subroutine simulation_init_process_selector (simulation)
class(simulation_t), intent(inout) :: simulation
integer :: i
if (simulation%has_integral) then
call simulation%process_selector%init (simulation%entry%integral, &
negative_weights = simulation%negative_weights)
do i = 1, simulation%n_prc
associate (entry => simulation%entry(i))
if (.not. entry%valid) then
call msg_warning ("Process '" // char (entry%process_id) // &
"': matrix element vanishes, no events can be generated.")
cycle
end if
call entry%init_mci_selector (simulation%negative_weights)
entry%process_weight = simulation%process_selector%get_weight (i)
end associate
end do
end if
end subroutine simulation_init_process_selector
@ %def simulation_init_process_selector
@ Select a process, using the random-number generator.
<<Simulations: simulation: TBP>>=
procedure :: select_prc => simulation_select_prc
<<Simulations: procedures>>=
function simulation_select_prc (simulation) result (i_prc)
class(simulation_t), intent(inout) :: simulation
integer :: i_prc
call simulation%process_selector%generate (simulation%rng, i_prc)
end function simulation_select_prc
@ %def simulation_select_prc
@ Select a MCI set for the selected process.
<<Simulations: simulation: TBP>>=
procedure :: select_mci => simulation_select_mci
<<Simulations: procedures>>=
function simulation_select_mci (simulation) result (i_mci)
class(simulation_t), intent(inout) :: simulation
integer :: i_mci
i_mci = 0
if (simulation%i_prc /= 0) then
i_mci = simulation%entry(simulation%i_prc)%select_mci ()
end if
end function simulation_select_mci
@ %def simulation_select_mci
@
\subsubsection{Generate-event loop}
The requested number of events should be set by this, in time for the
event-array initializers that may use this number.
<<Simulations: simulation: TBP>>=
procedure :: set_n_events_requested => simulation_set_n_events_requested
procedure :: get_n_events_requested => simulation_get_n_events_requested
<<Simulations: procedures>>=
subroutine simulation_set_n_events_requested (simulation, n)
class(simulation_t), intent(inout) :: simulation
integer, intent(in) :: n
simulation%n_evt_requested = n
end subroutine simulation_set_n_events_requested
function simulation_get_n_events_requested (simulation) result (n)
class(simulation_t), intent(in) :: simulation
integer :: n
n = simulation%n_evt_requested
end function simulation_get_n_events_requested
@ %def simulation_set_n_events_requested
@ %def simulation_get_n_events_requested
@ Generate the number of events that has been set by
[[simulation_set_n_events_requested]]. First select a process and a component
set, then generate an event for that process and factorize the quantum state.
The pair of random numbers can be used for factorization.
When generating events, we drop all configurations where the event is
marked as incomplete. This happens if the event fails cuts. In fact,
such events are dropped already by the sampler if unweighting is in
effect, so this can happen only for weighted events. By setting a
limit given by [[sample_max_tries]] (user parameter), we can avoid an
endless loop.
The [[begin_it]] and [[end_it]] limits are equal to 1 and the number of
events, repspectively, in serial mode, but differ for MPI mode.
TODO: When reading from file, event transforms cannot be applied because the
process instance will not be complete. (?)
<<Simulations: simulation: TBP>>=
procedure :: generate => simulation_generate
<<Simulations: procedures>>=
subroutine simulation_generate (simulation, es_array)
class(simulation_t), intent(inout), target :: simulation
type(event_stream_array_t), intent(inout), optional :: es_array
integer :: begin_it, end_it
integer :: i, j, k
call simulation%before_first_event (begin_it, end_it, es_array)
do i = begin_it, end_it
call simulation%next_event (es_array)
end do
call simulation%after_last_event (begin_it, end_it)
end subroutine simulation_generate
@ %def simulation_generate
@ The header of the event loop: with all necessary information present in the
[[simulation]] and [[es_array]] objects, and given a number of events [[n]] to
generate, we prepare for actually generating/reading/writing events.
The procedure returns the real iteration bounds [[begin_it]] and [[end_it]]
for the event loop. This is nontrivial only for MPI; in serial mode those are
equal to 1 and to [[n_events]], respectively.
<<Simulations: simulation: TBP>>=
procedure :: before_first_event => simulation_before_first_event
<<Simulations: procedures>>=
subroutine simulation_before_first_event (simulation, begin_it, end_it, &
es_array)
class(simulation_t), intent(inout), target :: simulation
integer, intent(out) :: begin_it
integer, intent(out) :: end_it
type(event_stream_array_t), intent(inout), optional :: es_array
integer :: n_evt_requested
logical :: has_input
integer :: n_events_print
logical :: is_leading_order
logical :: is_weighted
logical :: is_polarized
n_evt_requested = simulation%n_evt_requested
n_events_print = n_evt_requested * simulation%get_n_nlo_entries (1)
is_leading_order = (n_events_print == n_evt_requested)
has_input = .false.
if (present (es_array)) has_input = es_array%has_input ()
is_weighted = .not. simulation%entry(1)%config%unweighted
is_polarized = simulation%entry(1)%config%factorization_mode &
/= FM_IGNORE_HELICITY
call simulation%startup_message_generate ( &
has_input = has_input, &
is_weighted = is_weighted, &
is_polarized = is_polarized, &
is_leading_order = is_leading_order, &
n_events = n_events_print)
call simulation%entry%set_n (n_evt_requested)
if (simulation%n_alt > 0) call simulation%alt_entry%set_n (n_evt_requested)
call simulation%init_event_index ()
begin_it = 1
end_it = n_evt_requested
<<Simulations: simulation generate: extra init>>
end subroutine simulation_before_first_event
@ %def simulation_before_first_event
@ Keep the user informed:
<<Simulations: simulation: TBP>>=
procedure, private :: startup_message_generate &
=> simulation_startup_message_generate
<<Simulations: procedures>>=
subroutine simulation_startup_message_generate (simulation, &
has_input, is_weighted, is_polarized, is_leading_order, n_events)
class(simulation_t), intent(in) :: simulation
logical, intent(in) :: has_input
logical, intent(in) :: is_weighted
logical, intent(in) :: is_polarized
logical, intent(in) :: is_leading_order
integer, intent(in) :: n_events
type(string_t) :: str1, str2, str3, str4
if (has_input) then
str1 = "Events: reading"
else
str1 = "Events: generating"
end if
if (is_weighted) then
str2 = "weighted"
else
str2 = "unweighted"
end if
if (is_polarized) then
str3 = ", polarized"
else
str3 = ", unpolarized"
end if
str4 = ""
if (.not. is_leading_order) str4 = " NLO"
write (msg_buffer, "(A,1X,I0,1X,A,1X,A)") char (str1), n_events, &
char (str2) // char(str3) // char(str4), "events ..."
call msg_message ()
write (msg_buffer, "(A,1x,A)") "Events: event normalization mode", &
char (event_normalization_string (simulation%norm_mode))
call msg_message ()
end subroutine simulation_startup_message_generate
@ %def simulation_startup_message_generate
@
The body of the event loop: generate and process a single event.
Optionally transfer the current event to one of the provided event handles,
for in and/or output streams. This works for any stream for which the I/O
stream type matches the event-handle type.
<<Simulations: simulation: TBP>>=
procedure :: next_event => simulation_next_event
<<Simulations: procedures>>=
subroutine simulation_next_event &
(simulation, es_array, event_handle_out, event_handle_in)
class(simulation_t), intent(inout) :: simulation
type(event_stream_array_t), intent(inout), optional :: es_array
class(event_handle_t), intent(inout), optional :: event_handle_out
class(event_handle_t), intent(inout), optional :: event_handle_in
type(entry_t), pointer :: current_entry
logical :: generate_new
logical :: passed
integer :: j, k
call simulation%increment_event_index ()
if (present (es_array)) then
call simulation%read_event &
(es_array, .true., generate_new, event_handle_in)
else
generate_new = .true.
end if
if (generate_new) then
simulation%i_prc = simulation%select_prc ()
simulation%i_mci = simulation%select_mci ()
associate (entry => simulation%entry(simulation%i_prc))
entry%instance%i_mci = simulation%i_mci
call entry%set_active_real_components ()
current_entry => entry%get_first ()
do k = 1, current_entry%count_nlo_entries ()
if (k > 1) then
current_entry => current_entry%get_next ()
current_entry%particle_set => current_entry%first%particle_set
current_entry%particle_set_is_valid &
= current_entry%first%particle_set_is_valid
end if
do j = 1, simulation%n_max_tries
if (.not. current_entry%valid) call msg_warning &
("Process '" // char (current_entry%process_id) // "': " // &
"matrix element vanishes, no events can be generated.")
call current_entry%generate (simulation%i_mci, i_nlo = k)
if (signal_is_pending ()) return
call simulation%counter%record_mean_and_variance &
(current_entry%weight_prc, k)
if (current_entry%has_valid_particle_set ()) exit
end do
end do
if (entry%is_nlo ()) call entry%reset_nlo_counter ()
if (.not. entry%has_valid_particle_set ()) then
write (msg_buffer, "(A,I0,A)") "Simulation: failed to &
&generate valid event after ", &
simulation%n_max_tries, " tries (sample_max_tries)"
call msg_fatal ()
end if
current_entry => entry%get_first ()
do k = 1, current_entry%count_nlo_entries ()
if (k > 1) current_entry => current_entry%get_next ()
call current_entry%set_index (simulation%get_event_index ())
call current_entry%evaluate_expressions ()
end do
if (signal_is_pending ()) return
simulation%n_dropped = entry%get_n_dropped ()
if (entry%passed_selection ()) then
simulation%weight = entry%get_weight_ref ()
simulation%excess = entry%get_excess_prc ()
end if
call simulation%counter%record &
(simulation%weight, simulation%excess, simulation%n_dropped)
call entry%record (simulation%i_mci)
end associate
else
associate (entry => simulation%entry(simulation%i_prc))
call simulation%set_event_index (entry%get_index ())
call entry%accept_sqme_ref ()
call entry%accept_weight_ref ()
call entry%check ()
call entry%evaluate_expressions ()
if (signal_is_pending ()) return
simulation%n_dropped = entry%get_n_dropped ()
if (entry%passed_selection ()) then
simulation%weight = entry%get_weight_ref ()
simulation%excess = entry%get_excess_prc ()
end if
call simulation%counter%record &
(simulation%weight, simulation%excess, simulation%n_dropped, &
from_file=.true.)
call entry%record (simulation%i_mci, from_file=.true.)
end associate
end if
call simulation%calculate_alt_entries ()
if (simulation%pacify) call pacify (simulation)
if (signal_is_pending ()) return
if (simulation%respect_selection) then
passed = simulation%entry(simulation%i_prc)%passed_selection ()
else
passed = .true.
end if
if (present (es_array)) then
call simulation%write_event (es_array, passed, event_handle_out)
end if
end subroutine simulation_next_event
@ %def simulation_next_event
@ Cleanup after last event: compute and show summary information.
<<Simulations: simulation: TBP>>=
procedure :: after_last_event => simulation_after_last_event
<<Simulations: procedures>>=
subroutine simulation_after_last_event (simulation, begin_it, end_it)
class(simulation_t), intent(inout) :: simulation
integer, intent(in) :: begin_it, end_it
call msg_message (" ... event sample complete.")
<<Simulations: simulation generate: extra finalize>>
if (simulation%unweighted) call simulation%show_efficiency ()
call simulation%counter%show_excess ()
call simulation%counter%show_dropped ()
call simulation%counter%show_mean_and_variance ()
end subroutine simulation_after_last_event
@ %def simulation_after_last_event
@
\subsubsection{MPI additions}
Below, we define code chunks that differ between the serial and MPI versions.
Extra logging for MPI only.
<<Simulations: simulation: TBP>>=
procedure :: activate_extra_logging => simulation_activate_extra_logging
<<Simulations: procedures>>=
subroutine simulation_activate_extra_logging (simulation)
class(simulation_t), intent(in) :: simulation
<<Simulations: activate extra logging>>
end subroutine simulation_activate_extra_logging
<<Simulations: activate extra logging>>=
<<MPI: Simulations: activate extra logging>>=
logical :: mpi_logging
integer :: rank, n_size
call mpi_get_comm_id (n_size, rank)
mpi_logging = &
(simulation%local%get_sval (var_str ("$integration_method")) == "vamp2" &
.and. n_size > 1) &
.or. simulation%local%get_lval (var_str ("?mpi_logging"))
call mpi_set_logging (mpi_logging)
@ %def simulation_activate_extra_logging
@
Extra subroutine to be called before the first event:
<<Simulations: simulation generate: extra init>>=
<<MPI: Simulations: simulation generate: extra init>>=
call simulation%init_event_loop_mpi (n_evt_requested, begin_it, end_it)
@
Extra subroutine to be called after the last event:
<<Simulations: simulation generate: extra finalize>>=
<<MPI: Simulations: simulation generate: extra finalize>>=
call simulation%final_event_loop_mpi (begin_it, end_it)
@
For MPI event generation, the event-loop interval (1\dots n) is split up
into intervals of [[n_workers]].
<<MPI: Simulations: simulation: TBP>>=
procedure, private :: init_event_loop_mpi => simulation_init_event_loop_mpi
<<MPI: Simulations: procedures>>=
subroutine simulation_init_event_loop_mpi &
(simulation, n_events, begin_it, end_it)
class(simulation_t), intent(inout) :: simulation
integer, intent(in) :: n_events
integer, intent(out) :: begin_it, end_it
integer :: rank, n_workers
call MPI_COMM_SIZE (MPI_COMM_WORLD, n_workers)
if (n_workers < 2) then
begin_it = 1; end_it = n_events
return
end if
call MPI_COMM_RANK (MPI_COMM_WORLD, rank)
if (rank == 0) then
call compute_and_scatter_intervals (n_events, begin_it, end_it)
else
call retrieve_intervals (begin_it, end_it)
end if
!! Event index starts by 0 (before incrementing when the first event gets generated/read in).
!! Proof: event_index_offset in [0, N], start_it in [1, N].
simulation%event_index_offset = simulation%event_index_offset + (begin_it - 1)
call simulation%init_event_index ()
write (msg_buffer, "(A,I0,A,I0,A)") &
& "MPI: generate events [", begin_it, ":", end_it, "]"
call msg_message ()
contains
subroutine compute_and_scatter_intervals (n_events, begin_it, end_it)
integer, intent(in) :: n_events
integer, intent(out) :: begin_it, end_it
integer, dimension(:), allocatable :: all_begin_it, all_end_it
integer :: rank, n_workers, n_events_per_worker
call MPI_COMM_RANK (MPI_COMM_WORLD, rank)
call MPI_COMM_SIZE (MPI_COMM_WORLD, n_workers)
allocate (all_begin_it (n_workers), source = 1)
allocate (all_end_it (n_workers), source = n_events)
n_events_per_worker = floor (real (n_events, default) / n_workers)
all_begin_it = [(1 + rank * n_events_per_worker, rank = 0, n_workers - 1)]
all_end_it = [(rank * n_events_per_worker, rank = 1, n_workers)]
all_end_it(n_workers) = n_events
call MPI_SCATTER (all_begin_it, 1, MPI_INTEGER, begin_it, 1, MPI_INTEGER, 0, MPI_COMM_WORLD)
call MPI_SCATTER (all_end_it, 1, MPI_INTEGER, end_it, 1, MPI_INTEGER, 0, MPI_COMM_WORLD)
end subroutine compute_and_scatter_intervals
subroutine retrieve_intervals (begin_it, end_it)
integer, intent(out) :: begin_it, end_it
integer :: local_begin_it, local_end_it
call MPI_SCATTER (local_begin_it, 1, MPI_INTEGER, begin_it, 1, MPI_INTEGER, 0, MPI_COMM_WORLD)
call MPI_SCATTER (local_end_it, 1, MPI_INTEGER, end_it, 1, MPI_INTEGER, 0, MPI_COMM_WORLD)
end subroutine retrieve_intervals
end subroutine simulation_init_event_loop_mpi
@ %def simulation_init_event_loop_mpi
@
Synchronize, reduce and collect stuff after the event loop has completed.
<<MPI: Simulations: simulation: TBP>>=
procedure, private :: final_event_loop_mpi => simulation_final_event_loop_mpi
<<MPI: Simulations: procedures>>=
subroutine simulation_final_event_loop_mpi (simulation, begin_it, end_it)
class(simulation_t), intent(inout) :: simulation
integer, intent(in) :: begin_it, end_it
integer :: n_workers, n_events_local, n_events_global
call MPI_Barrier (MPI_COMM_WORLD)
call MPI_COMM_SIZE (MPI_COMM_WORLD, n_workers)
if (n_workers < 2) return
n_events_local = end_it - begin_it + 1
call MPI_ALLREDUCE (n_events_local, n_events_global, 1, MPI_INTEGER, MPI_SUM,&
& MPI_COMM_WORLD)
write (msg_buffer, "(2(A,1X,I0))") &
"MPI: Number of generated events locally", n_events_local, " and in world", n_events_global
call msg_message ()
call simulation%counter%allreduce_record ()
end subroutine simulation_final_event_loop_mpi
@ %def simulation_final_event_loop_mpi
@
\subsubsection{Alternate environments}
Compute the event matrix element and weight for all alternative
environments, given the current event and selected process. We first
copy the particle set, then temporarily update the process core with
local parameters, recalculate everything, and restore the process
core.
The event weight is obtained by rescaling the original event weight with the
ratio of the new and old [[sqme]] values. (In particular, if the old
value was zero, the weight will stay zero.)
Note: this may turn out to be inefficient because we always replace
all parameters and recalculate everything, once for each event and
environment. However, a more fine-grained control requires more
code. In any case, while we may keep multiple process cores (which
stay constant for a simulation run), we still have to update the
external matrix element parameters event by event. The matrix element
``object'' is present only once.
<<Simulations: simulation: TBP>>=
procedure :: calculate_alt_entries => simulation_calculate_alt_entries
<<Simulations: procedures>>=
subroutine simulation_calculate_alt_entries (simulation)
class(simulation_t), intent(inout) :: simulation
real(default) :: factor
real(default), dimension(:), allocatable :: sqme_alt, weight_alt
integer :: n_alt, i, j
i = simulation%i_prc
n_alt = simulation%n_alt
if (n_alt == 0) return
allocate (sqme_alt (n_alt), weight_alt (n_alt))
associate (entry => simulation%entry(i))
do j = 1, n_alt
if (signal_is_pending ()) return
factor = entry%get_kinematical_weight ()
associate (alt_entry => simulation%alt_entry(i,j))
call alt_entry%update_process (saved=.false.)
call alt_entry%select &
(entry%get_i_mci (), entry%get_i_term (), entry%get_channel ())
call alt_entry%fill_particle_set (entry)
call alt_entry%recalculate &
(update_sqme = .true., &
recover_beams = simulation%recover_beams, &
weight_factor = factor)
if (signal_is_pending ()) return
call alt_entry%accept_sqme_prc ()
call alt_entry%update_normalization ()
call alt_entry%accept_weight_prc ()
call alt_entry%check ()
call alt_entry%set_index (simulation%get_event_index ())
call alt_entry%evaluate_expressions ()
if (signal_is_pending ()) return
sqme_alt(j) = alt_entry%get_sqme_ref ()
if (alt_entry%passed_selection ()) then
weight_alt(j) = alt_entry%get_weight_ref ()
end if
end associate
end do
call entry%update_process (saved=.false.)
call entry%set (sqme_alt = sqme_alt, weight_alt = weight_alt)
call entry%check ()
call entry%store_alt_values ()
end associate
end subroutine simulation_calculate_alt_entries
@ %def simulation_calculate_alt_entries
@
These routines take care of temporary parameter redefinitions that
we want to take effect while recalculating the matrix elements. We
extract the core(s) of the processes that we are simulating, apply the
changes, and make sure that the changes are actually used. This is
the duty of [[dispatch_core_update]]. When done, we restore the
original versions using [[dispatch_core_restore]].
<<Simulations: simulation: TBP>>=
procedure :: update_processes => simulation_update_processes
procedure :: restore_processes => simulation_restore_processes
<<Simulations: procedures>>=
subroutine simulation_update_processes (simulation, &
model, qcd, helicity_selection)
class(simulation_t), intent(inout) :: simulation
class(model_data_t), intent(in), optional, target :: model
type(qcd_t), intent(in), optional :: qcd
type(helicity_selection_t), intent(in), optional :: helicity_selection
integer :: i
do i = 1, simulation%n_prc
call simulation%entry(i)%update_process &
(model, qcd, helicity_selection)
end do
end subroutine simulation_update_processes
subroutine simulation_restore_processes (simulation)
class(simulation_t), intent(inout) :: simulation
integer :: i
do i = 1, simulation%n_prc
call simulation%entry(i)%restore_process ()
end do
end subroutine simulation_restore_processes
@ %def simulation_update_processes
@ %def simulation_restore_processes
@
\subsubsection{Rescan-Events Loop}
Rescan an undefined number of events.
If [[update_event]] or [[update_sqme]] is set, we have to recalculate the
event, starting from the particle set. If the latter is set, this includes
the squared matrix element (i.e., the amplitude is evaluated). Otherwise,
only kinematics and observables derived from it are recovered.
If any of the update flags is set, we will come up with separate
[[sqme_prc]] and [[weight_prc]] values. (The latter is only distinct
if [[update_weight]] is set.) Otherwise, we accept the reference values.
<<Simulations: simulation: TBP>>=
procedure :: rescan => simulation_rescan
<<Simulations: procedures>>=
subroutine simulation_rescan (simulation, n, es_array, global)
class(simulation_t), intent(inout) :: simulation
integer, intent(in) :: n
type(event_stream_array_t), intent(inout) :: es_array
type(rt_data_t), intent(inout) :: global
type(qcd_t) :: qcd
type(string_t) :: str1, str2, str3
logical :: complete
str1 = "Rescanning"
if (simulation%entry(1)%config%unweighted) then
str2 = "unweighted"
else
str2 = "weighted"
end if
simulation%n_evt_requested = n
call simulation%entry%set_n (n)
if (simulation%update_sqme .or. simulation%update_weight) then
call dispatch_qcd (qcd, global%get_var_list_ptr (), global%os_data)
call simulation%update_processes &
(global%model, qcd, global%get_helicity_selection ())
str3 = "(process parameters updated) "
else
str3 = ""
end if
write (msg_buffer, "(A,1x,A,1x,A,A,A)") char (str1), char (str2), &
"events ", char (str3), "..."
call msg_message ()
call simulation%init_event_index ()
do
call simulation%increment_event_index ()
call simulation%read_event (es_array, .false., complete)
if (complete) exit
if (simulation%update_event &
.or. simulation%update_sqme &
.or. simulation%update_weight) then
call simulation%recalculate ()
if (signal_is_pending ()) return
associate (entry => simulation%entry(simulation%i_prc))
call entry%update_normalization ()
if (simulation%update_event) then
call entry%evaluate_transforms ()
end if
call entry%check ()
call entry%evaluate_expressions ()
if (signal_is_pending ()) return
simulation%n_dropped = entry%get_n_dropped ()
simulation%weight = entry%get_weight_prc ()
call simulation%counter%record &
(simulation%weight, n_dropped=simulation%n_dropped, from_file=.true.)
call entry%record (simulation%i_mci, from_file=.true.)
end associate
else
associate (entry => simulation%entry(simulation%i_prc))
call entry%accept_sqme_ref ()
call entry%accept_weight_ref ()
call entry%check ()
call entry%evaluate_expressions ()
if (signal_is_pending ()) return
simulation%n_dropped = entry%get_n_dropped ()
simulation%weight = entry%get_weight_ref ()
call simulation%counter%record &
(simulation%weight, n_dropped=simulation%n_dropped, from_file=.true.)
call entry%record (simulation%i_mci, from_file=.true.)
end associate
end if
call simulation%calculate_alt_entries ()
if (signal_is_pending ()) return
call simulation%write_event (es_array)
end do
call simulation%counter%show_dropped ()
if (simulation%update_sqme .or. simulation%update_weight) then
call simulation%restore_processes ()
end if
end subroutine simulation_rescan
@ %def simulation_rescan
@
\subsubsection{Event index}
Here we handle the event index that is kept in the simulation record. The
event index is valid for the current sample. When generating or reading
events, we initialize the index with the offset that the user provides (if any)
and increment it for each event that is generated or read from file. The event
index is stored in the event-entry that is current for the event. If an
event on file comes with its own index, that index overwrites the predefined
one and also resets the index within the simulation record.
The event index is not connected to the [[counter]] object. The counter is
supposed to collect statistical information. The event index is a user-level
object that is visible in event records and analysis expressions.
<<Simulations: simulation: TBP>>=
procedure :: init_event_index => simulation_init_event_index
procedure :: increment_event_index => simulation_increment_event_index
procedure :: set_event_index => simulation_set_event_index
procedure :: get_event_index => simulation_get_event_index
<<Simulations: procedures>>=
subroutine simulation_init_event_index (simulation)
class(simulation_t), intent(inout) :: simulation
call simulation%set_event_index (simulation%event_index_offset)
end subroutine simulation_init_event_index
subroutine simulation_increment_event_index (simulation)
class(simulation_t), intent(inout) :: simulation
if (simulation%event_index_set) then
simulation%event_index = simulation%event_index + 1
end if
end subroutine simulation_increment_event_index
subroutine simulation_set_event_index (simulation, i)
class(simulation_t), intent(inout) :: simulation
integer, intent(in) :: i
simulation%event_index = i
simulation%event_index_set = .true.
end subroutine simulation_set_event_index
function simulation_get_event_index (simulation) result (i)
class(simulation_t), intent(in) :: simulation
integer :: i
if (simulation%event_index_set) then
i = simulation%event_index
else
i = 0
end if
end function simulation_get_event_index
@ %def simulation_init_event_index
@ %def simulation_increment_event_index
@ %def simulation_set_event_index
@ %def simulation_get_event_index
@
\subsection{Direct event access}
If we want to retrieve event information, we should expose the currently
selected event [[entry]] within the simulation object. We recall that this is
an extension of the (generic) [[event]] type. Assuming that we will restrict
this to read access, we return a pointer.
<<Simulations: simulation: TBP>>=
procedure :: get_process_index => simulation_get_process_index
procedure :: get_event_ptr => simulation_get_event_ptr
<<Simulations: procedures>>=
function simulation_get_process_index (simulation) result (i_prc)
class(simulation_t), intent(in), target :: simulation
integer :: i_prc
i_prc = simulation%i_prc
end function simulation_get_process_index
function simulation_get_event_ptr (simulation) result (event)
class(simulation_t), intent(in), target :: simulation
class(event_t), pointer :: event
event => simulation%entry(simulation%i_prc)
end function simulation_get_event_ptr
@ %def simulation_get_process_index
@ %def simulation_get_event_ptr
@
\subsection{Event Stream I/O}
Write an event to a generic [[eio]] event stream. The process index
must be selected, or the current index must be available.
<<Simulations: simulation: TBP>>=
generic :: write_event => write_event_eio
procedure :: write_event_eio => simulation_write_event_eio
<<Simulations: procedures>>=
subroutine simulation_write_event_eio (object, eio, i_prc)
class(simulation_t), intent(in) :: object
class(eio_t), intent(inout) :: eio
integer, intent(in), optional :: i_prc
logical :: increased
integer :: current
if (present (i_prc)) then
current = i_prc
else
current = object%i_prc
end if
if (current > 0) then
if (object%split_n_evt > 0 .and. object%counter%total > 1) then
if (mod (object%counter%total, object%split_n_evt) == 1) then
call eio%split_out ()
end if
else if (object%split_n_kbytes > 0) then
call eio%update_split_count (increased)
if (increased) call eio%split_out ()
end if
call eio%output (object%entry(current)%event_t, current, pacify = object%pacify)
else
call msg_fatal ("Simulation: write event: no process selected")
end if
end subroutine simulation_write_event_eio
@ %def simulation_write_event
@
Read an event from a generic [[eio]] event stream. The event stream element
must specify the process within the sample ([[i_prc]]), the MC group for this
process ([[i_mci]]), the selected term ([[i_term]]), the selected MC
integration [[channel]], and the particle set of the event.
We may encounter EOF, which we indicate by storing 0 for the process index
[[i_prc]]. An I/O error will be reported, and we also abort reading.
<<Simulations: simulation: TBP>>=
generic :: read_event => read_event_eio
procedure :: read_event_eio => simulation_read_event_eio
<<Simulations: procedures>>=
subroutine simulation_read_event_eio (object, eio)
class(simulation_t), intent(inout) :: object
class(eio_t), intent(inout) :: eio
integer :: iostat, current
call eio%input_i_prc (current, iostat)
select case (iostat)
case (0)
object%i_prc = current
call eio%input_event (object%entry(current)%event_t, iostat)
end select
select case (iostat)
case (:-1)
object%i_prc = 0
object%i_mci = 0
case (1:)
call msg_error ("Reading events: I/O error, aborting read")
object%i_prc = 0
object%i_mci = 0
case default
object%i_mci = object%entry(current)%get_i_mci ()
end select
end subroutine simulation_read_event_eio
@ %def simulation_read_event
@
\subsection{Event Stream Array}
Write an event using an array of event I/O streams.
The process index must be selected, or the current index must be
available.
<<Simulations: simulation: TBP>>=
generic :: write_event => write_event_es_array
procedure :: write_event_es_array => simulation_write_event_es_array
<<Simulations: procedures>>=
subroutine simulation_write_event_es_array &
(object, es_array, passed, event_handle)
class(simulation_t), intent(in), target :: object
class(event_stream_array_t), intent(inout) :: es_array
logical, intent(in), optional :: passed
class(event_handle_t), intent(inout), optional :: event_handle
integer :: i_prc, event_index
integer :: i
type(entry_t), pointer :: current_entry
i_prc = object%i_prc
if (i_prc > 0) then
event_index = object%counter%total
current_entry => object%entry(i_prc)%get_first ()
do i = 1, current_entry%count_nlo_entries ()
if (i > 1) current_entry => current_entry%get_next ()
call es_array%output (current_entry%event_t, i_prc, &
event_index, &
passed = passed, &
pacify = object%pacify, &
event_handle = event_handle)
end do
else
call msg_fatal ("Simulation: write event: no process selected")
end if
end subroutine simulation_write_event_es_array
@ %def simulation_write_event
@ Read an event using an array of event I/O streams. Reading is
successful if there is an input stream within the array, and if a
valid event can be read from that stream. If there is a stream, but
EOF is passed when reading the first item, we switch the channel to
output and return failure but no error message, such that new events
can be appended to that stream.
<<Simulations: simulation: TBP>>=
generic :: read_event => read_event_es_array
procedure :: read_event_es_array => simulation_read_event_es_array
<<Simulations: procedures>>=
subroutine simulation_read_event_es_array &
(object, es_array, enable_switch, fail, event_handle)
class(simulation_t), intent(inout), target :: object
class(event_stream_array_t), intent(inout), target :: es_array
logical, intent(in) :: enable_switch
logical, intent(out) :: fail
class(event_handle_t), intent(inout), optional :: event_handle
integer :: iostat, i_prc
type(entry_t), pointer :: current_entry => null ()
integer :: i
if (es_array%has_input ()) then
fail = .false.
call es_array%input_i_prc (i_prc, iostat)
select case (iostat)
case (0)
object%i_prc = i_prc
current_entry => object%entry(i_prc)
do i = 1, current_entry%count_nlo_entries ()
if (i > 1) then
call es_array%skip_eio_entry (iostat)
current_entry => current_entry%get_next ()
end if
call current_entry%set_index (object%get_event_index ())
call es_array%input_event &
(current_entry%event_t, iostat, event_handle)
end do
case (:-1)
write (msg_buffer, "(A,1x,I0,1x,A)") &
"... event file terminates after", &
object%counter%read, "events."
call msg_message ()
if (enable_switch) then
call es_array%switch_inout ()
write (msg_buffer, "(A,1x,I0,1x,A)") &
"Generating remaining ", &
object%n_evt_requested - object%counter%read, "events ..."
call msg_message ()
end if
fail = .true.
return
end select
select case (iostat)
case (0)
object%i_mci = object%entry(i_prc)%get_i_mci ()
case default
write (msg_buffer, "(A,1x,I0,1x,A)") &
"Reading events: I/O error, aborting read after", &
object%counter%read, "events."
call msg_error ()
object%i_prc = 0
object%i_mci = 0
fail = .true.
end select
else
fail = .true.
end if
end subroutine simulation_read_event_es_array
@ %def simulation_read_event
@
\subsection{Recover event}
Recalculate the process instance contents, given an event with known particle
set. The indices for MC, term, and channel must be already set. The
[[recalculate]] method of the selected entry will import the result
into [[sqme_prc]] and [[weight_prc]].
If [[recover_phs]] is set (and false), do not attempt any phase-space
calculation. Useful if we need only matrix elements (esp. testing); this flag
is not stored in the simulation record.
<<Simulations: simulation: TBP>>=
procedure :: recalculate => simulation_recalculate
<<Simulations: procedures>>=
subroutine simulation_recalculate (simulation, recover_phs)
class(simulation_t), intent(inout) :: simulation
logical, intent(in), optional :: recover_phs
integer :: i_prc
i_prc = simulation%i_prc
associate (entry => simulation%entry(i_prc))
if (simulation%update_weight) then
call entry%recalculate &
(update_sqme = simulation%update_sqme, &
recover_beams = simulation%recover_beams, &
recover_phs = recover_phs, &
weight_factor = entry%get_kinematical_weight ())
else
call entry%recalculate &
(update_sqme = simulation%update_sqme, &
recover_beams = simulation%recover_beams, &
recover_phs = recover_phs)
end if
end associate
end subroutine simulation_recalculate
@ %def simulation_recalculate
@
\subsection{Extract contents of the simulation object}
Return the MD5 sum that summarizes configuration and integration
(but not the event file). Used for initializing the event streams.
<<Simulations: simulation: TBP>>=
procedure :: get_md5sum_prc => simulation_get_md5sum_prc
procedure :: get_md5sum_cfg => simulation_get_md5sum_cfg
procedure :: get_md5sum_alt => simulation_get_md5sum_alt
<<Simulations: procedures>>=
function simulation_get_md5sum_prc (simulation) result (md5sum)
class(simulation_t), intent(in) :: simulation
character(32) :: md5sum
md5sum = simulation%md5sum_prc
end function simulation_get_md5sum_prc
function simulation_get_md5sum_cfg (simulation) result (md5sum)
class(simulation_t), intent(in) :: simulation
character(32) :: md5sum
md5sum = simulation%md5sum_cfg
end function simulation_get_md5sum_cfg
function simulation_get_md5sum_alt (simulation, i) result (md5sum)
class(simulation_t), intent(in) :: simulation
integer, intent(in) :: i
character(32) :: md5sum
md5sum = simulation%md5sum_alt(i)
end function simulation_get_md5sum_alt
@ %def simulation_get_md5sum_prc
@ %def simulation_get_md5sum_cfg
@
Return data that may be useful for writing event files.
Usually we can refer to a previously integrated process, for which we
can fetch a process pointer. Occasionally, we do not have this because
we are just rescanning an externally generated file without
calculation. For that situation, we generate our local beam data object
using the current enviroment, or, in simple cases, just fetch the
necessary data from the process definition and environment.
<<Simulations: simulation: TBP>>=
procedure :: get_data => simulation_get_data
<<Simulations: procedures>>=
function simulation_get_data (simulation, alt) result (sdata)
class(simulation_t), intent(in) :: simulation
logical, intent(in), optional :: alt
type(event_sample_data_t) :: sdata
type(process_t), pointer :: process
type(beam_data_t), pointer :: beam_data
type(beam_structure_t), pointer :: beam_structure
type(flavor_t), dimension(:), allocatable :: flv
integer :: n, i
logical :: enable_alt, construct_beam_data
real(default) :: sqrts
class(model_data_t), pointer :: model
logical :: decay_rest_frame
type(string_t) :: process_id
enable_alt = .true.; if (present (alt)) enable_alt = alt
if (debug_on) call msg_debug (D_CORE, "simulation_get_data")
if (debug_on) call msg_debug (D_CORE, "alternative setup", enable_alt)
if (enable_alt) then
call sdata%init (simulation%n_prc, simulation%n_alt)
do i = 1, simulation%n_alt
sdata%md5sum_alt(i) = simulation%get_md5sum_alt (i)
end do
else
call sdata%init (simulation%n_prc)
end if
sdata%unweighted = simulation%unweighted
sdata%negative_weights = simulation%negative_weights
sdata%norm_mode = simulation%norm_mode
process => simulation%entry(1)%get_process_ptr ()
if (associated (process)) then
beam_data => process%get_beam_data_ptr ()
construct_beam_data = .false.
else
n = simulation%entry(1)%n_in
sqrts = simulation%local%get_sqrts ()
beam_structure => simulation%local%beam_structure
call beam_structure%check_against_n_in (n, construct_beam_data)
if (construct_beam_data) then
allocate (beam_data)
model => simulation%local%model
decay_rest_frame = &
simulation%local%get_lval (var_str ("?decay_rest_frame"))
call beam_data%init_structure (beam_structure, &
sqrts, model, decay_rest_frame)
else
beam_data => null ()
end if
end if
if (associated (beam_data)) then
n = beam_data%get_n_in ()
sdata%n_beam = n
allocate (flv (n))
flv = beam_data%get_flavor ()
sdata%pdg_beam(:n) = flv%get_pdg ()
sdata%energy_beam(:n) = beam_data%get_energy ()
if (construct_beam_data) deallocate (beam_data)
else
n = simulation%entry(1)%n_in
sdata%n_beam = n
process_id = simulation%entry(1)%process_id
call simulation%local%prclib%get_pdg_in_1 &
(process_id, sdata%pdg_beam(:n))
sdata%energy_beam(:n) = sqrts / n
end if
do i = 1, simulation%n_prc
if (.not. simulation%entry(i)%valid) cycle
process => simulation%entry(i)%get_process_ptr ()
if (associated (process)) then
sdata%proc_num_id(i) = process%get_num_id ()
else
process_id = simulation%entry(i)%process_id
sdata%proc_num_id(i) = simulation%local%prclib%get_num_id (process_id)
end if
if (sdata%proc_num_id(i) == 0) sdata%proc_num_id(i) = i
if (simulation%entry(i)%has_integral) then
sdata%cross_section(i) = simulation%entry(i)%integral
sdata%error(i) = simulation%entry(i)%error
end if
end do
sdata%total_cross_section = sum (sdata%cross_section)
sdata%md5sum_prc = simulation%get_md5sum_prc ()
sdata%md5sum_cfg = simulation%get_md5sum_cfg ()
if (simulation%split_n_evt > 0 .or. simulation%split_n_kbytes > 0) then
sdata%split_n_evt = simulation%split_n_evt
sdata%split_n_kbytes = simulation%split_n_kbytes
sdata%split_index = simulation%split_index
end if
end function simulation_get_data
@ %def simulation_get_data
@ Return a default name for the current event sample. This is the
process ID of the first process.
<<Simulations: simulation: TBP>>=
procedure :: get_default_sample_name => simulation_get_default_sample_name
<<Simulations: procedures>>=
function simulation_get_default_sample_name (simulation) result (sample)
class(simulation_t), intent(in) :: simulation
type(string_t) :: sample
type(process_t), pointer :: process
sample = "whizard"
if (simulation%n_prc > 0) then
process => simulation%entry(1)%get_process_ptr ()
if (associated (process)) then
sample = process%get_id ()
end if
end if
end function simulation_get_default_sample_name
@ %def simulation_get_default_sample_name
@
<<Simulations: simulation: TBP>>=
procedure :: is_valid => simulation_is_valid
<<Simulations: procedures>>=
function simulation_is_valid (simulation) result (valid)
class(simulation_t), intent(inout) :: simulation
logical :: valid
valid = simulation%valid
end function simulation_is_valid
@ %def simulation_is_valid
@
Return the hard-interaction particle set for event entry [[i_prc]].
<<Simulations: simulation: TBP>>=
procedure :: get_hard_particle_set => simulation_get_hard_particle_set
<<Simulations: procedures>>=
function simulation_get_hard_particle_set (simulation, i_prc) result (pset)
class(simulation_t), intent(in) :: simulation
integer, intent(in) :: i_prc
type(particle_set_t) :: pset
call simulation%entry(i_prc)%get_hard_particle_set (pset)
end function simulation_get_hard_particle_set
@ %def simulation_get_hard_particle_set
@
\subsection{Auxiliary}
Call pacify: eliminate numerical noise.
<<Simulations: public>>=
public :: pacify
<<Simulations: interfaces>>=
interface pacify
module procedure pacify_simulation
end interface
<<Simulations: procedures>>=
subroutine pacify_simulation (simulation)
class(simulation_t), intent(inout) :: simulation
integer :: i, j
i = simulation%i_prc
if (i > 0) then
call pacify (simulation%entry(i))
do j = 1, simulation%n_alt
call pacify (simulation%alt_entry(i,j))
end do
end if
end subroutine pacify_simulation
@ %def pacify_simulation
@ Manually evaluate expressions for the currently selected process.
This is used only in the unit tests.
<<Simulations: simulation: TBP>>=
procedure :: evaluate_expressions => simulation_evaluate_expressions
<<Simulations: procedures>>=
subroutine simulation_evaluate_expressions (simulation)
class(simulation_t), intent(inout) :: simulation
call simulation%entry(simulation%i_prc)%evaluate_expressions ()
end subroutine simulation_evaluate_expressions
@ %def simulation_evaluate_expressions
@ Manually evaluate event transforms for the currently selected
process. This is used only in the unit tests.
<<Simulations: simulation: TBP>>=
procedure :: evaluate_transforms => simulation_evaluate_transforms
<<Simulations: procedures>>=
subroutine simulation_evaluate_transforms (simulation)
class(simulation_t), intent(inout) :: simulation
associate (entry => simulation%entry(simulation%i_prc))
call entry%evaluate_transforms ()
end associate
end subroutine simulation_evaluate_transforms
@ %def simulation_evaluate_transforms
@
\subsection{Unit tests}
Test module, followed by the stand-alone unit-test procedures.
<<[[simulations_ut.f90]]>>=
<<File header>>
module simulations_ut
use unit_tests
use simulations_uti
<<Standard module head>>
<<Simulations: public test>>
contains
<<Simulations: test driver>>
end module simulations_ut
@ %def simulations_ut
@
<<[[simulations_uti.f90]]>>=
<<File header>>
module simulations_uti
<<Use kinds>>
use kinds, only: i64
<<Use strings>>
use io_units
use format_defs, only: FMT_10, FMT_12
use ifiles
use lexers
use parser
use lorentz
use flavors
use interactions, only: reset_interaction_counter
use process_libraries, only: process_library_t
use prclib_stacks
use phs_forests
use event_base, only: generic_event_t
use event_base, only: event_callback_t
use particles, only: particle_set_t
use eio_data
use eio_base
use eio_direct, only: eio_direct_t
use eio_raw
use eio_ascii
use eio_dump
use eio_callback
use eval_trees
use model_data, only: model_data_t
use models
use rt_data
use event_streams
use decays_ut, only: prepare_testbed
use process, only: process_t
use process_stacks, only: process_entry_t
use process_configurations_ut, only: prepare_test_library
use compilations, only: compile_library
use integrations, only: integrate_process
use simulations
use restricted_subprocesses_uti, only: prepare_resonance_test_library
<<Standard module head>>
<<Simulations: test declarations>>
<<Simulations: test auxiliary types>>
contains
<<Simulations: tests>>
<<Simulations: test auxiliary>>
end module simulations_uti
@ %def simulations_uti
@ API: driver for the unit tests below.
<<Simulations: public test>>=
public :: simulations_test
<<Simulations: test driver>>=
subroutine simulations_test (u, results)
integer, intent(in) :: u
type(test_results_t), intent(inout) :: results
<<Simulations: execute tests>>
end subroutine simulations_test
@ %def simulations_test
@
\subsubsection{Initialization}
Initialize a [[simulation_t]] object, including the embedded event records.
<<Simulations: execute tests>>=
call test (simulations_1, "simulations_1", &
"initialization", &
u, results)
<<Simulations: test declarations>>=
public :: simulations_1
<<Simulations: tests>>=
subroutine simulations_1 (u)
integer, intent(in) :: u
type(string_t) :: libname, procname1, procname2
type(rt_data_t), target :: global
type(simulation_t), target :: simulation
write (u, "(A)") "* Test output: simulations_1"
write (u, "(A)") "* Purpose: initialize simulation"
write (u, "(A)")
write (u, "(A)") "* Initialize processes"
write (u, "(A)")
call syntax_model_file_init ()
call global%global_init ()
call global%set_log (var_str ("?omega_openmp"), &
.false., is_known = .true.)
call global%set_int (var_str ("seed"), &
0, is_known = .true.)
libname = "simulation_1a"
procname1 = "simulation_1p"
call prepare_test_library (global, libname, 1, [procname1])
call compile_library (libname, global)
call global%set_string (var_str ("$method"), &
var_str ("unit_test"), is_known = .true.)
call global%set_string (var_str ("$phs_method"), &
var_str ("single"), is_known = .true.)
call global%set_string (var_str ("$integration_method"),&
var_str ("midpoint"), is_known = .true.)
call global%set_log (var_str ("?vis_history"),&
.false., is_known = .true.)
call global%set_log (var_str ("?integration_timer"),&
.false., is_known = .true.)
call global%set_log (var_str ("?recover_beams"), &
.false., is_known = .true.)
call global%set_real (var_str ("sqrts"),&
1000._default, is_known = .true.)
call global%it_list%init ([1], [1000])
call global%set_string (var_str ("$run_id"), &
var_str ("simulations1"), is_known = .true.)
call integrate_process (procname1, global, local_stack=.true.)
procname2 = "sim_extra"
call prepare_test_library (global, libname, 1, [procname2])
call compile_library (libname, global)
call global%set_string (var_str ("$run_id"), &
var_str ("simulations2"), is_known = .true.)
write (u, "(A)") "* Initialize event generation"
write (u, "(A)")
call global%set_string (var_str ("$sample"), &
var_str ("sim1"), is_known = .true.)
call integrate_process (procname2, global, local_stack=.true.)
call simulation%init ([procname1, procname2], .false., .true., global)
call simulation%init_process_selector ()
call simulation%write (u)
write (u, "(A)")
write (u, "(A)") "* Write the event record for the first process"
write (u, "(A)")
call simulation%write_event (u, i_prc = 1)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call simulation%final ()
call global%final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: simulations_1"
end subroutine simulations_1
@ %def simulations_1
@
\subsubsection{Weighted events}
Generate events for a single process.
<<Simulations: execute tests>>=
call test (simulations_2, "simulations_2", &
"weighted events", &
u, results)
<<Simulations: test declarations>>=
public :: simulations_2
<<Simulations: tests>>=
subroutine simulations_2 (u)
integer, intent(in) :: u
type(string_t) :: libname, procname1
type(rt_data_t), target :: global
type(simulation_t), target :: simulation
type(event_sample_data_t) :: data
write (u, "(A)") "* Test output: simulations_2"
write (u, "(A)") "* Purpose: generate events for a single process"
write (u, "(A)")
write (u, "(A)") "* Initialize processes"
write (u, "(A)")
call syntax_model_file_init ()
call global%global_init ()
call global%set_log (var_str ("?omega_openmp"), &
.false., is_known = .true.)
call global%set_int (var_str ("seed"), &
0, is_known = .true.)
libname = "simulation_2a"
procname1 = "simulation_2p"
call prepare_test_library (global, libname, 1, [procname1])
call compile_library (libname, global)
call global%append_log (&
var_str ("?rebuild_events"), .true., intrinsic = .true.)
call global%set_string (var_str ("$method"), &
var_str ("unit_test"), is_known = .true.)
call global%set_string (var_str ("$phs_method"), &
var_str ("single"), is_known = .true.)
call global%set_string (var_str ("$integration_method"),&
var_str ("midpoint"), is_known = .true.)
call global%set_log (var_str ("?vis_history"),&
.false., is_known = .true.)
call global%set_log (var_str ("?integration_timer"),&
.false., is_known = .true.)
call global%set_log (var_str ("?recover_beams"), &
.false., is_known = .true.)
call global%set_real (var_str ("sqrts"),&
1000._default, is_known = .true.)
call global%it_list%init ([1], [1000])
call global%set_string (var_str ("$run_id"), &
var_str ("simulations1"), is_known = .true.)
call integrate_process (procname1, global, local_stack=.true.)
write (u, "(A)") "* Initialize event generation"
write (u, "(A)")
call global%set_log (var_str ("?unweighted"), &
.false., is_known = .true.)
call simulation%init ([procname1], .true., .true., global)
call simulation%init_process_selector ()
data = simulation%get_data ()
call data%write (u)
write (u, "(A)")
write (u, "(A)") "* Generate three events"
write (u, "(A)")
call simulation%set_n_events_requested (3)
call simulation%generate ()
call simulation%write (u)
write (u, "(A)")
write (u, "(A)") "* Write the event record for the last event"
write (u, "(A)")
call simulation%write_event (u)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call simulation%final ()
call global%final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: simulations_2"
end subroutine simulations_2
@ %def simulations_2
@
\subsubsection{Unweighted events}
Generate events for a single process.
<<Simulations: execute tests>>=
call test (simulations_3, "simulations_3", &
"unweighted events", &
u, results)
<<Simulations: test declarations>>=
public :: simulations_3
<<Simulations: tests>>=
subroutine simulations_3 (u)
integer, intent(in) :: u
type(string_t) :: libname, procname1
type(rt_data_t), target :: global
type(simulation_t), target :: simulation
type(event_sample_data_t) :: data
write (u, "(A)") "* Test output: simulations_3"
write (u, "(A)") "* Purpose: generate unweighted events &
&for a single process"
write (u, "(A)")
write (u, "(A)") "* Initialize processes"
write (u, "(A)")
call syntax_model_file_init ()
call global%global_init ()
call global%set_log (var_str ("?omega_openmp"), &
.false., is_known = .true.)
call global%set_int (var_str ("seed"), &
0, is_known = .true.)
libname = "simulation_3a"
procname1 = "simulation_3p"
call prepare_test_library (global, libname, 1, [procname1])
call compile_library (libname, global)
call global%append_log (&
var_str ("?rebuild_events"), .true., intrinsic = .true.)
call global%set_string (var_str ("$method"), &
var_str ("unit_test"), is_known = .true.)
call global%set_string (var_str ("$phs_method"), &
var_str ("single"), is_known = .true.)
call global%set_string (var_str ("$integration_method"),&
var_str ("midpoint"), is_known = .true.)
call global%set_log (var_str ("?vis_history"),&
.false., is_known = .true.)
call global%set_log (var_str ("?integration_timer"),&
.false., is_known = .true.)
call global%set_log (var_str ("?recover_beams"), &
.false., is_known = .true.)
call global%set_real (var_str ("sqrts"),&
1000._default, is_known = .true.)
call global%it_list%init ([1], [1000])
call global%set_string (var_str ("$run_id"), &
var_str ("simulations1"), is_known = .true.)
call integrate_process (procname1, global, local_stack=.true.)
write (u, "(A)") "* Initialize event generation"
write (u, "(A)")
call simulation%init ([procname1], .true., .true., global)
call simulation%init_process_selector ()
data = simulation%get_data ()
call data%write (u)
write (u, "(A)")
write (u, "(A)") "* Generate three events"
write (u, "(A)")
call simulation%set_n_events_requested (3)
call simulation%generate ()
call simulation%write (u)
write (u, "(A)")
write (u, "(A)") "* Write the event record for the last event"
write (u, "(A)")
call simulation%write_event (u)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call simulation%final ()
call global%final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: simulations_3"
end subroutine simulations_3
@ %def simulations_3
@
\subsubsection{Simulating process with structure functions}
Generate events for a single process.
<<Simulations: execute tests>>=
call test (simulations_4, "simulations_4", &
"process with structure functions", &
u, results)
<<Simulations: test declarations>>=
public :: simulations_4
<<Simulations: tests>>=
subroutine simulations_4 (u)
integer, intent(in) :: u
type(string_t) :: libname, procname1
type(rt_data_t), target :: global
type(flavor_t) :: flv
type(string_t) :: name
type(simulation_t), target :: simulation
type(event_sample_data_t) :: data
write (u, "(A)") "* Test output: simulations_4"
write (u, "(A)") "* Purpose: generate events for a single process &
&with structure functions"
write (u, "(A)")
write (u, "(A)") "* Initialize processes"
write (u, "(A)")
call syntax_model_file_init ()
call syntax_phs_forest_init ()
call global%global_init ()
call global%set_log (var_str ("?omega_openmp"), &
.false., is_known = .true.)
call global%set_int (var_str ("seed"), &
0, is_known = .true.)
libname = "simulation_4a"
procname1 = "simulation_4p"
call prepare_test_library (global, libname, 1, [procname1])
call compile_library (libname, global)
call global%append_log (&
var_str ("?rebuild_phase_space"), .true., intrinsic = .true.)
call global%append_log (&
var_str ("?rebuild_grids"), .true., intrinsic = .true.)
call global%append_log (&
var_str ("?rebuild_events"), .true., intrinsic = .true.)
call global%set_string (var_str ("$run_id"), &
var_str ("r1"), is_known = .true.)
call global%set_string (var_str ("$method"), &
var_str ("unit_test"), is_known = .true.)
call global%set_string (var_str ("$phs_method"), &
var_str ("wood"), is_known = .true.)
call global%set_string (var_str ("$integration_method"),&
var_str ("vamp"), is_known = .true.)
call global%set_log (var_str ("?use_vamp_equivalences"),&
.true., is_known = .true.)
call global%set_real (var_str ("sqrts"),&
1000._default, is_known = .true.)
call global%model_set_real (var_str ("ms"), &
0._default)
call global%set_log (var_str ("?vis_history"),&
.false., is_known = .true.)
call global%set_log (var_str ("?integration_timer"),&
.false., is_known = .true.)
call global%set_log (var_str ("?recover_beams"), &
.false., is_known = .true.)
call reset_interaction_counter ()
call flv%init (25, global%model)
name = flv%get_name ()
call global%beam_structure%init_sf ([name, name], [1])
call global%beam_structure%set_sf (1, 1, var_str ("sf_test_1"))
write (u, "(A)") "* Integrate"
write (u, "(A)")
call global%it_list%init ([1], [1000])
call global%set_string (var_str ("$run_id"), &
var_str ("r1"), is_known = .true.)
call integrate_process (procname1, global, local_stack=.true.)
write (u, "(A)") "* Initialize event generation"
write (u, "(A)")
call global%set_log (var_str ("?unweighted"), &
.false., is_known = .true.)
call global%set_string (var_str ("$sample"), &
var_str ("simulations4"), is_known = .true.)
call simulation%init ([procname1], .true., .true., global)
call simulation%init_process_selector ()
data = simulation%get_data ()
call data%write (u)
write (u, "(A)")
write (u, "(A)") "* Generate three events"
write (u, "(A)")
call simulation%set_n_events_requested (3)
call simulation%generate ()
call simulation%write (u)
write (u, "(A)")
write (u, "(A)") "* Write the event record for the last event"
write (u, "(A)")
call simulation%write_event (u)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call simulation%final ()
call global%final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: simulations_4"
end subroutine simulations_4
@ %def simulations_4
@
\subsubsection{Event I/O}
Generate event for a test process, write to file and reread.
<<Simulations: execute tests>>=
call test (simulations_5, "simulations_5", &
"raw event I/O", &
u, results)
<<Simulations: test declarations>>=
public :: simulations_5
<<Simulations: tests>>=
subroutine simulations_5 (u)
integer, intent(in) :: u
type(string_t) :: libname, procname1, sample
type(rt_data_t), target :: global
class(eio_t), allocatable :: eio
type(simulation_t), allocatable, target :: simulation
write (u, "(A)") "* Test output: simulations_5"
write (u, "(A)") "* Purpose: generate events for a single process"
write (u, "(A)") "* write to file and reread"
write (u, "(A)")
write (u, "(A)") "* Initialize processes"
write (u, "(A)")
call syntax_model_file_init ()
call global%global_init ()
call global%set_log (var_str ("?omega_openmp"), &
.false., is_known = .true.)
call global%set_int (var_str ("seed"), &
0, is_known = .true.)
libname = "simulation_5a"
procname1 = "simulation_5p"
call prepare_test_library (global, libname, 1, [procname1])
call compile_library (libname, global)
call global%append_log (&
var_str ("?rebuild_events"), .true., intrinsic = .true.)
call global%set_string (var_str ("$method"), &
var_str ("unit_test"), is_known = .true.)
call global%set_string (var_str ("$phs_method"), &
var_str ("single"), is_known = .true.)
call global%set_string (var_str ("$integration_method"),&
var_str ("midpoint"), is_known = .true.)
call global%set_log (var_str ("?vis_history"),&
.false., is_known = .true.)
call global%set_log (var_str ("?integration_timer"),&
.false., is_known = .true.)
call global%set_log (var_str ("?recover_beams"), &
.false., is_known = .true.)
call global%set_real (var_str ("sqrts"),&
1000._default, is_known = .true.)
call global%it_list%init ([1], [1000])
call global%set_string (var_str ("$run_id"), &
var_str ("simulations5"), is_known = .true.)
call integrate_process (procname1, global, local_stack=.true.)
write (u, "(A)") "* Initialize event generation"
write (u, "(A)")
call global%set_log (var_str ("?unweighted"), &
.false., is_known = .true.)
sample = "simulations5"
call global%set_string (var_str ("$sample"), &
sample, is_known = .true.)
allocate (simulation)
call simulation%init ([procname1], .true., .true., global)
call simulation%init_process_selector ()
write (u, "(A)") "* Initialize raw event file"
write (u, "(A)")
allocate (eio_raw_t :: eio)
call eio%init_out (sample)
write (u, "(A)") "* Generate an event"
write (u, "(A)")
call simulation%set_n_events_requested (1)
call simulation%generate ()
call simulation%write_event (u)
call simulation%write_event (eio)
call eio%final ()
deallocate (eio)
call simulation%final ()
deallocate (simulation)
write (u, "(A)")
write (u, "(A)") "* Re-read the event from file"
write (u, "(A)")
call global%set_log (var_str ("?update_sqme"), &
.true., is_known = .true.)
call global%set_log (var_str ("?update_weight"), &
.true., is_known = .true.)
call global%set_log (var_str ("?recover_beams"), &
.false., is_known = .true.)
allocate (simulation)
call simulation%init ([procname1], .true., .true., global)
call simulation%init_process_selector ()
allocate (eio_raw_t :: eio)
call eio%init_in (sample)
call simulation%read_event (eio)
call simulation%write_event (u)
write (u, "(A)")
write (u, "(A)") "* Recalculate process instance"
write (u, "(A)")
call simulation%recalculate ()
call simulation%evaluate_expressions ()
call simulation%write_event (u)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call eio%final ()
call simulation%final ()
call global%final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: simulations_5"
end subroutine simulations_5
@ %def simulations_5
@
\subsubsection{Event I/O}
Generate event for a real process with structure functions, write to file and
reread.
<<Simulations: execute tests>>=
call test (simulations_6, "simulations_6", &
"raw event I/O with structure functions", &
u, results)
<<Simulations: test declarations>>=
public :: simulations_6
<<Simulations: tests>>=
subroutine simulations_6 (u)
integer, intent(in) :: u
type(string_t) :: libname, procname1, sample
type(rt_data_t), target :: global
class(eio_t), allocatable :: eio
type(simulation_t), allocatable, target :: simulation
type(flavor_t) :: flv
type(string_t) :: name
write (u, "(A)") "* Test output: simulations_6"
write (u, "(A)") "* Purpose: generate events for a single process"
write (u, "(A)") "* write to file and reread"
write (u, "(A)")
write (u, "(A)") "* Initialize process and integrate"
write (u, "(A)")
call syntax_model_file_init ()
call global%global_init ()
call global%set_log (var_str ("?omega_openmp"), &
.false., is_known = .true.)
call global%set_int (var_str ("seed"), &
0, is_known = .true.)
libname = "simulation_6"
procname1 = "simulation_6p"
call prepare_test_library (global, libname, 1, [procname1])
call compile_library (libname, global)
call global%append_log (&
var_str ("?rebuild_phase_space"), .true., intrinsic = .true.)
call global%append_log (&
var_str ("?rebuild_grids"), .true., intrinsic = .true.)
call global%append_log (&
var_str ("?rebuild_events"), .true., intrinsic = .true.)
call global%set_string (var_str ("$method"), &
var_str ("unit_test"), is_known = .true.)
call global%set_string (var_str ("$phs_method"), &
var_str ("wood"), is_known = .true.)
call global%set_string (var_str ("$integration_method"),&
var_str ("vamp"), is_known = .true.)
call global%set_log (var_str ("?use_vamp_equivalences"),&
.true., is_known = .true.)
call global%set_log (var_str ("?vis_history"),&
.false., is_known = .true.)
call global%set_log (var_str ("?integration_timer"),&
.false., is_known = .true.)
call global%set_log (var_str ("?recover_beams"), &
.false., is_known = .true.)
call global%set_real (var_str ("sqrts"),&
1000._default, is_known = .true.)
call global%model_set_real (var_str ("ms"), &
0._default)
call flv%init (25, global%model)
name = flv%get_name ()
call global%beam_structure%init_sf ([name, name], [1])
call global%beam_structure%set_sf (1, 1, var_str ("sf_test_1"))
call global%it_list%init ([1], [1000])
call global%set_string (var_str ("$run_id"), &
var_str ("r1"), is_known = .true.)
call integrate_process (procname1, global, local_stack=.true.)
write (u, "(A)") "* Initialize event generation"
write (u, "(A)")
call reset_interaction_counter ()
call global%set_log (var_str ("?unweighted"), &
.false., is_known = .true.)
sample = "simulations6"
call global%set_string (var_str ("$sample"), &
sample, is_known = .true.)
allocate (simulation)
call simulation%init ([procname1], .true., .true., global)
call simulation%init_process_selector ()
write (u, "(A)") "* Initialize raw event file"
write (u, "(A)")
allocate (eio_raw_t :: eio)
call eio%init_out (sample)
write (u, "(A)") "* Generate an event"
write (u, "(A)")
call simulation%set_n_events_requested (1)
call simulation%generate ()
call pacify (simulation)
call simulation%write_event (u, verbose = .true., testflag = .true.)
call simulation%write_event (eio)
call eio%final ()
deallocate (eio)
call simulation%final ()
deallocate (simulation)
write (u, "(A)")
write (u, "(A)") "* Re-read the event from file"
write (u, "(A)")
call reset_interaction_counter ()
call global%set_log (var_str ("?update_sqme"), &
.true., is_known = .true.)
call global%set_log (var_str ("?update_weight"), &
.true., is_known = .true.)
allocate (simulation)
call simulation%init ([procname1], .true., .true., global)
call simulation%init_process_selector ()
allocate (eio_raw_t :: eio)
call eio%init_in (sample)
call simulation%read_event (eio)
call simulation%write_event (u, verbose = .true., testflag = .true.)
write (u, "(A)")
write (u, "(A)") "* Recalculate process instance"
write (u, "(A)")
call simulation%recalculate ()
call simulation%evaluate_expressions ()
call simulation%write_event (u, verbose = .true., testflag = .true.)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call eio%final ()
call simulation%final ()
call global%final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: simulations_6"
end subroutine simulations_6
@ %def simulations_6
@
\subsubsection{Automatic Event I/O}
Generate events with raw-format event file as cache: generate, reread,
append.
<<Simulations: execute tests>>=
call test (simulations_7, "simulations_7", &
"automatic raw event I/O", &
u, results)
<<Simulations: test declarations>>=
public :: simulations_7
<<Simulations: tests>>=
subroutine simulations_7 (u)
integer, intent(in) :: u
type(string_t) :: libname, procname1, sample
type(rt_data_t), target :: global
type(string_t), dimension(0) :: empty_string_array
type(event_sample_data_t) :: data
type(event_stream_array_t) :: es_array
type(simulation_t), allocatable, target :: simulation
type(flavor_t) :: flv
type(string_t) :: name
write (u, "(A)") "* Test output: simulations_7"
write (u, "(A)") "* Purpose: generate events for a single process"
write (u, "(A)") "* write to file and reread"
write (u, "(A)")
write (u, "(A)") "* Initialize process and integrate"
write (u, "(A)")
call syntax_model_file_init ()
call global%global_init ()
call global%init_fallback_model &
(var_str ("SM_hadrons"), var_str ("SM_hadrons.mdl"))
call global%set_log (var_str ("?omega_openmp"), &
.false., is_known = .true.)
call global%set_int (var_str ("seed"), &
0, is_known = .true.)
libname = "simulation_7"
procname1 = "simulation_7p"
call prepare_test_library (global, libname, 1, [procname1])
call compile_library (libname, global)
call global%append_log (&
var_str ("?rebuild_phase_space"), .true., intrinsic = .true.)
call global%append_log (&
var_str ("?rebuild_grids"), .true., intrinsic = .true.)
call global%append_log (&
var_str ("?rebuild_events"), .true., intrinsic = .true.)
call global%set_string (var_str ("$method"), &
var_str ("unit_test"), is_known = .true.)
call global%set_string (var_str ("$phs_method"), &
var_str ("wood"), is_known = .true.)
call global%set_string (var_str ("$integration_method"),&
var_str ("vamp"), is_known = .true.)
call global%set_log (var_str ("?use_vamp_equivalences"),&
.true., is_known = .true.)
call global%set_log (var_str ("?vis_history"),&
.false., is_known = .true.)
call global%set_log (var_str ("?integration_timer"),&
.false., is_known = .true.)
call global%set_log (var_str ("?recover_beams"), &
.false., is_known = .true.)
call global%set_real (var_str ("sqrts"),&
1000._default, is_known = .true.)
call global%model_set_real (var_str ("ms"), &
0._default)
call flv%init (25, global%model)
name = flv%get_name ()
call global%beam_structure%init_sf ([name, name], [1])
call global%beam_structure%set_sf (1, 1, var_str ("sf_test_1"))
call global%it_list%init ([1], [1000])
call global%set_string (var_str ("$run_id"), &
var_str ("r1"), is_known = .true.)
call integrate_process (procname1, global, local_stack=.true.)
write (u, "(A)") "* Initialize event generation"
write (u, "(A)")
call reset_interaction_counter ()
call global%set_log (var_str ("?unweighted"), &
.false., is_known = .true.)
sample = "simulations7"
call global%set_string (var_str ("$sample"), &
sample, is_known = .true.)
allocate (simulation)
call simulation%init ([procname1], .true., .true., global)
call simulation%init_process_selector ()
write (u, "(A)") "* Initialize raw event file"
write (u, "(A)")
data%md5sum_prc = simulation%get_md5sum_prc ()
data%md5sum_cfg = simulation%get_md5sum_cfg ()
call es_array%init (sample, [var_str ("raw")], global, data)
write (u, "(A)") "* Generate an event"
write (u, "(A)")
call simulation%set_n_events_requested (1)
call simulation%generate (es_array)
call es_array%final ()
call simulation%final ()
deallocate (simulation)
write (u, "(A)") "* Re-read the event from file and generate another one"
write (u, "(A)")
call global%set_log (&
var_str ("?rebuild_events"), .false., is_known = .true.)
call reset_interaction_counter ()
allocate (simulation)
call simulation%init ([procname1], .true., .true., global)
call simulation%init_process_selector ()
data%md5sum_prc = simulation%get_md5sum_prc ()
data%md5sum_cfg = simulation%get_md5sum_cfg ()
call es_array%init (sample, empty_string_array, global, data, &
input = var_str ("raw"))
call simulation%set_n_events_requested (2)
call simulation%generate (es_array)
call pacify (simulation)
call simulation%write_event (u, verbose = .true.)
call es_array%final ()
call simulation%final ()
deallocate (simulation)
write (u, "(A)")
write (u, "(A)") "* Re-read both events from file"
write (u, "(A)")
call reset_interaction_counter ()
allocate (simulation)
call simulation%init ([procname1], .true., .true., global)
call simulation%init_process_selector ()
data%md5sum_prc = simulation%get_md5sum_prc ()
data%md5sum_cfg = simulation%get_md5sum_cfg ()
call es_array%init (sample, empty_string_array, global, data, &
input = var_str ("raw"))
call simulation%set_n_events_requested (2)
call simulation%generate (es_array)
call pacify (simulation)
call simulation%write_event (u, verbose = .true.)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call es_array%final ()
call simulation%final ()
call global%final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: simulations_7"
end subroutine simulations_7
@ %def simulations_7
@
\subsubsection{Rescanning Events}
Generate events and rescan the resulting raw event file.
<<Simulations: execute tests>>=
call test (simulations_8, "simulations_8", &
"rescan raw event file", &
u, results)
<<Simulations: test declarations>>=
public :: simulations_8
<<Simulations: tests>>=
subroutine simulations_8 (u)
integer, intent(in) :: u
type(string_t) :: libname, procname1, sample
type(rt_data_t), target :: global
type(string_t), dimension(0) :: empty_string_array
type(event_sample_data_t) :: data
type(event_stream_array_t) :: es_array
type(simulation_t), allocatable, target :: simulation
type(flavor_t) :: flv
type(string_t) :: name
write (u, "(A)") "* Test output: simulations_8"
write (u, "(A)") "* Purpose: generate events for a single process"
write (u, "(A)") "* write to file and rescan"
write (u, "(A)")
write (u, "(A)") "* Initialize process and integrate"
write (u, "(A)")
call syntax_model_file_init ()
call global%global_init ()
call global%init_fallback_model &
(var_str ("SM_hadrons"), var_str ("SM_hadrons.mdl"))
call global%set_log (var_str ("?omega_openmp"), &
.false., is_known = .true.)
call global%set_int (var_str ("seed"), &
0, is_known = .true.)
libname = "simulation_8"
procname1 = "simulation_8p"
call prepare_test_library (global, libname, 1, [procname1])
call compile_library (libname, global)
call global%append_log (&
var_str ("?rebuild_phase_space"), .true., intrinsic = .true.)
call global%append_log (&
var_str ("?rebuild_grids"), .true., intrinsic = .true.)
call global%append_log (&
var_str ("?rebuild_events"), .true., intrinsic = .true.)
call global%set_string (var_str ("$method"), &
var_str ("unit_test"), is_known = .true.)
call global%set_string (var_str ("$phs_method"), &
var_str ("wood"), is_known = .true.)
call global%set_string (var_str ("$integration_method"),&
var_str ("vamp"), is_known = .true.)
call global%set_log (var_str ("?use_vamp_equivalences"),&
.true., is_known = .true.)
call global%set_log (var_str ("?vis_history"),&
.false., is_known = .true.)
call global%set_log (var_str ("?integration_timer"),&
.false., is_known = .true.)
call global%set_log (var_str ("?recover_beams"), &
.false., is_known = .true.)
call global%set_real (var_str ("sqrts"),&
1000._default, is_known = .true.)
call global%model_set_real (var_str ("ms"), &
0._default)
call flv%init (25, global%model)
name = flv%get_name ()
call global%beam_structure%init_sf ([name, name], [1])
call global%beam_structure%set_sf (1, 1, var_str ("sf_test_1"))
call global%it_list%init ([1], [1000])
call global%set_string (var_str ("$run_id"), &
var_str ("r1"), is_known = .true.)
call integrate_process (procname1, global, local_stack=.true.)
write (u, "(A)") "* Initialize event generation"
write (u, "(A)")
call reset_interaction_counter ()
call global%set_log (var_str ("?unweighted"), &
.false., is_known = .true.)
sample = "simulations8"
call global%set_string (var_str ("$sample"), &
sample, is_known = .true.)
allocate (simulation)
call simulation%init ([procname1], .true., .true., global)
call simulation%init_process_selector ()
write (u, "(A)") "* Initialize raw event file"
write (u, "(A)")
data%md5sum_prc = simulation%get_md5sum_prc ()
data%md5sum_cfg = simulation%get_md5sum_cfg ()
write (u, "(1x,A,A,A)") "MD5 sum (proc) = '", data%md5sum_prc, "'"
write (u, "(1x,A,A,A)") "MD5 sum (config) = '", data%md5sum_cfg, "'"
call es_array%init (sample, [var_str ("raw")], global, &
data)
write (u, "(A)")
write (u, "(A)") "* Generate an event"
write (u, "(A)")
call simulation%set_n_events_requested (1)
call simulation%generate (es_array)
call pacify (simulation)
call simulation%write_event (u, verbose = .true., testflag = .true.)
call es_array%final ()
call simulation%final ()
deallocate (simulation)
write (u, "(A)")
write (u, "(A)") "* Re-read the event from file"
write (u, "(A)")
call reset_interaction_counter ()
allocate (simulation)
call simulation%init ([procname1], .false., .false., global)
call simulation%init_process_selector ()
data%md5sum_prc = simulation%get_md5sum_prc ()
data%md5sum_cfg = ""
write (u, "(1x,A,A,A)") "MD5 sum (proc) = '", data%md5sum_prc, "'"
write (u, "(1x,A,A,A)") "MD5 sum (config) = '", data%md5sum_cfg, "'"
call es_array%init (sample, empty_string_array, global, data, &
input = var_str ("raw"), input_sample = sample, allow_switch = .false.)
call simulation%rescan (1, es_array, global = global)
write (u, "(A)")
call pacify (simulation)
call simulation%write_event (u, verbose = .true., testflag = .true.)
call es_array%final ()
call simulation%final ()
deallocate (simulation)
write (u, "(A)")
write (u, "(A)") "* Re-read again and recalculate"
write (u, "(A)")
call reset_interaction_counter ()
call global%set_log (var_str ("?update_sqme"), &
.true., is_known = .true.)
call global%set_log (var_str ("?update_event"), &
.true., is_known = .true.)
allocate (simulation)
call simulation%init ([procname1], .false., .false., global)
call simulation%init_process_selector ()
data%md5sum_prc = simulation%get_md5sum_prc ()
data%md5sum_cfg = ""
write (u, "(1x,A,A,A)") "MD5 sum (proc) = '", data%md5sum_prc, "'"
write (u, "(1x,A,A,A)") "MD5 sum (config) = '", data%md5sum_cfg, "'"
call es_array%init (sample, empty_string_array, global, data, &
input = var_str ("raw"), input_sample = sample, allow_switch = .false.)
call simulation%rescan (1, es_array, global = global)
write (u, "(A)")
call pacify (simulation)
call simulation%write_event (u, verbose = .true., testflag = .true.)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call es_array%final ()
call simulation%final ()
call global%final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: simulations_8"
end subroutine simulations_8
@ %def simulations_8
@
\subsubsection{Rescanning Check}
Generate events and rescan with process mismatch.
<<Simulations: execute tests>>=
call test (simulations_9, "simulations_9", &
"rescan mismatch", &
u, results)
<<Simulations: test declarations>>=
public :: simulations_9
<<Simulations: tests>>=
subroutine simulations_9 (u)
integer, intent(in) :: u
type(string_t) :: libname, procname1, sample
type(rt_data_t), target :: global
type(string_t), dimension(0) :: empty_string_array
type(event_sample_data_t) :: data
type(event_stream_array_t) :: es_array
type(simulation_t), allocatable, target :: simulation
type(flavor_t) :: flv
type(string_t) :: name
logical :: error
write (u, "(A)") "* Test output: simulations_9"
write (u, "(A)") "* Purpose: generate events for a single process"
write (u, "(A)") "* write to file and rescan"
write (u, "(A)")
write (u, "(A)") "* Initialize process and integrate"
write (u, "(A)")
call syntax_model_file_init ()
call global%global_init ()
call global%init_fallback_model &
(var_str ("SM_hadrons"), var_str ("SM_hadrons.mdl"))
call global%set_log (var_str ("?omega_openmp"), &
.false., is_known = .true.)
call global%set_int (var_str ("seed"), &
0, is_known = .true.)
libname = "simulation_9"
procname1 = "simulation_9p"
call prepare_test_library (global, libname, 1, [procname1])
call compile_library (libname, global)
call global%append_log (&
var_str ("?rebuild_phase_space"), .true., intrinsic = .true.)
call global%append_log (&
var_str ("?rebuild_grids"), .true., intrinsic = .true.)
call global%append_log (&
var_str ("?rebuild_events"), .true., intrinsic = .true.)
call global%set_string (var_str ("$method"), &
var_str ("unit_test"), is_known = .true.)
call global%set_string (var_str ("$phs_method"), &
var_str ("wood"), is_known = .true.)
call global%set_string (var_str ("$integration_method"),&
var_str ("vamp"), is_known = .true.)
call global%set_log (var_str ("?use_vamp_equivalences"),&
.true., is_known = .true.)
call global%set_log (var_str ("?vis_history"),&
.false., is_known = .true.)
call global%set_log (var_str ("?integration_timer"),&
.false., is_known = .true.)
call global%set_log (var_str ("?recover_beams"), &
.false., is_known = .true.)
call global%set_real (var_str ("sqrts"),&
1000._default, is_known = .true.)
call global%model_set_real (var_str ("ms"), &
0._default)
call flv%init (25, global%model)
name = flv%get_name ()
call global%beam_structure%init_sf ([name, name], [1])
call global%beam_structure%set_sf (1, 1, var_str ("sf_test_1"))
call global%it_list%init ([1], [1000])
call global%set_string (var_str ("$run_id"), &
var_str ("r1"), is_known = .true.)
call integrate_process (procname1, global, local_stack=.true.)
write (u, "(A)") "* Initialize event generation"
write (u, "(A)")
call reset_interaction_counter ()
call global%set_log (var_str ("?unweighted"), &
.false., is_known = .true.)
sample = "simulations9"
call global%set_string (var_str ("$sample"), &
sample, is_known = .true.)
allocate (simulation)
call simulation%init ([procname1], .true., .true., global)
call simulation%init_process_selector ()
call simulation%write (u)
write (u, "(A)")
write (u, "(A)") "* Initialize raw event file"
write (u, "(A)")
data%md5sum_prc = simulation%get_md5sum_prc ()
data%md5sum_cfg = simulation%get_md5sum_cfg ()
write (u, "(1x,A,A,A)") "MD5 sum (proc) = '", data%md5sum_prc, "'"
write (u, "(1x,A,A,A)") "MD5 sum (config) = '", data%md5sum_cfg, "'"
call es_array%init (sample, [var_str ("raw")], global, &
data)
write (u, "(A)")
write (u, "(A)") "* Generate an event"
write (u, "(A)")
call simulation%set_n_events_requested (1)
call simulation%generate (es_array)
call es_array%final ()
call simulation%final ()
deallocate (simulation)
write (u, "(A)") "* Initialize event generation for different parameters"
write (u, "(A)")
call reset_interaction_counter ()
allocate (simulation)
call simulation%init ([procname1, procname1], .false., .false., global)
call simulation%init_process_selector ()
call simulation%write (u)
write (u, "(A)")
write (u, "(A)") "* Attempt to re-read the events (should fail)"
write (u, "(A)")
data%md5sum_prc = simulation%get_md5sum_prc ()
data%md5sum_cfg = ""
write (u, "(1x,A,A,A)") "MD5 sum (proc) = '", data%md5sum_prc, "'"
write (u, "(1x,A,A,A)") "MD5 sum (config) = '", data%md5sum_cfg, "'"
call es_array%init (sample, empty_string_array, global, data, &
input = var_str ("raw"), input_sample = sample, &
allow_switch = .false., error = error)
write (u, "(1x,A,L1)") "error = ", error
call simulation%rescan (1, es_array, global = global)
call es_array%final ()
call simulation%final ()
call global%final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: simulations_9"
end subroutine simulations_9
@ %def simulations_9
@
\subsubsection{Alternative weights}
Generate an event for a single process and reweight it in a
simultaneous calculation.
<<Simulations: execute tests>>=
call test (simulations_10, "simulations_10", &
"alternative weight", &
u, results)
<<Simulations: test declarations>>=
public :: simulations_10
<<Simulations: tests>>=
subroutine simulations_10 (u)
integer, intent(in) :: u
type(string_t) :: libname, procname1, expr_text
type(rt_data_t), target :: global
type(rt_data_t), dimension(1), target :: alt_env
type(ifile_t) :: ifile
type(stream_t) :: stream
type(parse_tree_t) :: pt_weight
type(simulation_t), target :: simulation
type(event_sample_data_t) :: data
write (u, "(A)") "* Test output: simulations_10"
write (u, "(A)") "* Purpose: reweight event"
write (u, "(A)")
write (u, "(A)") "* Initialize processes"
write (u, "(A)")
call syntax_model_file_init ()
call syntax_pexpr_init ()
call global%global_init ()
call global%set_log (var_str ("?omega_openmp"), &
.false., is_known = .true.)
call global%set_int (var_str ("seed"), &
0, is_known = .true.)
libname = "simulation_10a"
procname1 = "simulation_10p"
call prepare_test_library (global, libname, 1, [procname1])
call compile_library (libname, global)
call global%append_log (&
var_str ("?rebuild_phase_space"), .true., intrinsic = .true.)
call global%append_log (&
var_str ("?rebuild_grids"), .true., intrinsic = .true.)
call global%append_log (&
var_str ("?rebuild_events"), .true., intrinsic = .true.)
call global%set_string (var_str ("$method"), &
var_str ("unit_test"), is_known = .true.)
call global%set_string (var_str ("$phs_method"), &
var_str ("single"), is_known = .true.)
call global%set_string (var_str ("$integration_method"),&
var_str ("midpoint"), is_known = .true.)
call global%set_log (var_str ("?vis_history"),&
.false., is_known = .true.)
call global%set_log (var_str ("?integration_timer"),&
.false., is_known = .true.)
call global%set_log (var_str ("?recover_beams"), &
.false., is_known = .true.)
call global%set_real (var_str ("sqrts"),&
1000._default, is_known = .true.)
call global%it_list%init ([1], [1000])
call global%set_string (var_str ("$run_id"), &
var_str ("simulations1"), is_known = .true.)
call integrate_process (procname1, global, local_stack=.true.)
write (u, "(A)") "* Initialize alternative environment with custom weight"
write (u, "(A)")
call alt_env(1)%local_init (global)
call alt_env(1)%activate ()
expr_text = "2"
write (u, "(A,A)") "weight = ", char (expr_text)
write (u, *)
call ifile_clear (ifile)
call ifile_append (ifile, expr_text)
call stream_init (stream, ifile)
call parse_tree_init_expr (pt_weight, stream, .true.)
call stream_final (stream)
alt_env(1)%pn%weight_expr => pt_weight%get_root_ptr ()
call alt_env(1)%write_expr (u)
write (u, "(A)")
write (u, "(A)") "* Initialize event generation"
write (u, "(A)")
call global%set_log (var_str ("?unweighted"), &
.false., is_known = .true.)
call simulation%init ([procname1], .true., .true., global, alt_env=alt_env)
call simulation%init_process_selector ()
data = simulation%get_data ()
call data%write (u)
write (u, "(A)")
write (u, "(A)") "* Generate an event"
write (u, "(A)")
call simulation%set_n_events_requested (1)
call simulation%generate ()
call simulation%write (u)
write (u, "(A)")
write (u, "(A)") "* Write the event record for the last event"
write (u, "(A)")
call simulation%write_event (u)
write (u, "(A)")
write (u, "(A)") "* Write the event record for the alternative setup"
write (u, "(A)")
call simulation%write_alt_event (u)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call simulation%final ()
call global%final ()
call syntax_model_file_final ()
call syntax_pexpr_final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: simulations_10"
end subroutine simulations_10
@ %def simulations_10
@
\subsubsection{Decays}
Generate an event with subsequent partonic decays.
<<Simulations: execute tests>>=
call test (simulations_11, "simulations_11", &
"decay", &
u, results)
<<Simulations: test declarations>>=
public :: simulations_11
<<Simulations: tests>>=
subroutine simulations_11 (u)
integer, intent(in) :: u
type(rt_data_t), target :: global
type(prclib_entry_t), pointer :: lib
type(string_t) :: prefix, procname1, procname2
type(simulation_t), target :: simulation
write (u, "(A)") "* Test output: simulations_11"
write (u, "(A)") "* Purpose: apply decay"
write (u, "(A)")
write (u, "(A)") "* Initialize processes"
write (u, "(A)")
call syntax_model_file_init ()
call global%global_init ()
allocate (lib)
call global%add_prclib (lib)
call global%set_int (var_str ("seed"), &
0, is_known = .true.)
call global%set_log (var_str ("?recover_beams"), &
.false., is_known = .true.)
prefix = "simulation_11"
procname1 = prefix // "_p"
procname2 = prefix // "_d"
call prepare_testbed &
(global%prclib, global%process_stack, &
prefix, global%os_data, &
scattering=.true., decay=.true.)
call global%select_model (var_str ("Test"))
call global%model%set_par (var_str ("ff"), 0.4_default)
call global%model%set_par (var_str ("mf"), &
global%model%get_real (var_str ("ff")) &
* global%model%get_real (var_str ("ms")))
call global%model%set_unstable (25, [procname2])
write (u, "(A)") "* Initialize simulation object"
write (u, "(A)")
call simulation%init ([procname1], .true., .true., global)
call simulation%init_process_selector ()
write (u, "(A)") "* Generate event"
write (u, "(A)")
call simulation%set_n_events_requested (1)
call simulation%generate ()
call simulation%write (u)
write (u, *)
call simulation%write_event (u)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
write (u, "(A)")
call simulation%final ()
call global%final ()
call syntax_model_file_final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: simulations_11"
end subroutine simulations_11
@ %def simulations_11
@
\subsubsection{Split Event Files}
Generate event for a real process with structure functions and write to file,
accepting a limit for the number of events per file.
<<Simulations: execute tests>>=
call test (simulations_12, "simulations_12", &
"split event files", &
u, results)
<<Simulations: test declarations>>=
public :: simulations_12
<<Simulations: tests>>=
subroutine simulations_12 (u)
integer, intent(in) :: u
type(string_t) :: libname, procname1, sample
type(rt_data_t), target :: global
class(eio_t), allocatable :: eio
type(simulation_t), allocatable, target :: simulation
type(flavor_t) :: flv
integer :: i_evt
write (u, "(A)") "* Test output: simulations_12"
write (u, "(A)") "* Purpose: generate events for a single process"
write (u, "(A)") "* and write to split event files"
write (u, "(A)")
write (u, "(A)") "* Initialize process and integrate"
write (u, "(A)")
call syntax_model_file_init ()
call global%global_init ()
call global%set_log (var_str ("?omega_openmp"), &
.false., is_known = .true.)
call global%set_int (var_str ("seed"), &
0, is_known = .true.)
libname = "simulation_12"
procname1 = "simulation_12p"
call prepare_test_library (global, libname, 1, [procname1])
call compile_library (libname, global)
call global%append_log (&
var_str ("?rebuild_phase_space"), .true., intrinsic = .true.)
call global%append_log (&
var_str ("?rebuild_grids"), .true., intrinsic = .true.)
call global%append_log (&
var_str ("?rebuild_events"), .true., intrinsic = .true.)
call global%set_string (var_str ("$method"), &
var_str ("unit_test"), is_known = .true.)
call global%set_string (var_str ("$phs_method"), &
var_str ("single"), is_known = .true.)
call global%set_string (var_str ("$integration_method"),&
var_str ("midpoint"), is_known = .true.)
call global%set_log (var_str ("?vis_history"),&
.false., is_known = .true.)
call global%set_log (var_str ("?integration_timer"),&
.false., is_known = .true.)
call global%set_log (var_str ("?recover_beams"), &
.false., is_known = .true.)
call global%set_real (var_str ("sqrts"),&
1000._default, is_known = .true.)
call global%model_set_real (var_str ("ms"), &
0._default)
call flv%init (25, global%model)
call global%it_list%init ([1], [1000])
call global%set_string (var_str ("$run_id"), &
var_str ("r1"), is_known = .true.)
call integrate_process (procname1, global, local_stack=.true.)
write (u, "(A)") "* Initialize event generation"
write (u, "(A)")
call global%set_log (var_str ("?unweighted"), &
.false., is_known = .true.)
sample = "simulations_12"
call global%set_string (var_str ("$sample"), &
sample, is_known = .true.)
call global%set_int (var_str ("sample_split_n_evt"), &
2, is_known = .true.)
call global%set_int (var_str ("sample_split_index"), &
42, is_known = .true.)
allocate (simulation)
call simulation%init ([procname1], .true., .true., global)
call simulation%init_process_selector ()
call simulation%write (u)
write (u, "(A)")
write (u, "(A)") "* Initialize ASCII event file"
write (u, "(A)")
allocate (eio_ascii_short_t :: eio)
select type (eio)
class is (eio_ascii_t); call eio%set_parameters ()
end select
call eio%init_out (sample, data = simulation%get_data ())
write (u, "(A)") "* Generate 5 events, distributed among three files"
do i_evt = 1, 5
call simulation%set_n_events_requested (1)
call simulation%generate ()
call simulation%write_event (eio)
end do
call eio%final ()
deallocate (eio)
call simulation%final ()
deallocate (simulation)
write (u, *)
call display_file ("simulations_12.42.short.evt", u)
write (u, *)
call display_file ("simulations_12.43.short.evt", u)
write (u, *)
call display_file ("simulations_12.44.short.evt", u)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call global%final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: simulations_12"
end subroutine simulations_12
@ %def simulations_12
@ Auxiliary: display file contents.
<<Simulations: public test auxiliary>>=
public :: display_file
<<Simulations: test auxiliary>>=
subroutine display_file (file, u)
use io_units, only: free_unit
character(*), intent(in) :: file
integer, intent(in) :: u
character(256) :: buffer
integer :: u_file
write (u, "(3A)") "* Contents of file '", file, "':"
write (u, *)
u_file = free_unit ()
open (u_file, file = file, action = "read", status = "old")
do
read (u_file, "(A)", end = 1) buffer
write (u, "(A)") trim (buffer)
end do
1 continue
end subroutine display_file
@ %def display_file
@
\subsubsection{Callback}
Generate events and execute a callback in place of event I/O.
<<Simulations: execute tests>>=
call test (simulations_13, "simulations_13", &
"callback", &
u, results)
<<Simulations: test declarations>>=
public :: simulations_13
<<Simulations: tests>>=
subroutine simulations_13 (u)
integer, intent(in) :: u
type(string_t) :: libname, procname1, sample
type(rt_data_t), target :: global
class(eio_t), allocatable :: eio
type(simulation_t), allocatable, target :: simulation
type(flavor_t) :: flv
integer :: i_evt
type(simulations_13_callback_t) :: event_callback
write (u, "(A)") "* Test output: simulations_13"
write (u, "(A)") "* Purpose: generate events for a single process"
write (u, "(A)") "* and execute callback"
write (u, "(A)")
write (u, "(A)") "* Initialize process and integrate"
write (u, "(A)")
call syntax_model_file_init ()
call global%global_init ()
call global%set_log (var_str ("?omega_openmp"), &
.false., is_known = .true.)
call global%set_int (var_str ("seed"), &
0, is_known = .true.)
libname = "simulation_13"
procname1 = "simulation_13p"
call prepare_test_library (global, libname, 1, [procname1])
call compile_library (libname, global)
call global%append_log (&
var_str ("?rebuild_phase_space"), .true., intrinsic = .true.)
call global%append_log (&
var_str ("?rebuild_grids"), .true., intrinsic = .true.)
call global%append_log (&
var_str ("?rebuild_events"), .true., intrinsic = .true.)
call global%set_string (var_str ("$method"), &
var_str ("unit_test"), is_known = .true.)
call global%set_string (var_str ("$phs_method"), &
var_str ("single"), is_known = .true.)
call global%set_string (var_str ("$integration_method"),&
var_str ("midpoint"), is_known = .true.)
call global%set_log (var_str ("?vis_history"),&
.false., is_known = .true.)
call global%set_log (var_str ("?integration_timer"),&
.false., is_known = .true.)
call global%set_log (var_str ("?recover_beams"), &
.false., is_known = .true.)
call global%set_real (var_str ("sqrts"),&
1000._default, is_known = .true.)
call flv%init (25, global%model)
call global%it_list%init ([1], [1000])
call global%set_string (var_str ("$run_id"), &
var_str ("r1"), is_known = .true.)
call integrate_process (procname1, global, local_stack=.true.)
write (u, "(A)") "* Initialize event generation"
write (u, "(A)")
call global%set_log (var_str ("?unweighted"), &
.false., is_known = .true.)
sample = "simulations_13"
call global%set_string (var_str ("$sample"), &
sample, is_known = .true.)
allocate (simulation)
call simulation%init ([procname1], .true., .true., global)
call simulation%init_process_selector ()
write (u, "(A)") "* Prepare callback object"
write (u, "(A)")
event_callback%u = u
call global%set_event_callback (event_callback)
write (u, "(A)") "* Initialize callback I/O object"
write (u, "(A)")
allocate (eio_callback_t :: eio)
select type (eio)
class is (eio_callback_t)
call eio%set_parameters (callback = event_callback, &
count_interval = 3)
end select
call eio%init_out (sample, data = simulation%get_data ())
write (u, "(A)") "* Generate 7 events, with callback every 3 events"
write (u, "(A)")
do i_evt = 1, 7
call simulation%set_n_events_requested (1)
call simulation%generate ()
call simulation%write_event (eio)
end do
call eio%final ()
deallocate (eio)
call simulation%final ()
deallocate (simulation)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call global%final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: simulations_13"
end subroutine simulations_13
@ %def simulations_13
@ The callback object and procedure. In the type extension, we can
store the output channel [[u]] so we know where to write into.
<<Simulations: test auxiliary types>>=
type, extends (event_callback_t) :: simulations_13_callback_t
integer :: u
contains
procedure :: write => simulations_13_callback_write
procedure :: proc => simulations_13_callback
end type simulations_13_callback_t
@ %def simulations_13_callback_t
<<Simulations: test auxiliary>>=
subroutine simulations_13_callback_write (event_callback, unit)
class(simulations_13_callback_t), intent(in) :: event_callback
integer, intent(in), optional :: unit
integer :: u
u = given_output_unit (unit)
write (u, "(1x,A)") "Hello"
end subroutine simulations_13_callback_write
subroutine simulations_13_callback (event_callback, i, event)
class(simulations_13_callback_t), intent(in) :: event_callback
integer(i64), intent(in) :: i
class(generic_event_t), intent(in) :: event
write (event_callback%u, "(A,I0)") "hello event #", i
end subroutine simulations_13_callback
@ %def simulations_13_callback_write
@ %def simulations_13_callback
@
\subsubsection{Resonant subprocess setup}
Prepare a process with resonances and enter resonant subprocesses in
the simulation object. Select a kinematics configuration and compute
probabilities for resonant subprocesses.
The process and its initialization is taken from [[processes_18]], but
we need a complete \oMega\ matrix element here.
<<Simulations: execute tests>>=
call test (simulations_14, "simulations_14", &
"resonant subprocesses evaluation", &
u, results)
<<Simulations: test declarations>>=
public :: simulations_14
<<Simulations: tests>>=
subroutine simulations_14 (u)
integer, intent(in) :: u
type(string_t) :: libname, libname_generated
type(string_t) :: procname
type(string_t) :: model_name
type(rt_data_t), target :: global
type(prclib_entry_t), pointer :: lib_entry
type(process_library_t), pointer :: lib
class(model_t), pointer :: model
class(model_data_t), pointer :: model_data
type(simulation_t), target :: simulation
type(particle_set_t) :: pset
type(eio_direct_t) :: eio_in
type(eio_dump_t) :: eio_out
real(default) :: sqrts, mw, pp
real(default), dimension(3) :: p3
type(vector4_t), dimension(:), allocatable :: p
real(default), dimension(:), allocatable :: m
integer :: u_verbose, i
real(default) :: sqme_proc
real(default), dimension(:), allocatable :: sqme
real(default) :: on_shell_limit
integer, dimension(:), allocatable :: i_array
real(default), dimension(:), allocatable :: prob_array
write (u, "(A)") "* Test output: simulations_14"
write (u, "(A)") "* Purpose: construct resonant subprocesses &
&in the simulation object"
write (u, "(A)")
write (u, "(A)") "* Build and load a test library with one process"
write (u, "(A)")
call syntax_model_file_init ()
call syntax_phs_forest_init ()
libname = "simulations_14_lib"
procname = "simulations_14_p"
call global%global_init ()
call global%append_log (&
var_str ("?rebuild_phase_space"), .true., intrinsic = .true.)
call global%append_log (&
var_str ("?rebuild_grids"), .true., intrinsic = .true.)
call global%append_log (&
var_str ("?rebuild_events"), .true., intrinsic = .true.)
call global%set_log (var_str ("?omega_openmp"), &
.false., is_known = .true.)
call global%set_int (var_str ("seed"), &
0, is_known = .true.)
call global%set_real (var_str ("sqrts"),&
1000._default, is_known = .true.)
call global%set_log (var_str ("?recover_beams"), &
.false., is_known = .true.)
call global%set_log (var_str ("?update_sqme"), &
.true., is_known = .true.)
call global%set_log (var_str ("?update_weight"), &
.true., is_known = .true.)
call global%set_log (var_str ("?update_event"), &
.true., is_known = .true.)
model_name = "SM"
call global%select_model (model_name)
allocate (model)
call model%init_instance (global%model)
model_data => model
write (u, "(A)") "* Initialize process library and process"
write (u, "(A)")
allocate (lib_entry)
call lib_entry%init (libname)
lib => lib_entry%process_library_t
call global%add_prclib (lib_entry)
call prepare_resonance_test_library &
(lib, libname, procname, model_data, global, u)
write (u, "(A)")
write (u, "(A)") "* Initialize simulation object &
&with resonant subprocesses"
write (u, "(A)")
call global%set_log (var_str ("?resonance_history"), &
.true., is_known = .true.)
call global%set_real (var_str ("resonance_on_shell_limit"), &
10._default, is_known = .true.)
call simulation%init ([procname], &
integrate=.false., generate=.false., local=global)
call simulation%write_resonant_subprocess_data (u, 1)
write (u, "(A)")
write (u, "(A)") "* Resonant subprocesses: generated library"
write (u, "(A)")
libname_generated = procname // "_R"
lib => global%prclib_stack%get_library_ptr (libname_generated)
if (associated (lib)) call lib%write (u, libpath=.false.)
write (u, "(A)")
write (u, "(A)") "* Generated process stack"
write (u, "(A)")
call global%process_stack%show (u)
write (u, "(A)")
write (u, "(A)") "* Particle set"
write (u, "(A)")
pset = simulation%get_hard_particle_set (1)
call pset%write (u)
write (u, "(A)")
write (u, "(A)") "* Initialize object for direct access"
write (u, "(A)")
call eio_in%init_direct &
(n_beam = 0, n_in = 2, n_rem = 0, n_vir = 0, n_out = 3, &
pdg = [-11, 11, 1, -2, 24], model=global%model)
call eio_in%set_selection_indices (1, 1, 1, 1)
sqrts = global%get_rval (var_str ("sqrts"))
mw = 80._default ! deliberately slightly different from true mw
pp = sqrt (sqrts**2 - 4 * mw**2) / 2
allocate (p (5), m (5))
p(1) = vector4_moving (sqrts/2, sqrts/2, 3)
m(1) = 0
p(2) = vector4_moving (sqrts/2,-sqrts/2, 3)
m(2) = 0
p3(1) = pp/2
p3(2) = mw/2
p3(3) = 0
p(3) = vector4_moving (sqrts/4, vector3_moving (p3))
m(3) = 0
p3(2) = -mw/2
p(4) = vector4_moving (sqrts/4, vector3_moving (p3))
m(4) = 0
p(5) = vector4_moving (sqrts/2,-pp, 1)
m(5) = mw
call eio_in%set_momentum (p, m**2)
call eio_in%write (u)
write (u, "(A)")
write (u, "(A)") "* Transfer and show particle set"
write (u, "(A)")
call simulation%read_event (eio_in)
pset = simulation%get_hard_particle_set (1)
call pset%write (u)
write (u, "(A)")
write (u, "(A)") "* (Re)calculate matrix element"
write (u, "(A)")
call simulation%recalculate (recover_phs = .false.)
call simulation%evaluate_transforms ()
write (u, "(A)") "* Show event with sqme"
write (u, "(A)")
call eio_out%set_parameters (unit = u, &
weights = .true., pacify = .true., compressed = .true.)
call eio_out%init_out (var_str (""))
call simulation%write_event (eio_out)
write (u, "(A)")
write (u, "(A)") "* Write event to separate file &
&'simulations_14_event_verbose.log'"
u_verbose = free_unit ()
open (unit = u_verbose, file = "simulations_14_event_verbose.log", &
status = "replace", action = "write")
call simulation%write (u_verbose)
write (u_verbose, *)
call simulation%write_event (u_verbose, verbose =.true., testflag = .true.)
close (u_verbose)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call simulation%final ()
call global%final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: simulations_14"
end subroutine simulations_14
@ %def simulations_14
@
\subsubsection{Resonant subprocess simulation}
Prepare a process with resonances and enter resonant subprocesses in
the simulation object. Simulate events with selection of resonance
histories.
The process and its initialization is taken from [[processes_18]], but
we need a complete \oMega\ matrix element here.
<<Simulations: execute tests>>=
call test (simulations_15, "simulations_15", &
"resonant subprocesses in simulation", &
u, results)
<<Simulations: test declarations>>=
public :: simulations_15
<<Simulations: tests>>=
subroutine simulations_15 (u)
integer, intent(in) :: u
type(string_t) :: libname, libname_generated
type(string_t) :: procname
type(string_t) :: model_name
type(rt_data_t), target :: global
type(prclib_entry_t), pointer :: lib_entry
type(process_library_t), pointer :: lib
class(model_t), pointer :: model
class(model_data_t), pointer :: model_data
type(simulation_t), target :: simulation
real(default) :: sqrts
type(eio_dump_t) :: eio_out
integer :: u_verbose
write (u, "(A)") "* Test output: simulations_15"
write (u, "(A)") "* Purpose: generate event with resonant subprocess"
write (u, "(A)")
write (u, "(A)") "* Build and load a test library with one process"
write (u, "(A)")
call syntax_model_file_init ()
call syntax_phs_forest_init ()
libname = "simulations_15_lib"
procname = "simulations_15_p"
call global%global_init ()
call global%append_log (&
var_str ("?rebuild_phase_space"), .true., intrinsic = .true.)
call global%append_log (&
var_str ("?rebuild_grids"), .true., intrinsic = .true.)
call global%append_log (&
var_str ("?rebuild_events"), .true., intrinsic = .true.)
call global%set_log (var_str ("?omega_openmp"), &
.false., is_known = .true.)
call global%set_int (var_str ("seed"), &
0, is_known = .true.)
call global%set_real (var_str ("sqrts"),&
1000._default, is_known = .true.)
call global%set_log (var_str ("?recover_beams"), &
.false., is_known = .true.)
call global%set_log (var_str ("?update_sqme"), &
.true., is_known = .true.)
call global%set_log (var_str ("?update_weight"), &
.true., is_known = .true.)
call global%set_log (var_str ("?update_event"), &
.true., is_known = .true.)
call global%set_log (var_str ("?resonance_history"), &
.true., is_known = .true.)
call global%set_real (var_str ("resonance_on_shell_limit"), &
10._default, is_known = .true.)
model_name = "SM"
call global%select_model (model_name)
allocate (model)
call model%init_instance (global%model)
model_data => model
write (u, "(A)") "* Initialize process library and process"
write (u, "(A)")
allocate (lib_entry)
call lib_entry%init (libname)
lib => lib_entry%process_library_t
call global%add_prclib (lib_entry)
call prepare_resonance_test_library &
(lib, libname, procname, model_data, global, u)
write (u, "(A)")
write (u, "(A)") "* Initialize simulation object &
&with resonant subprocesses"
write (u, "(A)")
call global%it_list%init ([1], [1000])
call simulation%init ([procname], &
integrate=.true., generate=.true., local=global)
call simulation%write_resonant_subprocess_data (u, 1)
write (u, "(A)")
write (u, "(A)") "* Generate event"
write (u, "(A)")
call simulation%init_process_selector ()
call simulation%set_n_events_requested (1)
call simulation%generate ()
call eio_out%set_parameters (unit = u, &
weights = .true., pacify = .true., compressed = .true.)
call eio_out%init_out (var_str (""))
call simulation%write_event (eio_out)
write (u, "(A)")
write (u, "(A)") "* Write event to separate file &
&'simulations_15_event_verbose.log'"
u_verbose = free_unit ()
open (unit = u_verbose, file = "simulations_15_event_verbose.log", &
status = "replace", action = "write")
call simulation%write (u_verbose)
write (u_verbose, *)
call simulation%write_event (u_verbose, verbose =.true., testflag = .true.)
close (u_verbose)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call simulation%final ()
call global%final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: simulations_15"
end subroutine simulations_15
@ %def simulations_15
@
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\chapter{More Unit Tests}
This chapter collects some procedures for testing that can't be
provided at the point where the corresponding modules are defined,
because they use other modules of a different level.
(We should move them back, collecting the high-level functionality in
init/final hooks that we can set at runtime.)
\section{Expression Testing}
Expression objects are part of process and event objects, but the
process and event object modules should not depend on the
implementation of expressions. Here, we collect unit tests that
depend on expression implementation.
<<[[expr_tests_ut.f90]]>>=
<<File header>>
module expr_tests_ut
use unit_tests
use expr_tests_uti
<<Standard module head>>
<<Expr tests: public test>>
contains
<<Expr tests: test driver>>
end module expr_tests_ut
@ %def expr_tests_ut
@
<<[[expr_tests_uti.f90]]>>=
<<File header>>
module expr_tests_uti
<<Use kinds>>
<<Use strings>>
use format_defs, only: FMT_12
use format_utils, only: write_separator
use os_interface
use sm_qcd
use lorentz
use ifiles
use lexers
use parser
use model_data
use interactions, only: reset_interaction_counter
use process_libraries
use subevents
use subevt_expr
use rng_base
use mci_base
use phs_base
use variables, only: var_list_t
use eval_trees
use models
use prc_core
use prc_test
use process, only: process_t
use instances, only: process_instance_t
use events
use rng_base_ut, only: rng_test_factory_t
use phs_base_ut, only: phs_test_config_t
<<Standard module head>>
<<Expr tests: test declarations>>
contains
<<Expr tests: tests>>
<<Expr tests: test auxiliary>>
end module expr_tests_uti
@ %def expr_tests_uti
@
\subsection{Test}
This is the master for calling self-test procedures.
<<Expr tests: public test>>=
public :: subevt_expr_test
<<Expr tests: test driver>>=
subroutine subevt_expr_test (u, results)
integer, intent(in) :: u
type(test_results_t), intent(inout) :: results
<<Expr tests: execute tests>>
end subroutine subevt_expr_test
@ %def subevt_expr_test
@
\subsubsection{Parton-event expressions}
<<Expr tests: execute tests>>=
call test (subevt_expr_1, "subevt_expr_1", &
"parton-event expressions", &
u, results)
<<Expr tests: test declarations>>=
public :: subevt_expr_1
<<Expr tests: tests>>=
subroutine subevt_expr_1 (u)
integer, intent(in) :: u
type(string_t) :: expr_text
type(ifile_t) :: ifile
type(stream_t) :: stream
type(parse_tree_t) :: pt_cuts, pt_scale, pt_fac_scale, pt_ren_scale
type(parse_tree_t) :: pt_weight
type(parse_node_t), pointer :: pn_cuts, pn_scale, pn_fac_scale, pn_ren_scale
type(parse_node_t), pointer :: pn_weight
type(eval_tree_factory_t) :: expr_factory
type(os_data_t) :: os_data
type(model_t), target :: model
type(parton_expr_t), target :: expr
real(default) :: E, Ex, m
type(vector4_t), dimension(6) :: p
integer :: i, pdg
logical :: passed
real(default) :: scale, fac_scale, ren_scale, weight
write (u, "(A)") "* Test output: subevt_expr_1"
write (u, "(A)") "* Purpose: Set up a subevt and associated &
&process-specific expressions"
write (u, "(A)")
call syntax_pexpr_init ()
call syntax_model_file_init ()
call os_data%init ()
call model%read (var_str ("Test.mdl"), os_data)
write (u, "(A)") "* Expression texts"
write (u, "(A)")
expr_text = "all Pt > 100 [s]"
write (u, "(A,A)") "cuts = ", char (expr_text)
call ifile_clear (ifile)
call ifile_append (ifile, expr_text)
call stream_init (stream, ifile)
call parse_tree_init_lexpr (pt_cuts, stream, .true.)
call stream_final (stream)
pn_cuts => pt_cuts%get_root_ptr ()
expr_text = "sqrts"
write (u, "(A,A)") "scale = ", char (expr_text)
call ifile_clear (ifile)
call ifile_append (ifile, expr_text)
call stream_init (stream, ifile)
call parse_tree_init_expr (pt_scale, stream, .true.)
call stream_final (stream)
pn_scale => pt_scale%get_root_ptr ()
expr_text = "sqrts_hat"
write (u, "(A,A)") "fac_scale = ", char (expr_text)
call ifile_clear (ifile)
call ifile_append (ifile, expr_text)
call stream_init (stream, ifile)
call parse_tree_init_expr (pt_fac_scale, stream, .true.)
call stream_final (stream)
pn_fac_scale => pt_fac_scale%get_root_ptr ()
expr_text = "100"
write (u, "(A,A)") "ren_scale = ", char (expr_text)
call ifile_clear (ifile)
call ifile_append (ifile, expr_text)
call stream_init (stream, ifile)
call parse_tree_init_expr (pt_ren_scale, stream, .true.)
call stream_final (stream)
pn_ren_scale => pt_ren_scale%get_root_ptr ()
expr_text = "n_tot - n_in - n_out"
write (u, "(A,A)") "weight = ", char (expr_text)
call ifile_clear (ifile)
call ifile_append (ifile, expr_text)
call stream_init (stream, ifile)
call parse_tree_init_expr (pt_weight, stream, .true.)
call stream_final (stream)
pn_weight => pt_weight%get_root_ptr ()
call ifile_final (ifile)
write (u, "(A)")
write (u, "(A)") "* Initialize process expr"
write (u, "(A)")
call expr%setup_vars (1000._default)
call expr%var_list%append_real (var_str ("tolerance"), 0._default)
call expr%link_var_list (model%get_var_list_ptr ())
call expr_factory%init (pn_cuts)
call expr%setup_selection (expr_factory)
call expr_factory%init (pn_scale)
call expr%setup_scale (expr_factory)
call expr_factory%init (pn_fac_scale)
call expr%setup_fac_scale (expr_factory)
call expr_factory%init (pn_ren_scale)
call expr%setup_ren_scale (expr_factory)
call expr_factory%init (pn_weight)
call expr%setup_weight (expr_factory)
call write_separator (u)
call expr%write (u)
call write_separator (u)
write (u, "(A)")
write (u, "(A)") "* Fill subevt and evaluate expressions"
write (u, "(A)")
call subevt_init (expr%subevt_t, 6)
E = 500._default
Ex = 400._default
m = 125._default
pdg = 25
p(1) = vector4_moving (E, sqrt (E**2 - m**2), 3)
p(2) = vector4_moving (E, -sqrt (E**2 - m**2), 3)
p(3) = vector4_moving (Ex, sqrt (Ex**2 - m**2), 3)
p(4) = vector4_moving (Ex, -sqrt (Ex**2 - m**2), 3)
p(5) = vector4_moving (Ex, sqrt (Ex**2 - m**2), 1)
p(6) = vector4_moving (Ex, -sqrt (Ex**2 - m**2), 1)
call expr%reset_contents ()
do i = 1, 2
call subevt_set_beam (expr%subevt_t, i, pdg, p(i), m**2)
end do
do i = 3, 4
call subevt_set_incoming (expr%subevt_t, i, pdg, p(i), m**2)
end do
do i = 5, 6
call subevt_set_outgoing (expr%subevt_t, i, pdg, p(i), m**2)
end do
expr%sqrts_hat = subevt_get_sqrts_hat (expr%subevt_t)
expr%n_in = 2
expr%n_out = 2
expr%n_tot = 4
expr%subevt_filled = .true.
call expr%evaluate (passed, scale, fac_scale, ren_scale, weight)
write (u, "(A,L1)") "Event has passed = ", passed
write (u, "(A," // FMT_12 // ")") "Scale = ", scale
write (u, "(A," // FMT_12 // ")") "Factorization scale = ", fac_scale
write (u, "(A," // FMT_12 // ")") "Renormalization scale = ", ren_scale
write (u, "(A," // FMT_12 // ")") "Weight = ", weight
write (u, "(A)")
call write_separator (u)
call expr%write (u)
call write_separator (u)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call expr%final ()
call model%final ()
call syntax_model_file_final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: subevt_expr_1"
end subroutine subevt_expr_1
@ %def subevt_expr_1
@
\subsubsection{Parton-event expressions}
<<Expr tests: execute tests>>=
call test (subevt_expr_2, "subevt_expr_2", &
"parton-event expressions", &
u, results)
<<Expr tests: test declarations>>=
public :: subevt_expr_2
<<Expr tests: tests>>=
subroutine subevt_expr_2 (u)
integer, intent(in) :: u
type(string_t) :: expr_text
type(ifile_t) :: ifile
type(stream_t) :: stream
type(parse_tree_t) :: pt_selection
type(parse_tree_t) :: pt_reweight, pt_analysis
type(parse_node_t), pointer :: pn_selection
type(parse_node_t), pointer :: pn_reweight, pn_analysis
type(os_data_t) :: os_data
type(model_t), target :: model
type(eval_tree_factory_t) :: expr_factory
type(event_expr_t), target :: expr
real(default) :: E, Ex, m
type(vector4_t), dimension(6) :: p
integer :: i, pdg
logical :: passed
real(default) :: reweight
logical :: analysis_flag
write (u, "(A)") "* Test output: subevt_expr_2"
write (u, "(A)") "* Purpose: Set up a subevt and associated &
&process-specific expressions"
write (u, "(A)")
call syntax_pexpr_init ()
call syntax_model_file_init ()
call os_data%init ()
call model%read (var_str ("Test.mdl"), os_data)
write (u, "(A)") "* Expression texts"
write (u, "(A)")
expr_text = "all Pt > 100 [s]"
write (u, "(A,A)") "selection = ", char (expr_text)
call ifile_clear (ifile)
call ifile_append (ifile, expr_text)
call stream_init (stream, ifile)
call parse_tree_init_lexpr (pt_selection, stream, .true.)
call stream_final (stream)
pn_selection => pt_selection%get_root_ptr ()
expr_text = "n_tot - n_in - n_out"
write (u, "(A,A)") "reweight = ", char (expr_text)
call ifile_clear (ifile)
call ifile_append (ifile, expr_text)
call stream_init (stream, ifile)
call parse_tree_init_expr (pt_reweight, stream, .true.)
call stream_final (stream)
pn_reweight => pt_reweight%get_root_ptr ()
expr_text = "true"
write (u, "(A,A)") "analysis = ", char (expr_text)
call ifile_clear (ifile)
call ifile_append (ifile, expr_text)
call stream_init (stream, ifile)
call parse_tree_init_lexpr (pt_analysis, stream, .true.)
call stream_final (stream)
pn_analysis => pt_analysis%get_root_ptr ()
call ifile_final (ifile)
write (u, "(A)")
write (u, "(A)") "* Initialize process expr"
write (u, "(A)")
call expr%setup_vars (1000._default)
call expr%link_var_list (model%get_var_list_ptr ())
call expr%var_list%append_real (var_str ("tolerance"), 0._default)
call expr_factory%init (pn_selection)
call expr%setup_selection (expr_factory)
call expr_factory%init (pn_analysis)
call expr%setup_analysis (expr_factory)
call expr_factory%init (pn_reweight)
call expr%setup_reweight (expr_factory)
call write_separator (u)
call expr%write (u)
call write_separator (u)
write (u, "(A)")
write (u, "(A)") "* Fill subevt and evaluate expressions"
write (u, "(A)")
call subevt_init (expr%subevt_t, 6)
E = 500._default
Ex = 400._default
m = 125._default
pdg = 25
p(1) = vector4_moving (E, sqrt (E**2 - m**2), 3)
p(2) = vector4_moving (E, -sqrt (E**2 - m**2), 3)
p(3) = vector4_moving (Ex, sqrt (Ex**2 - m**2), 3)
p(4) = vector4_moving (Ex, -sqrt (Ex**2 - m**2), 3)
p(5) = vector4_moving (Ex, sqrt (Ex**2 - m**2), 1)
p(6) = vector4_moving (Ex, -sqrt (Ex**2 - m**2), 1)
call expr%reset_contents ()
do i = 1, 2
call subevt_set_beam (expr%subevt_t, i, pdg, p(i), m**2)
end do
do i = 3, 4
call subevt_set_incoming (expr%subevt_t, i, pdg, p(i), m**2)
end do
do i = 5, 6
call subevt_set_outgoing (expr%subevt_t, i, pdg, p(i), m**2)
end do
expr%sqrts_hat = subevt_get_sqrts_hat (expr%subevt_t)
expr%n_in = 2
expr%n_out = 2
expr%n_tot = 4
expr%subevt_filled = .true.
call expr%evaluate (passed, reweight, analysis_flag)
write (u, "(A,L1)") "Event has passed = ", passed
write (u, "(A," // FMT_12 // ")") "Reweighting factor = ", reweight
write (u, "(A,L1)") "Analysis flag = ", analysis_flag
write (u, "(A)")
call write_separator (u)
call expr%write (u)
call write_separator (u)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call expr%final ()
call model%final ()
call syntax_model_file_final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: subevt_expr_2"
end subroutine subevt_expr_2
@ %def subevt_expr_2
@
\subsubsection{Processes: handle partonic cuts}
Initialize a process and process instance, choose a sampling point and
fill the process instance, evaluating a given cut configuration.
We use the same trivial process as for the previous test. All
momentum and state dependence is trivial, so we just test basic
functionality.
<<Expr tests: execute tests>>=
call test (processes_5, "processes_5", &
"handle cuts (partonic event)", &
u, results)
<<Expr tests: test declarations>>=
public :: processes_5
<<Expr tests: tests>>=
subroutine processes_5 (u)
integer, intent(in) :: u
type(string_t) :: cut_expr_text
type(ifile_t) :: ifile
type(stream_t) :: stream
type(parse_tree_t) :: parse_tree
type(eval_tree_factory_t) :: expr_factory
type(process_library_t), target :: lib
type(string_t) :: libname
type(string_t) :: procname
type(os_data_t) :: os_data
type(model_t), pointer :: model_tmp
type(model_t), pointer :: model
type(var_list_t), target :: var_list
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
write (u, "(A)") "* Test output: processes_5"
write (u, "(A)") "* Purpose: create a process &
&and fill a process instance"
write (u, "(A)")
write (u, "(A)") "* Prepare a cut expression"
write (u, "(A)")
call syntax_pexpr_init ()
cut_expr_text = "all Pt > 100 [s]"
call ifile_append (ifile, cut_expr_text)
call stream_init (stream, ifile)
call parse_tree_init_lexpr (parse_tree, stream, .true.)
write (u, "(A)") "* Build and initialize a test process"
write (u, "(A)")
libname = "processes5"
procname = libname
call os_data%init ()
call prc_test_create_library (libname, lib)
call syntax_model_file_init ()
allocate (model_tmp)
call model_tmp%read (var_str ("Test.mdl"), os_data)
call var_list%init_snapshot (model_tmp%get_var_list_ptr ())
model => model_tmp
call reset_interaction_counter ()
call var_list%append_real (var_str ("tolerance"), 0._default)
call var_list%append_log (var_str ("?alphas_is_fixed"), .true.)
call var_list%append_int (var_str ("seed"), 0)
allocate (process)
call process%init (procname, lib, os_data, model, var_list)
call var_list%final ()
allocate (phs_test_config_t :: phs_config_template)
call process%setup_test_cores ()
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 and set cuts"
write (u, "(A)")
call process%setup_terms ()
call expr_factory%init (parse_tree%get_root_ptr ())
call process%set_cuts (expr_factory)
call process%write (.false., u, &
show_var_list=.true., show_expressions=.true., show_os_data=.false.)
write (u, "(A)")
write (u, "(A)") "* Create a process instance"
write (u, "(A)")
allocate (process_instance)
call process_instance%init (process)
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])
write (u, "(A)")
write (u, "(A)") "* Set up kinematics and subevt, check cuts (should fail)"
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 ()
call process_instance%write (u)
write (u, "(A)")
write (u, "(A)") "* Evaluate for another set (should succeed)"
write (u, "(A)")
call process_instance%reset ()
call process_instance%set_mcpar ([0.5_default, 0.125_default])
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 ()
call process_instance%evaluate_trace ()
call process_instance%write (u)
write (u, "(A)")
write (u, "(A)") "* Evaluate for another set using convenience procedure &
&(failure)"
write (u, "(A)")
call process_instance%evaluate_sqme (1, [0.0_default, 0.2_default])
call process_instance%write_header (u)
write (u, "(A)")
write (u, "(A)") "* Evaluate for another set using convenience procedure &
&(success)"
write (u, "(A)")
call process_instance%evaluate_sqme (1, [0.1_default, 0.2_default])
call process_instance%write_header (u)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call process_instance%final ()
deallocate (process_instance)
call process%final ()
deallocate (process)
call parse_tree_final (parse_tree)
call stream_final (stream)
call ifile_final (ifile)
call syntax_pexpr_final ()
call syntax_model_file_final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: processes_5"
end subroutine processes_5
@ %def processes_5
@ Trivial for testing: do not allocate the MCI record.
<<Expr tests: test auxiliary>>=
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{Processes: scales and such}
Initialize a process and process instance, choose a sampling point and
fill the process instance, evaluating a given cut configuration.
We use the same trivial process as for the previous test. All
momentum and state dependence is trivial, so we just test basic
functionality.
<<Expr tests: execute tests>>=
call test (processes_6, "processes_6", &
"handle scales and weight (partonic event)", &
u, results)
<<Expr tests: test declarations>>=
public :: processes_6
<<Expr tests: tests>>=
subroutine processes_6 (u)
integer, intent(in) :: u
type(string_t) :: expr_text
type(ifile_t) :: ifile
type(stream_t) :: stream
type(parse_tree_t) :: pt_scale, pt_fac_scale, pt_ren_scale, pt_weight
type(process_library_t), target :: lib
type(string_t) :: libname
type(string_t) :: procname
type(os_data_t) :: os_data
type(model_t), pointer :: model_tmp
type(model_t), pointer :: model
type(var_list_t), target :: var_list
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(eval_tree_factory_t) :: expr_factory
write (u, "(A)") "* Test output: processes_6"
write (u, "(A)") "* Purpose: create a process &
&and fill a process instance"
write (u, "(A)")
write (u, "(A)") "* Prepare expressions"
write (u, "(A)")
call syntax_pexpr_init ()
expr_text = "sqrts - 100 GeV"
write (u, "(A,A)") "scale = ", char (expr_text)
call ifile_clear (ifile)
call ifile_append (ifile, expr_text)
call stream_init (stream, ifile)
call parse_tree_init_expr (pt_scale, stream, .true.)
call stream_final (stream)
expr_text = "sqrts_hat"
write (u, "(A,A)") "fac_scale = ", char (expr_text)
call ifile_clear (ifile)
call ifile_append (ifile, expr_text)
call stream_init (stream, ifile)
call parse_tree_init_expr (pt_fac_scale, stream, .true.)
call stream_final (stream)
expr_text = "eval sqrt (M2) [collect [s]]"
write (u, "(A,A)") "ren_scale = ", char (expr_text)
call ifile_clear (ifile)
call ifile_append (ifile, expr_text)
call stream_init (stream, ifile)
call parse_tree_init_expr (pt_ren_scale, stream, .true.)
call stream_final (stream)
expr_text = "n_tot * n_in * n_out * (eval Phi / pi [s])"
write (u, "(A,A)") "weight = ", char (expr_text)
call ifile_clear (ifile)
call ifile_append (ifile, expr_text)
call stream_init (stream, ifile)
call parse_tree_init_expr (pt_weight, stream, .true.)
call stream_final (stream)
call ifile_final (ifile)
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 syntax_model_file_init ()
allocate (model_tmp)
call model_tmp%read (var_str ("Test.mdl"), os_data)
call var_list%init_snapshot (model_tmp%get_var_list_ptr ())
model => model_tmp
call var_list%append_log (var_str ("?alphas_is_fixed"), .true.)
call var_list%append_int (var_str ("seed"), 0)
call reset_interaction_counter ()
allocate (process)
call process%init (procname, lib, os_data, model, var_list)
call var_list%final ()
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 and set cuts"
write (u, "(A)")
call process%setup_terms ()
call expr_factory%init (pt_scale%get_root_ptr ())
call process%set_scale (expr_factory)
call expr_factory%init (pt_fac_scale%get_root_ptr ())
call process%set_fac_scale (expr_factory)
call expr_factory%init (pt_ren_scale%get_root_ptr ())
call process%set_ren_scale (expr_factory)
call expr_factory%init (pt_weight%get_root_ptr ())
call process%set_weight (expr_factory)
call process%write (.false., u, show_expressions=.true.)
write (u, "(A)")
write (u, "(A)") "* Create a process instance and evaluate"
write (u, "(A)")
allocate (process_instance)
call process_instance%init (process)
call process_instance%choose_mci (1)
call process_instance%evaluate_sqme (1, [0.5_default, 0.125_default])
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 parse_tree_final (pt_scale)
call parse_tree_final (pt_fac_scale)
call parse_tree_final (pt_ren_scale)
call parse_tree_final (pt_weight)
call syntax_pexpr_final ()
call syntax_model_file_final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: processes_6"
end subroutine processes_6
@ %def processes_6
@
\subsubsection{Event expressions}
After generating an event, fill the [[subevt]] and evaluate expressions for
selection, reweighting, and analysis.
<<Expr tests: execute tests>>=
call test (events_3, "events_3", &
"expression evaluation", &
u, results)
<<Expr tests: test declarations>>=
public :: events_3
<<Expr tests: tests>>=
subroutine events_3 (u)
use processes_ut, only: prepare_test_process, cleanup_test_process
integer, intent(in) :: u
type(string_t) :: expr_text
type(ifile_t) :: ifile
type(stream_t) :: stream
type(parse_tree_t) :: pt_selection, pt_reweight, pt_analysis
type(eval_tree_factory_t) :: expr_factory
type(event_t), allocatable, target :: event
type(process_t), allocatable, target :: process
type(process_instance_t), allocatable, target :: process_instance
type(os_data_t) :: os_data
type(model_t), pointer :: model
type(var_list_t), target :: var_list
write (u, "(A)") "* Test output: events_3"
write (u, "(A)") "* Purpose: generate an event and evaluate expressions"
write (u, "(A)")
call syntax_pexpr_init ()
write (u, "(A)") "* Expression texts"
write (u, "(A)")
expr_text = "all Pt > 100 [s]"
write (u, "(A,A)") "selection = ", char (expr_text)
call ifile_clear (ifile)
call ifile_append (ifile, expr_text)
call stream_init (stream, ifile)
call parse_tree_init_lexpr (pt_selection, stream, .true.)
call stream_final (stream)
expr_text = "1 + sqrts_hat / sqrts"
write (u, "(A,A)") "reweight = ", char (expr_text)
call ifile_clear (ifile)
call ifile_append (ifile, expr_text)
call stream_init (stream, ifile)
call parse_tree_init_expr (pt_reweight, stream, .true.)
call stream_final (stream)
expr_text = "true"
write (u, "(A,A)") "analysis = ", char (expr_text)
call ifile_clear (ifile)
call ifile_append (ifile, expr_text)
call stream_init (stream, ifile)
call parse_tree_init_lexpr (pt_analysis, stream, .true.)
call stream_final (stream)
call ifile_final (ifile)
write (u, "(A)")
write (u, "(A)") "* Initialize test process event"
call os_data%init ()
call syntax_model_file_init ()
allocate (model)
call model%read (var_str ("Test.mdl"), os_data)
call var_list%init_snapshot (model%get_var_list_ptr ())
call var_list%append_log (var_str ("?alphas_is_fixed"), .true.)
call var_list%append_int (var_str ("seed"), 0)
allocate (process)
allocate (process_instance)
call prepare_test_process (process, process_instance, model, var_list)
call var_list%final ()
call process_instance%setup_event_data ()
write (u, "(A)")
write (u, "(A)") "* Initialize event object and set expressions"
allocate (event)
call event%basic_init ()
call expr_factory%init (pt_selection%get_root_ptr ())
call event%set_selection (expr_factory)
call expr_factory%init (pt_reweight%get_root_ptr ())
call event%set_reweight (expr_factory)
call expr_factory%init (pt_analysis%get_root_ptr ())
call event%set_analysis (expr_factory)
call event%connect (process_instance, process%get_model_ptr ())
call event%expr%var_list%append_real (var_str ("tolerance"), 0._default)
call event%setup_expressions ()
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 and evaluate expressions"
write (u, "(A)")
call event%generate (1, [0.4_default, 0.4_default])
call event%set_index (42)
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 syntax_model_file_final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: events_3"
end subroutine events_3
@ %def events_3
@
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\chapter{Top Level}
The top level consists of
\begin{description}
\item[commands]
Defines generic command-list and command objects, and all specific
implementations. Each command type provides a specific
functionality. Together with the modules that provide expressions
and variables, this module defines the Sindarin language.
\item[whizard]
This module interprets streams of various kind in terms of the
command language. It also contains the unit-test feature. We also
define the externally visible procedures here, for the \whizard\ as
a library.
\item[main]
The driver for \whizard\ as a stand-alone program. Contains the
command-line interpreter.
\item[whizard\_c\_interface]
Alternative top-level procedures, for use in the context of a
C-compatible caller program.
\end{description}
\clearpage
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{Commands}
This module defines the command language of the main input file.
<<[[commands.f90]]>>=
<<File header>>
module commands
<<Use kinds>>
<<Use strings>>
<<Use debug>>
use io_units
use string_utils, only: lower_case, split_string, str
use format_utils, only: write_indent
use format_defs, only: FMT_14, FMT_19
use diagnostics
use constants, only: one
use physics_defs
use sorting
use sf_lhapdf, only: lhapdf_global_reset
use os_interface
use ifiles
use lexers
use syntax_rules
use parser
use analysis
use pdg_arrays
use variables, only: var_list_t, V_NONE, V_LOG, V_INT, V_REAL, V_CMPLX, V_STR, V_PDG
use observables, only: var_list_check_observable
use observables, only: var_list_check_result_var
use eval_trees
use models
use auto_components
use flavors
use polarizations
use particle_specifiers
use process_libraries
use process
use instances
use prclib_stacks
use slha_interface
use user_files
use eio_data
use rt_data
use process_configurations
use compilations, only: compile_library, compile_executable
use integrations, only: integrate_process
use restricted_subprocesses, only: get_libname_res
use restricted_subprocesses, only: spawn_resonant_subprocess_libraries
use event_streams
use simulations
use radiation_generator
<<Use mpi f08>>
<<Standard module head>>
<<Commands: public>>
<<Commands: types>>
<<Commands: variables>>
<<Commands: parameters>>
<<Commands: interfaces>>
contains
<<Commands: procedures>>
end module commands
@ %def commands
@
\subsection{The command type}
The command type is a generic type that holds any command, compiled
for execution.
Each command may come with its own local environment. The command list that
determines this environment is allocated as [[options]], if necessary. (It
has to be allocated as a pointer because the type definition is recursive.) The
local environment is available as a pointer which either points to the global
environment, or is explicitly allocated and initialized.
<<Commands: types>>=
type, abstract :: command_t
type(parse_node_t), pointer :: pn => null ()
class(command_t), pointer :: next => null ()
type(parse_node_t), pointer :: pn_opt => null ()
type(command_list_t), pointer :: options => null ()
type(rt_data_t), pointer :: local => null ()
contains
<<Commands: command: TBP>>
end type command_t
@ %def command_t
@ Finalizer: If there is an option list, finalize the option list and
deallocate. If not, the local environment is just a pointer.
<<Commands: command: TBP>>=
procedure :: final => command_final
<<Commands: procedures>>=
recursive subroutine command_final (cmd)
class(command_t), intent(inout) :: cmd
if (associated (cmd%options)) then
call cmd%options%final ()
deallocate (cmd%options)
call cmd%local%local_final ()
deallocate (cmd%local)
else
cmd%local => null ()
end if
end subroutine command_final
@ %def command_final
@ Allocate a command with the appropriate concrete type. Store the
parse node pointer in the command object, so we can reference to it
when compiling.
<<Commands: procedures>>=
subroutine dispatch_command (command, pn)
class(command_t), intent(inout), pointer :: command
type(parse_node_t), intent(in), target :: pn
select case (char (parse_node_get_rule_key (pn)))
case ("cmd_model")
allocate (cmd_model_t :: command)
case ("cmd_library")
allocate (cmd_library_t :: command)
case ("cmd_process")
allocate (cmd_process_t :: command)
case ("cmd_nlo")
allocate (cmd_nlo_t :: command)
case ("cmd_compile")
allocate (cmd_compile_t :: command)
case ("cmd_exec")
allocate (cmd_exec_t :: command)
case ("cmd_num", "cmd_complex", "cmd_real", "cmd_int", &
"cmd_log_decl", "cmd_log", "cmd_string", "cmd_string_decl", &
"cmd_alias", "cmd_result")
allocate (cmd_var_t :: command)
case ("cmd_slha")
allocate (cmd_slha_t :: command)
case ("cmd_show")
allocate (cmd_show_t :: command)
case ("cmd_clear")
allocate (cmd_clear_t :: command)
case ("cmd_expect")
allocate (cmd_expect_t :: command)
case ("cmd_beams")
allocate (cmd_beams_t :: command)
case ("cmd_beams_pol_density")
allocate (cmd_beams_pol_density_t :: command)
case ("cmd_beams_pol_fraction")
allocate (cmd_beams_pol_fraction_t :: command)
case ("cmd_beams_momentum")
allocate (cmd_beams_momentum_t :: command)
case ("cmd_beams_theta")
allocate (cmd_beams_theta_t :: command)
case ("cmd_beams_phi")
allocate (cmd_beams_phi_t :: command)
case ("cmd_cuts")
allocate (cmd_cuts_t :: command)
case ("cmd_scale")
allocate (cmd_scale_t :: command)
case ("cmd_fac_scale")
allocate (cmd_fac_scale_t :: command)
case ("cmd_ren_scale")
allocate (cmd_ren_scale_t :: command)
case ("cmd_weight")
allocate (cmd_weight_t :: command)
case ("cmd_selection")
allocate (cmd_selection_t :: command)
case ("cmd_reweight")
allocate (cmd_reweight_t :: command)
case ("cmd_iterations")
allocate (cmd_iterations_t :: command)
case ("cmd_integrate")
allocate (cmd_integrate_t :: command)
case ("cmd_observable")
allocate (cmd_observable_t :: command)
case ("cmd_histogram")
allocate (cmd_histogram_t :: command)
case ("cmd_plot")
allocate (cmd_plot_t :: command)
case ("cmd_graph")
allocate (cmd_graph_t :: command)
case ("cmd_record")
allocate (cmd_record_t :: command)
case ("cmd_analysis")
allocate (cmd_analysis_t :: command)
case ("cmd_alt_setup")
allocate (cmd_alt_setup_t :: command)
case ("cmd_unstable")
allocate (cmd_unstable_t :: command)
case ("cmd_stable")
allocate (cmd_stable_t :: command)
case ("cmd_polarized")
allocate (cmd_polarized_t :: command)
case ("cmd_unpolarized")
allocate (cmd_unpolarized_t :: command)
case ("cmd_sample_format")
allocate (cmd_sample_format_t :: command)
case ("cmd_simulate")
allocate (cmd_simulate_t :: command)
case ("cmd_rescan")
allocate (cmd_rescan_t :: command)
case ("cmd_write_analysis")
allocate (cmd_write_analysis_t :: command)
case ("cmd_compile_analysis")
allocate (cmd_compile_analysis_t :: command)
case ("cmd_open_out")
allocate (cmd_open_out_t :: command)
case ("cmd_close_out")
allocate (cmd_close_out_t :: command)
case ("cmd_printf")
allocate (cmd_printf_t :: command)
case ("cmd_scan")
allocate (cmd_scan_t :: command)
case ("cmd_if")
allocate (cmd_if_t :: command)
case ("cmd_include")
allocate (cmd_include_t :: command)
case ("cmd_export")
allocate (cmd_export_t :: command)
case ("cmd_quit")
allocate (cmd_quit_t :: command)
case default
print *, char (parse_node_get_rule_key (pn))
call msg_bug ("Command not implemented")
end select
command%pn => pn
end subroutine dispatch_command
@ %def dispatch_command
@ Output. We allow for indentation so we can display a command tree.
<<Commands: command: TBP>>=
procedure (command_write), deferred :: write
<<Commands: interfaces>>=
abstract interface
subroutine command_write (cmd, unit, indent)
import
class(command_t), intent(in) :: cmd
integer, intent(in), optional :: unit, indent
end subroutine command_write
end interface
@ %def command_write
@ Compile a command. The command type is already fixed, so this is a
deferred type-bound procedure.
<<Commands: command: TBP>>=
procedure (command_compile), deferred :: compile
<<Commands: interfaces>>=
abstract interface
subroutine command_compile (cmd, global)
import
class(command_t), intent(inout) :: cmd
type(rt_data_t), intent(inout), target :: global
end subroutine command_compile
end interface
@ %def command_compile
@ Execute a command. This will use and/or modify the runtime data
set. If the [[quit]] flag is set, the caller should terminate command
execution.
<<Commands: command: TBP>>=
procedure (command_execute), deferred :: execute
<<Commands: interfaces>>=
abstract interface
subroutine command_execute (cmd, global)
import
class(command_t), intent(inout) :: cmd
type(rt_data_t), intent(inout), target :: global
end subroutine command_execute
end interface
@ %def command_execute
@
\subsection{Options}
The [[options]] command list is allocated, initialized, and executed, if the
command is associated with an option text in curly braces. If present, a
separate local runtime data set [[local]] will be allocated and initialized;
otherwise, [[local]] becomes a pointer to the global dataset.
For output, we indent the options list.
<<Commands: command: TBP>>=
procedure :: write_options => command_write_options
<<Commands: procedures>>=
recursive subroutine command_write_options (cmd, unit, indent)
class(command_t), intent(in) :: cmd
integer, intent(in), optional :: unit, indent
integer :: ind
ind = 1; if (present (indent)) ind = indent + 1
if (associated (cmd%options)) call cmd%options%write (unit, ind)
end subroutine command_write_options
@ %def command_write_options
@ Compile the options list, if any. This implies initialization of the local
environment. Should be done once the [[pn_opt]] node has been assigned (if
applicable), but before the actual command compilation.
<<Commands: command: TBP>>=
procedure :: compile_options => command_compile_options
<<Commands: procedures>>=
recursive subroutine command_compile_options (cmd, global)
class(command_t), intent(inout) :: cmd
type(rt_data_t), intent(inout), target :: global
if (associated (cmd%pn_opt)) then
allocate (cmd%local)
call cmd%local%local_init (global)
call global%copy_globals (cmd%local)
allocate (cmd%options)
call cmd%options%compile (cmd%pn_opt, cmd%local)
call global%restore_globals (cmd%local)
call cmd%local%deactivate ()
else
cmd%local => global
end if
end subroutine command_compile_options
@ %def command_compile_options
@ Execute options. First prepare the local environment, then execute the
command list.
<<Commands: command: TBP>>=
procedure :: execute_options => cmd_execute_options
<<Commands: procedures>>=
recursive subroutine cmd_execute_options (cmd, global)
class(command_t), intent(inout) :: cmd
type(rt_data_t), intent(inout), target :: global
if (associated (cmd%options)) then
call cmd%local%activate ()
call cmd%options%execute (cmd%local)
end if
end subroutine cmd_execute_options
@ %def cmd_execute_options
@ This must be called after the parent command has been executed, to undo
temporary modifications to the environment. Note that some modifications to
[[global]] can become permanent.
<<Commands: command: TBP>>=
procedure :: reset_options => cmd_reset_options
<<Commands: procedures>>=
subroutine cmd_reset_options (cmd, global)
class(command_t), intent(inout) :: cmd
type(rt_data_t), intent(inout), target :: global
if (associated (cmd%options)) then
call cmd%local%deactivate (global)
end if
end subroutine cmd_reset_options
@ %def cmd_reset_options
@
\subsection{Specific command types}
\subsubsection{Model configuration}
The command declares a model, looks for the specified file and loads
it.
<<Commands: types>>=
type, extends (command_t) :: cmd_model_t
private
type(string_t) :: name
type(string_t) :: scheme
logical :: ufo_model = .false.
logical :: ufo_path_set = .false.
type(string_t) :: ufo_path
contains
<<Commands: cmd model: TBP>>
end type cmd_model_t
@ %def cmd_model_t
@ Output
<<Commands: cmd model: TBP>>=
procedure :: write => cmd_model_write
<<Commands: procedures>>=
subroutine cmd_model_write (cmd, unit, indent)
class(cmd_model_t), intent(in) :: cmd
integer, intent(in), optional :: unit, indent
integer :: u
u = given_output_unit (unit); if (u < 0) return
call write_indent (u, indent)
write (u, "(1x,A,1x,'""',A,'""')", advance="no") "model =", char (cmd%name)
if (cmd%ufo_model) then
if (cmd%ufo_path_set) then
write (u, "(1x,A,A,A)") "(ufo (", char (cmd%ufo_path), "))"
else
write (u, "(1x,A)") "(ufo)"
end if
else if (cmd%scheme /= "") then
write (u, "(1x,'(',A,')')") char (cmd%scheme)
else
write (u, *)
end if
end subroutine cmd_model_write
@ %def cmd_model_write
@ Compile. Get the model name and read the model from file, so it is
readily available when the command list is executed. If the model has a
scheme argument, take this into account.
Assign the model pointer in the [[global]] record, so it can be used for
(read-only) variable lookup while compiling further commands.
<<Commands: cmd model: TBP>>=
procedure :: compile => cmd_model_compile
<<Commands: procedures>>=
subroutine cmd_model_compile (cmd, global)
class(cmd_model_t), intent(inout) :: cmd
type(rt_data_t), intent(inout), target :: global
type(parse_node_t), pointer :: pn_name, pn_arg, pn_scheme
type(parse_node_t), pointer :: pn_ufo_arg, pn_path
type(model_t), pointer :: model
type(string_t) :: scheme
pn_name => cmd%pn%get_sub_ptr (3)
pn_arg => pn_name%get_next_ptr ()
if (associated (pn_arg)) then
pn_scheme => pn_arg%get_sub_ptr ()
else
pn_scheme => null ()
end if
cmd%name = pn_name%get_string ()
if (associated (pn_scheme)) then
select case (char (pn_scheme%get_rule_key ()))
case ("ufo_spec")
cmd%ufo_model = .true.
pn_ufo_arg => pn_scheme%get_sub_ptr (2)
if (associated (pn_ufo_arg)) then
pn_path => pn_ufo_arg%get_sub_ptr ()
cmd%ufo_path_set = .true.
cmd%ufo_path = pn_path%get_string ()
end if
case default
scheme = pn_scheme%get_string ()
select case (char (lower_case (scheme)))
case ("ufo"); cmd%ufo_model = .true.
case default; cmd%scheme = scheme
end select
end select
if (cmd%ufo_model) then
if (cmd%ufo_path_set) then
call preload_ufo_model (model, cmd%name, cmd%ufo_path)
else
call preload_ufo_model (model, cmd%name)
end if
else
call preload_model (model, cmd%name, cmd%scheme)
end if
else
cmd%scheme = ""
call preload_model (model, cmd%name)
end if
global%model => model
if (associated (global%model)) then
call global%model%link_var_list (global%var_list)
end if
contains
subroutine preload_model (model, name, scheme)
type(model_t), pointer, intent(out) :: model
type(string_t), intent(in) :: name
type(string_t), intent(in), optional :: scheme
model => null ()
if (associated (global%model)) then
if (global%model%matches (name, scheme)) then
model => global%model
end if
end if
if (.not. associated (model)) then
if (global%model_list%model_exists (name, scheme)) then
model => global%model_list%get_model_ptr (name, scheme)
else
call global%read_model (name, model, scheme)
end if
end if
end subroutine preload_model
subroutine preload_ufo_model (model, name, ufo_path)
type(model_t), pointer, intent(out) :: model
type(string_t), intent(in) :: name
type(string_t), intent(in), optional :: ufo_path
model => null ()
if (associated (global%model)) then
if (global%model%matches (name, ufo=.true., ufo_path=ufo_path)) then
model => global%model
end if
end if
if (.not. associated (model)) then
if (global%model_list%model_exists (name, &
ufo=.true., ufo_path=ufo_path)) then
model => global%model_list%get_model_ptr (name, &
ufo=.true., ufo_path=ufo_path)
else
call global%read_ufo_model (name, model, ufo_path=ufo_path)
end if
end if
end subroutine preload_ufo_model
end subroutine cmd_model_compile
@ %def cmd_model_compile
@ Execute: Insert a pointer into the global data record and reassign
the variable list.
<<Commands: cmd model: TBP>>=
procedure :: execute => cmd_model_execute
<<Commands: procedures>>=
subroutine cmd_model_execute (cmd, global)
class(cmd_model_t), intent(inout) :: cmd
type(rt_data_t), intent(inout), target :: global
if (cmd%ufo_model) then
if (cmd%ufo_path_set) then
call global%select_model (cmd%name, ufo=.true., ufo_path=cmd%ufo_path)
else
call global%select_model (cmd%name, ufo=.true.)
end if
else if (cmd%scheme /= "") then
call global%select_model (cmd%name, cmd%scheme)
else
call global%select_model (cmd%name)
end if
if (.not. associated (global%model)) &
call msg_fatal ("Switching to model '" &
// char (cmd%name) // "': model not found")
end subroutine cmd_model_execute
@ %def cmd_model_execute
@
\subsubsection{Library configuration}
We configure a process library that should hold the subsequently
defined processes. If the referenced library exists already, just
make it the currently active one.
<<Commands: types>>=
type, extends (command_t) :: cmd_library_t
private
type(string_t) :: name
contains
<<Commands: cmd library: TBP>>
end type cmd_library_t
@ %def cmd_library_t
@ Output.
<<Commands: cmd library: TBP>>=
procedure :: write => cmd_library_write
<<Commands: procedures>>=
subroutine cmd_library_write (cmd, unit, indent)
class(cmd_library_t), intent(in) :: cmd
integer, intent(in), optional :: unit, indent
integer :: u
u = given_output_unit (unit)
call write_indent (u, indent)
write (u, "(1x,A,1x,'""',A,'""')") "library =", char (cmd%name)
end subroutine cmd_library_write
@ %def cmd_library_write
@ Compile. Get the library name.
<<Commands: cmd library: TBP>>=
procedure :: compile => cmd_library_compile
<<Commands: procedures>>=
subroutine cmd_library_compile (cmd, global)
class(cmd_library_t), intent(inout) :: cmd
type(rt_data_t), intent(inout), target :: global
type(parse_node_t), pointer :: pn_name
pn_name => parse_node_get_sub_ptr (cmd%pn, 3)
cmd%name = parse_node_get_string (pn_name)
end subroutine cmd_library_compile
@ %def cmd_library_compile
@ Execute: Initialize a new library and push it on the library stack
(if it does not yet exist). Insert a pointer to the library into the
global data record. Then, try to load the library unless the
[[rebuild]] flag is set.
<<Commands: cmd library: TBP>>=
procedure :: execute => cmd_library_execute
<<Commands: procedures>>=
subroutine cmd_library_execute (cmd, global)
class(cmd_library_t), intent(inout) :: cmd
type(rt_data_t), intent(inout), target :: global
type(prclib_entry_t), pointer :: lib_entry
type(process_library_t), pointer :: lib
logical :: rebuild_library
lib => global%prclib_stack%get_library_ptr (cmd%name)
rebuild_library = &
global%var_list%get_lval (var_str ("?rebuild_library"))
if (.not. (associated (lib))) then
allocate (lib_entry)
call lib_entry%init (cmd%name)
lib => lib_entry%process_library_t
call global%add_prclib (lib_entry)
else
call global%update_prclib (lib)
end if
if (associated (lib) .and. .not. rebuild_library) then
call lib%update_status (global%os_data)
end if
end subroutine cmd_library_execute
@ %def cmd_library_execute
@
\subsubsection{Process configuration}
We define a process-configuration command as a specific type. The
incoming and outgoing particles are given evaluation-trees which we
transform to PDG-code arrays. For transferring to \oMega, they are
reconverted to strings.
For the incoming particles, we store parse nodes individually. We do
not yet resolve the outgoing state, so we store just a single parse
node.
This also includes the choice of method for the corresponding process:
[[omega]] for \oMega\ matrix elements as Fortran code, [[ovm]] for
\oMega\ matrix elements as a bytecode virtual machine, [[test]] for
special processes, [[unit_test]] for internal test matrix elements
generated by \whizard, [[template]] and [[template_unity]] for test
matrix elements generated by \whizard\ as Fortran code similar to the
\oMega\ code. If the one-loop program (OLP) \gosam\ is linked, also
matrix elements from there (at leading and next-to-leading order) can
be generated via [[gosam]].
<<Commands: types>>=
type, extends (command_t) :: cmd_process_t
private
type(string_t) :: id
integer :: n_in = 0
type(parse_node_p), dimension(:), allocatable :: pn_pdg_in
type(parse_node_t), pointer :: pn_out => null ()
contains
<<Commands: cmd process: TBP>>
end type cmd_process_t
@ %def cmd_process_t
@ Output. The particle expressions are not resolved, so we just list the
number of incoming particles.
<<Commands: cmd process: TBP>>=
procedure :: write => cmd_process_write
<<Commands: procedures>>=
subroutine cmd_process_write (cmd, unit, indent)
class(cmd_process_t), intent(in) :: cmd
integer, intent(in), optional :: unit, indent
integer :: u
u = given_output_unit (unit); if (u < 0) return
call write_indent (u, indent)
write (u, "(1x,A,A,A,I0,A)") "process: ", char (cmd%id), " (", &
size (cmd%pn_pdg_in), " -> X)"
call cmd%write_options (u, indent)
end subroutine cmd_process_write
@ %def cmd_process_write
@ Compile. Find and assign the parse nodes.
<<Commands: cmd process: TBP>>=
procedure :: compile => cmd_process_compile
<<Commands: procedures>>=
subroutine cmd_process_compile (cmd, global)
class(cmd_process_t), intent(inout) :: cmd
type(rt_data_t), intent(inout), target :: global
type(parse_node_t), pointer :: pn_id, pn_in, pn_codes
integer :: i
pn_id => parse_node_get_sub_ptr (cmd%pn, 2)
pn_in => parse_node_get_next_ptr (pn_id, 2)
cmd%pn_out => parse_node_get_next_ptr (pn_in, 2)
cmd%pn_opt => parse_node_get_next_ptr (cmd%pn_out)
call cmd%compile_options (global)
cmd%id = parse_node_get_string (pn_id)
cmd%n_in = parse_node_get_n_sub (pn_in)
pn_codes => parse_node_get_sub_ptr (pn_in)
allocate (cmd%pn_pdg_in (cmd%n_in))
do i = 1, cmd%n_in
cmd%pn_pdg_in(i)%ptr => pn_codes
pn_codes => parse_node_get_next_ptr (pn_codes)
end do
end subroutine cmd_process_compile
@ %def cmd_process_compile
@ Command execution. Evaluate the subevents, transform PDG codes
into strings, and add the current process configuration to the
process library.
The initial state will be unique (one or two particles). For the final state,
we allow for expressions. The expressions will be expanded until we have a
sum of final states. Each distinct final state will get its own process
component.
To identify equivalent final states, we transform the final state into
an array of PDG codes, which we sort and compare. If a particle entry
is actually a PDG array, only the first entry in the array is used for
the comparison. The user should make sure that there is no overlap
between different particles or arrays which would make the expansion
ambiguous.
There are two possibilities that a process contains more than one
component: by an explicit component statement by the user for
inclusive processes, or by having one process at NLO level. The first
option is determined in the routine [[scan_components]], and
determines [[n_components]].
<<Commands: cmd process: TBP>>=
procedure :: execute => cmd_process_execute
<<Commands: procedures>>=
subroutine cmd_process_execute (cmd, global)
class(cmd_process_t), intent(inout) :: cmd
type(rt_data_t), intent(inout), target :: global
type(pdg_array_t) :: pdg_in, pdg_out
type(pdg_array_t), dimension(:), allocatable :: pdg_out_tab
type(string_t), dimension(:), allocatable :: prt_in
type(string_t) :: prt_out, prt_out1
type(process_configuration_t) :: prc_config
type(prt_expr_t) :: prt_expr_out
type(prt_spec_t), dimension(:), allocatable :: prt_spec_in
type(prt_spec_t), dimension(:), allocatable :: prt_spec_out
type(var_list_t), pointer :: var_list
integer, dimension(:), allocatable :: pdg
integer, dimension(:), allocatable :: i_term
integer, dimension(:), allocatable :: nlo_comp
integer :: i, j, n_in, n_out, n_terms, n_components
logical :: nlo_fixed_order
logical :: qcd_corr, qed_corr
type(string_t), dimension(:), allocatable :: prt_in_nlo, prt_out_nlo
type(radiation_generator_t) :: radiation_generator
type(pdg_list_t) :: pl_in, pl_out, pl_excluded_gauge_splittings
type(string_t) :: method, born_me_method, loop_me_method, &
correlation_me_method, real_tree_me_method, dglap_me_method
integer, dimension(:), allocatable :: i_list
logical :: use_real_finite
logical :: gks_active
logical :: initial_state_colored
integer :: comp_mult
integer :: gks_multiplicity
integer :: n_components_init
integer :: alpha_power, alphas_power
logical :: requires_soft_mismatch, requires_dglap_remnants
if (debug_on) call msg_debug (D_CORE, "cmd_process_execute")
var_list => cmd%local%get_var_list_ptr ()
n_in = size (cmd%pn_pdg_in)
allocate (prt_in (n_in), prt_spec_in (n_in))
do i = 1, n_in
pdg_in = &
eval_pdg_array (cmd%pn_pdg_in(i)%ptr, var_list)
prt_in(i) = make_flavor_string (pdg_in, cmd%local%model)
prt_spec_in(i) = new_prt_spec (prt_in(i))
end do
call compile_prt_expr &
(prt_expr_out, cmd%pn_out, var_list, cmd%local%model)
call prt_expr_out%expand ()
call scan_components ()
allocate (nlo_comp (n_components))
nlo_fixed_order = cmd%local%nlo_fixed_order
gks_multiplicity = var_list%get_ival (var_str ('gks_multiplicity'))
gks_active = gks_multiplicity > 2
call check_for_nlo_corrections ()
method = var_list%get_sval (var_str ("$method"))
born_me_method = var_list%get_sval (var_str ("$born_me_method"))
if (born_me_method == var_str ("")) born_me_method = method
use_real_finite = var_list%get_lval (var_str ('?nlo_use_real_partition'))
if (nlo_fixed_order) then
real_tree_me_method = &
var_list%get_sval (var_str ("$real_tree_me_method"))
if (real_tree_me_method == var_str ("")) &
real_tree_me_method = method
loop_me_method = var_list%get_sval (var_str ("$loop_me_method"))
if (loop_me_method == var_str ("")) &
loop_me_method = method
correlation_me_method = &
var_list%get_sval (var_str ("$correlation_me_method"))
if (correlation_me_method == var_str ("")) &
correlation_me_method = method
dglap_me_method = var_list%get_sval (var_str ("$dglap_me_method"))
if (dglap_me_method == var_str ("")) &
dglap_me_method = method
call check_nlo_options (cmd%local)
end if
call determine_needed_components ()
call prc_config%init (cmd%id, n_in, n_components_init, &
cmd%local%model, cmd%local%var_list, &
nlo_process = nlo_fixed_order)
alpha_power = var_list%get_ival (var_str ("alpha_power"))
alphas_power = var_list%get_ival (var_str ("alphas_power"))
call prc_config%set_coupling_powers (alpha_power, alphas_power)
call setup_components ()
call prc_config%record (cmd%local)
contains
<<Commands: cmd process execute procedures>>
end subroutine cmd_process_execute
@ %def cmd_process_execute
@
<<Commands: cmd process execute procedures>>=
elemental function is_threshold (method)
logical :: is_threshold
type(string_t), intent(in) :: method
is_threshold = method == var_str ("threshold")
end function is_threshold
subroutine check_threshold_consistency ()
if (nlo_fixed_order .and. is_threshold (born_me_method)) then
if (.not. (is_threshold (real_tree_me_method) .and. is_threshold (loop_me_method) &
.and. is_threshold (correlation_me_method))) then
print *, 'born: ', char (born_me_method)
print *, 'real: ', char (real_tree_me_method)
print *, 'loop: ', char (loop_me_method)
print *, 'correlation: ', char (correlation_me_method)
call msg_fatal ("Inconsistent methods: All components need to be threshold")
end if
end if
end subroutine check_threshold_consistency
@ %def check_threshold_consistency
<<Commands: cmd process execute procedures>>=
subroutine check_for_nlo_corrections ()
type(string_t) :: nlo_correction_type
type(pdg_array_t), dimension(:), allocatable :: pdg
if (nlo_fixed_order .or. gks_active) then
nlo_correction_type = &
var_list%get_sval (var_str ('$nlo_correction_type'))
select case (char(nlo_correction_type))
case ("QCD")
qcd_corr = .true.; qed_corr = .false.
case ("EW")
qcd_corr = .false.; qed_corr = .true.
case ("Full")
qcd_corr =.true.; qed_corr = .true.
case default
call msg_fatal ("Invalid NLO correction type! " // &
"Valid inputs are: QCD, EW, Full (default: QCD)")
end select
call check_for_excluded_gauge_boson_splitting_partners ()
call setup_radiation_generator ()
end if
if (nlo_fixed_order) then
call radiation_generator%find_splittings ()
if (debug2_active (D_CORE)) then
print *, ''
print *, 'Found (pdg) splittings: '
do i = 1, radiation_generator%if_table%get_length ()
call radiation_generator%if_table%get_pdg_out (i, pdg)
call pdg_array_write_set (pdg)
print *, '----------------'
end do
end if
nlo_fixed_order = radiation_generator%contains_emissions ()
if (.not. nlo_fixed_order) call msg_warning &
(arr = [var_str ("No NLO corrections found for process ") // &
cmd%id // var_str("."), var_str ("Proceed with usual " // &
"leading-order integration and simulation")])
end if
end subroutine check_for_nlo_corrections
@ %def check_for_nlo_corrections
@
<<Commands: cmd process execute procedures>>=
subroutine check_for_excluded_gauge_boson_splitting_partners ()
type(string_t) :: str_excluded_partners
type(string_t), dimension(:), allocatable :: excluded_partners
type(pdg_list_t) :: pl_tmp, pl_anti
integer :: i, n_anti
str_excluded_partners = var_list%get_sval &
(var_str ("$exclude_gauge_splittings"))
if (str_excluded_partners == "") then
return
else
call split_string (str_excluded_partners, &
var_str (":"), excluded_partners)
call pl_tmp%init (size (excluded_partners))
do i = 1, size (excluded_partners)
call pl_tmp%set (i, &
cmd%local%model%get_pdg (excluded_partners(i), .true.))
end do
call pl_tmp%create_antiparticles (pl_anti, n_anti)
call pl_excluded_gauge_splittings%init (pl_tmp%get_size () + n_anti)
do i = 1, pl_tmp%get_size ()
call pl_excluded_gauge_splittings%set (i, pl_tmp%get(i))
end do
do i = 1, n_anti
j = i + pl_tmp%get_size ()
call pl_excluded_gauge_splittings%set (j, pl_anti%get(i))
end do
end if
end subroutine check_for_excluded_gauge_boson_splitting_partners
@ %def check_for_excluded_gauge_boson_splitting_partners
@
<<Commands: cmd process execute procedures>>=
subroutine determine_needed_components ()
type(string_t) :: fks_method
comp_mult = 1
if (nlo_fixed_order) then
fks_method = var_list%get_sval (var_str ('$fks_mapping_type'))
call check_threshold_consistency ()
requires_soft_mismatch = fks_method == var_str ('resonances')
comp_mult = needed_extra_components (requires_dglap_remnants, &
use_real_finite, requires_soft_mismatch)
allocate (i_list (comp_mult))
else if (gks_active) then
call radiation_generator%generate_multiple &
(gks_multiplicity, cmd%local%model)
comp_mult = radiation_generator%get_n_gks_states () + 1
end if
n_components_init = n_components * comp_mult
end subroutine determine_needed_components
@ %def determine_needed_components
@
<<Commands: cmd process execute procedures>>=
subroutine setup_radiation_generator ()
call split_prt (prt_spec_in, n_in, pl_in)
call split_prt (prt_spec_out, n_out, pl_out)
call radiation_generator%init (pl_in, pl_out, &
pl_excluded_gauge_splittings, qcd = qcd_corr, qed = qed_corr)
call radiation_generator%set_n (n_in, n_out, 0)
initial_state_colored = pdg_in%has_colored_particles ()
if ((n_in == 2 .and. initial_state_colored) .or. qed_corr) then
requires_dglap_remnants = n_in == 2 .and. initial_state_colored
call radiation_generator%set_initial_state_emissions ()
else
requires_dglap_remnants = .false.
end if
call radiation_generator%set_constraints (.false., .false., .true., .true.)
call radiation_generator%setup_if_table (cmd%local%model)
end subroutine setup_radiation_generator
@ %def setup_radiation_generator
@
<<Commands: cmd process execute procedures>>=
subroutine scan_components ()
n_terms = prt_expr_out%get_n_terms ()
allocate (pdg_out_tab (n_terms))
allocate (i_term (n_terms), source = 0)
n_components = 0
SCAN: do i = 1, n_terms
if (allocated (pdg)) deallocate (pdg)
call prt_expr_out%term_to_array (prt_spec_out, i)
n_out = size (prt_spec_out)
allocate (pdg (n_out))
do j = 1, n_out
prt_out = prt_spec_out(j)%to_string ()
call split (prt_out, prt_out1, ":")
pdg(j) = cmd%local%model%get_pdg (prt_out1)
end do
pdg_out = sort (pdg)
do j = 1, n_components
if (pdg_out == pdg_out_tab(j)) cycle SCAN
end do
n_components = n_components + 1
i_term(n_components) = i
pdg_out_tab(n_components) = pdg_out
end do SCAN
end subroutine scan_components
@
<<Commands: cmd process execute procedures>>=
subroutine split_prt (prt, n_out, pl)
type(prt_spec_t), intent(in), dimension(:), allocatable :: prt
integer, intent(in) :: n_out
type(pdg_list_t), intent(out) :: pl
type(pdg_array_t) :: pdg
type(string_t) :: prt_string, prt_tmp
integer, parameter :: max_particle_number = 25
integer, dimension(max_particle_number) :: i_particle
integer :: i, j, n
i_particle = 0
call pl%init (n_out)
do i = 1, n_out
n = 1
prt_string = prt(i)%to_string ()
do
call split (prt_string, prt_tmp, ":")
if (prt_tmp /= "") then
i_particle(n) = cmd%local%model%get_pdg (prt_tmp)
n = n + 1
else
exit
end if
end do
call pdg_array_init (pdg, n - 1)
do j = 1, n - 1
call pdg%set (j, i_particle(j))
end do
call pl%set (i, pdg)
call pdg_array_delete (pdg)
end do
end subroutine split_prt
@ %def split_prt
@
<<Commands: cmd process execute procedures>>=
subroutine setup_components()
integer :: k, i_comp, add_index
i_comp = 0
add_index = 0
if (debug_on) call msg_debug (D_CORE, "setup_components")
do i = 1, n_components
call prt_expr_out%term_to_array (prt_spec_out, i_term(i))
if (nlo_fixed_order) then
associate (selected_nlo_parts => cmd%local%selected_nlo_parts)
if (debug_on) call msg_debug (D_CORE, "Setting up this NLO component:", &
i_comp + 1)
call prc_config%setup_component (i_comp + 1, &
prt_spec_in, prt_spec_out, &
cmd%local%model, var_list, BORN, &
can_be_integrated = selected_nlo_parts (BORN))
call radiation_generator%generate_real_particle_strings &
(prt_in_nlo, prt_out_nlo)
if (debug_on) call msg_debug (D_CORE, "Setting up this NLO component:", &
i_comp + 2)
call prc_config%setup_component (i_comp + 2, &
new_prt_spec (prt_in_nlo), new_prt_spec (prt_out_nlo), &
cmd%local%model, var_list, NLO_REAL, &
can_be_integrated = selected_nlo_parts (NLO_REAL))
if (debug_on) call msg_debug (D_CORE, "Setting up this NLO component:", &
i_comp + 3)
call prc_config%setup_component (i_comp + 3, &
prt_spec_in, prt_spec_out, &
cmd%local%model, var_list, NLO_VIRTUAL, &
can_be_integrated = selected_nlo_parts (NLO_VIRTUAL))
if (debug_on) call msg_debug (D_CORE, "Setting up this NLO component:", &
i_comp + 4)
call prc_config%setup_component (i_comp + 4, &
prt_spec_in, prt_spec_out, &
cmd%local%model, var_list, NLO_SUBTRACTION, &
can_be_integrated = selected_nlo_parts (NLO_SUBTRACTION))
do k = 1, 4
i_list(k) = i_comp + k
end do
if (requires_dglap_remnants) then
if (debug_on) call msg_debug (D_CORE, "Setting up this NLO component:", &
i_comp + 5)
call prc_config%setup_component (i_comp + 5, &
prt_spec_in, prt_spec_out, &
cmd%local%model, var_list, NLO_DGLAP, &
can_be_integrated = selected_nlo_parts (NLO_DGLAP))
i_list(5) = i_comp + 5
add_index = add_index + 1
end if
if (use_real_finite) then
if (debug_on) call msg_debug (D_CORE, "Setting up this NLO component:", &
i_comp + 5 + add_index)
call prc_config%setup_component (i_comp + 5 + add_index, &
new_prt_spec (prt_in_nlo), new_prt_spec (prt_out_nlo), &
cmd%local%model, var_list, NLO_REAL, &
can_be_integrated = selected_nlo_parts (NLO_REAL))
i_list(5 + add_index) = i_comp + 5 + add_index
add_index = add_index + 1
end if
if (requires_soft_mismatch) then
if (debug_on) call msg_debug (D_CORE, "Setting up this NLO component:", &
i_comp + 5 + add_index)
call prc_config%setup_component (i_comp + 5 + add_index, &
prt_spec_in, prt_spec_out, &
cmd%local%model, var_list, NLO_MISMATCH, &
can_be_integrated = selected_nlo_parts (NLO_MISMATCH))
i_list(5 + add_index) = i_comp + 5 + add_index
end if
call prc_config%set_component_associations (i_list, &
requires_dglap_remnants, use_real_finite, &
requires_soft_mismatch)
end associate
else if (gks_active) then
call prc_config%setup_component (i_comp + 1, prt_spec_in, &
prt_spec_out, cmd%local%model, var_list, BORN, &
can_be_integrated = .true.)
call radiation_generator%reset_queue ()
do j = 1, comp_mult
prt_out_nlo = radiation_generator%get_next_state ()
call prc_config%setup_component (i_comp + 1 + j, &
new_prt_spec (prt_in), new_prt_spec (prt_out_nlo), &
cmd%local%model, var_list, GKS, can_be_integrated = .false.)
end do
else
call prc_config%setup_component (i, &
prt_spec_in, prt_spec_out, &
cmd%local%model, var_list, can_be_integrated = .true.)
end if
i_comp = i_comp + comp_mult
end do
end subroutine setup_components
@
@ These three functions should be bundled with the logicals they depend
on into an object (the pcm?).
<<Commands: procedures>>=
subroutine check_nlo_options (local)
type(rt_data_t), intent(in) :: local
type(var_list_t), pointer :: var_list => null ()
real :: mult_real, mult_virt, mult_dglap
logical :: nlo, combined, powheg
logical :: case_lo_but_any_other
logical :: case_nlo_powheg_but_not_combined
- logical :: vamp_equivalences_enabled
logical :: fixed_order_nlo_events
var_list => local%get_var_list_ptr ()
nlo = local%nlo_fixed_order
combined = var_list%get_lval (var_str ('?combined_nlo_integration'))
powheg = var_list%get_lval (var_str ('?powheg_matching'))
case_lo_but_any_other = .not. nlo .and. any ([combined, powheg])
case_nlo_powheg_but_not_combined = &
nlo .and. powheg .and. .not. combined
if (case_lo_but_any_other) then
call msg_fatal ("Option mismatch: Leading order process is selected &
&but either powheg_matching or combined_nlo_integration &
&is set to true.")
else if (case_nlo_powheg_but_not_combined) then
call msg_fatal ("POWHEG requires the 'combined_nlo_integration'-option &
&to be set to true.")
end if
fixed_order_nlo_events = &
var_list%get_lval (var_str ('?fixed_order_nlo_events'))
if (fixed_order_nlo_events .and. .not. combined .and. &
count (local%selected_nlo_parts) > 1) &
call msg_fatal ("Option mismatch: Fixed order NLO events of multiple ", &
[var_str ("components are requested, but ?combined_nlo_integration "), &
var_str ("is false. You can either switch to the combined NLO "), &
var_str ("integration mode for the full process or choose one "), &
var_str ("individual NLO component to generate events with.")])
associate (nlo_parts => local%selected_nlo_parts)
! TODO (PS-2020-03-26): This technically leaves the possibility to skip this
! message by deactivating the dglap component for a proton collider process.
! To circumvent this, the selected_nlo_parts should be refactored.
if (combined .and. .not. (nlo_parts(BORN) &
.and. nlo_parts(NLO_VIRTUAL) .and. nlo_parts(NLO_REAL))) then
call msg_fatal ("A combined integration of anything else than", &
[var_str ("all NLO components together is not supported.")])
end if
end associate
mult_real = local%var_list%get_rval (var_str ("mult_call_real"))
mult_virt = local%var_list%get_rval (var_str ("mult_call_virt"))
mult_dglap = local%var_list%get_rval (var_str ("mult_call_dglap"))
if (combined .and. (mult_real /= one .or. mult_virt /= one .or. mult_dglap /= one)) then
call msg_warning ("mult_call_real, mult_call_virt and mult_call_dglap", &
[var_str (" will be ignored because of ?combined_nlo_integration = true. ")])
end if
- vamp_equivalences_enabled = var_list%get_lval &
- (var_str ('?use_vamp_equivalences'))
- if (nlo .and. vamp_equivalences_enabled) &
- call msg_warning ("You have not disabled VAMP equivalences. ", &
- [var_str (" Note that they are automatically switched off "), &
- var_str (" for NLO calculations.")])
end subroutine check_nlo_options
@ %def check_nlo_options
@ There are four components for a general NLO process, namely Born,
real, virtual and subtraction. There will be additional components for
DGLAP remnant, in case real contributions are split into singular and
finite pieces, and for resonance-aware FKS subtraction for the needed
soft mismatch component.
<<Commands: procedures>>=
pure function needed_extra_components (requires_dglap_remnant, &
use_real_finite, requires_soft_mismatch) result (n)
integer :: n
logical, intent(in) :: requires_dglap_remnant, &
use_real_finite, requires_soft_mismatch
n = 4
if (requires_dglap_remnant) n = n + 1
if (use_real_finite) n = n + 1
if (requires_soft_mismatch) n = n + 1
end function needed_extra_components
@ %def needed_extra_components
@ This is a method of the eval tree, but cannot be coded inside the
[[expressions]] module since it uses the [[model]] and [[flv]] types
which are not available there.
<<Commands: procedures>>=
function make_flavor_string (aval, model) result (prt)
type(string_t) :: prt
type(pdg_array_t), intent(in) :: aval
type(model_t), intent(in), target :: model
integer, dimension(:), allocatable :: pdg
type(flavor_t), dimension(:), allocatable :: flv
integer :: i
pdg = aval
allocate (flv (size (pdg)))
call flv%init (pdg, model)
if (size (pdg) /= 0) then
prt = flv(1)%get_name ()
do i = 2, size (flv)
prt = prt // ":" // flv(i)%get_name ()
end do
else
prt = "?"
end if
end function make_flavor_string
@ %def make_flavor_string
@ Create a pdg array from a particle-specification array
<<Commands: procedures>>=
function make_pdg_array (prt, model) result (pdg_array)
type(prt_spec_t), intent(in), dimension(:) :: prt
type(model_t), intent(in) :: model
integer, dimension(:), allocatable :: aval
type(pdg_array_t) :: pdg_array
type(flavor_t) :: flv
integer :: k
allocate (aval (size (prt)))
do k = 1, size (prt)
call flv%init (prt(k)%to_string (), model)
aval (k) = flv%get_pdg ()
end do
pdg_array = aval
end function make_pdg_array
@ %def make_pdg_array
@ Compile a (possible nested) expression, to obtain a
particle-specifier expression which we can process further.
<<Commands: procedures>>=
recursive subroutine compile_prt_expr (prt_expr, pn, var_list, model)
type(prt_expr_t), intent(out) :: prt_expr
type(parse_node_t), intent(in), target :: pn
type(var_list_t), intent(in), target :: var_list
type(model_t), intent(in), target :: model
type(parse_node_t), pointer :: pn_entry, pn_term, pn_addition
type(pdg_array_t) :: pdg
type(string_t) :: prt_string
integer :: n_entry, n_term, i
select case (char (parse_node_get_rule_key (pn)))
case ("prt_state_list")
n_entry = parse_node_get_n_sub (pn)
pn_entry => parse_node_get_sub_ptr (pn)
if (n_entry == 1) then
call compile_prt_expr (prt_expr, pn_entry, var_list, model)
else
call prt_expr%init_list (n_entry)
select type (x => prt_expr%x)
type is (prt_spec_list_t)
do i = 1, n_entry
call compile_prt_expr (x%expr(i), pn_entry, var_list, model)
pn_entry => parse_node_get_next_ptr (pn_entry)
end do
end select
end if
case ("prt_state_sum")
n_term = parse_node_get_n_sub (pn)
pn_term => parse_node_get_sub_ptr (pn)
pn_addition => pn_term
if (n_term == 1) then
call compile_prt_expr (prt_expr, pn_term, var_list, model)
else
call prt_expr%init_sum (n_term)
select type (x => prt_expr%x)
type is (prt_spec_sum_t)
do i = 1, n_term
call compile_prt_expr (x%expr(i), pn_term, var_list, model)
pn_addition => parse_node_get_next_ptr (pn_addition)
if (associated (pn_addition)) &
pn_term => parse_node_get_sub_ptr (pn_addition, 2)
end do
end select
end if
case ("cexpr")
pdg = eval_pdg_array (pn, var_list)
prt_string = make_flavor_string (pdg, model)
call prt_expr%init_spec (new_prt_spec (prt_string))
case default
call parse_node_write_rec (pn)
call msg_bug ("compile prt expr: impossible syntax rule")
end select
end subroutine compile_prt_expr
@ %def compile_prt_expr
@
\subsubsection{Initiating a NLO calculation}
<<Commands: types>>=
type, extends (command_t) :: cmd_nlo_t
private
integer, dimension(:), allocatable :: nlo_component
contains
<<Commands: cmd nlo: TBP>>
end type cmd_nlo_t
@ %def cmd_nlo_t
@
<<Commands: cmd nlo: TBP>>=
procedure :: write => cmd_nlo_write
<<Commands: procedures>>=
subroutine cmd_nlo_write (cmd, unit, indent)
class(cmd_nlo_t), intent(in) :: cmd
integer, intent(in), optional :: unit, indent
end subroutine cmd_nlo_write
@ %def cmd_nlo_write
@ As it is, the NLO calculation is switched on by putting {nlo} behind the process definition. This should be made nicer in the future.
<<Commands: cmd nlo: TBP>>=
procedure :: compile => cmd_nlo_compile
<<Commands: procedures>>=
subroutine cmd_nlo_compile (cmd, global)
class(cmd_nlo_t), intent(inout) :: cmd
type(rt_data_t), intent(inout), target :: global
type(parse_node_t), pointer :: pn_arg, pn_comp
integer :: i, n_comp
pn_arg => parse_node_get_sub_ptr (cmd%pn, 3)
if (associated (pn_arg)) then
n_comp = parse_node_get_n_sub (pn_arg)
allocate (cmd%nlo_component (n_comp))
pn_comp => parse_node_get_sub_ptr (pn_arg)
i = 0
do while (associated (pn_comp))
i = i + 1
cmd%nlo_component(i) = component_status &
(parse_node_get_rule_key (pn_comp))
pn_comp => parse_node_get_next_ptr (pn_comp)
end do
else
allocate (cmd%nlo_component (0))
end if
end subroutine cmd_nlo_compile
@ %def cmd_nlo_compile
@ % TODO (PS-2020-03-26): This routine still needs to be adopted
% to cope with more than 5 components.
<<Commands: cmd nlo: TBP>>=
procedure :: execute => cmd_nlo_execute
<<Commands: procedures>>=
subroutine cmd_nlo_execute (cmd, global)
class(cmd_nlo_t), intent(inout) :: cmd
type(rt_data_t), intent(inout), target :: global
type(string_t) :: string
integer :: n, i, j
logical, dimension(0:5) :: selected_nlo_parts
if (debug_on) call msg_debug (D_CORE, "cmd_nlo_execute")
selected_nlo_parts = .false.
if (allocated (cmd%nlo_component)) then
n = size (cmd%nlo_component)
else
n = 0
end if
do i = 1, n
select case (cmd%nlo_component (i))
case (BORN, NLO_VIRTUAL, NLO_MISMATCH, NLO_DGLAP, NLO_REAL)
selected_nlo_parts(cmd%nlo_component (i)) = .true.
case (NLO_FULL)
selected_nlo_parts = .true.
selected_nlo_parts (NLO_SUBTRACTION) = .false.
case default
string = var_str ("")
do j = BORN, NLO_DGLAP
string = string // component_status (j) // ", "
end do
string = string // component_status (NLO_FULL)
call msg_fatal ("Invalid NLO mode. Valid modes are: " // &
char (string))
end select
end do
global%nlo_fixed_order = any (selected_nlo_parts)
global%selected_nlo_parts = selected_nlo_parts
allocate (global%nlo_component (size (cmd%nlo_component)))
global%nlo_component = cmd%nlo_component
end subroutine cmd_nlo_execute
@ %def cmd_nlo_execute
@
\subsubsection{Process compilation}
<<Commands: types>>=
type, extends (command_t) :: cmd_compile_t
private
type(string_t), dimension(:), allocatable :: libname
logical :: make_executable = .false.
type(string_t) :: exec_name
contains
<<Commands: cmd compile: TBP>>
end type cmd_compile_t
@ %def cmd_compile_t
@ Output: list all libraries to be compiled.
<<Commands: cmd compile: TBP>>=
procedure :: write => cmd_compile_write
<<Commands: procedures>>=
subroutine cmd_compile_write (cmd, unit, indent)
class(cmd_compile_t), intent(in) :: cmd
integer, intent(in), optional :: unit, indent
integer :: u, i
u = given_output_unit (unit); if (u < 0) return
call write_indent (u, indent)
write (u, "(1x,A)", advance="no") "compile ("
if (allocated (cmd%libname)) then
do i = 1, size (cmd%libname)
if (i > 1) write (u, "(A,1x)", advance="no") ","
write (u, "('""',A,'""')", advance="no") char (cmd%libname(i))
end do
end if
write (u, "(A)") ")"
end subroutine cmd_compile_write
@ %def cmd_compile_write
@ Compile the libraries specified in the argument. If the argument is
empty, compile all libraries which can be found in the process library stack.
<<Commands: cmd compile: TBP>>=
procedure :: compile => cmd_compile_compile
<<Commands: procedures>>=
subroutine cmd_compile_compile (cmd, global)
class(cmd_compile_t), intent(inout) :: cmd
type(rt_data_t), intent(inout), target :: global
type(parse_node_t), pointer :: pn_cmd, pn_clause, pn_arg, pn_lib
type(parse_node_t), pointer :: pn_exec_name_spec, pn_exec_name
integer :: n_lib, i
pn_cmd => parse_node_get_sub_ptr (cmd%pn)
pn_clause => parse_node_get_sub_ptr (pn_cmd)
pn_exec_name_spec => parse_node_get_sub_ptr (pn_clause, 2)
if (associated (pn_exec_name_spec)) then
pn_exec_name => parse_node_get_sub_ptr (pn_exec_name_spec, 2)
else
pn_exec_name => null ()
end if
pn_arg => parse_node_get_next_ptr (pn_clause)
cmd%pn_opt => parse_node_get_next_ptr (pn_cmd)
call cmd%compile_options (global)
if (associated (pn_arg)) then
n_lib = parse_node_get_n_sub (pn_arg)
else
n_lib = 0
end if
if (n_lib > 0) then
allocate (cmd%libname (n_lib))
pn_lib => parse_node_get_sub_ptr (pn_arg)
do i = 1, n_lib
cmd%libname(i) = parse_node_get_string (pn_lib)
pn_lib => parse_node_get_next_ptr (pn_lib)
end do
end if
if (associated (pn_exec_name)) then
cmd%make_executable = .true.
cmd%exec_name = parse_node_get_string (pn_exec_name)
end if
end subroutine cmd_compile_compile
@ %def cmd_compile_compile
@ Command execution. Generate code, write driver, compile and link.
Do this for all libraries in the list.
If no library names have been given and stored while compiling this
command, we collect all libraries from the current stack and compile
those.
As a bonus, a compiled library may be able to spawn new process
libraries. For instance, a processes may ask for a set of resonant
subprocesses which go into their own library, but this can be
determined only after the process is available as a compiled object.
Therefore, the compilation loop is implemented as a recursive internal
subroutine.
We can compile static libraries (which actually just loads them). However, we
can't incorporate in a generated executable.
<<Commands: cmd compile: TBP>>=
procedure :: execute => cmd_compile_execute
<<Commands: procedures>>=
subroutine cmd_compile_execute (cmd, global)
class(cmd_compile_t), intent(inout) :: cmd
type(rt_data_t), intent(inout), target :: global
type(string_t), dimension(:), allocatable :: libname, libname_static
integer :: i, n_lib
<<Commands: cmd compile execute: extra variables>>
<<Commands: cmd compile execute: extra init>>
if (allocated (cmd%libname)) then
allocate (libname (size (cmd%libname)))
libname = cmd%libname
else
call cmd%local%prclib_stack%get_names (libname)
end if
n_lib = size (libname)
if (cmd%make_executable) then
call get_prclib_static (libname_static)
do i = 1, n_lib
if (any (libname_static == libname(i))) then
call msg_fatal ("Compile: can't include static library '" &
// char (libname(i)) // "'")
end if
end do
call compile_executable (cmd%exec_name, libname, cmd%local)
else
call compile_libraries (libname)
call global%update_prclib &
(global%prclib_stack%get_library_ptr (libname(n_lib)))
end if
<<Commands: cmd compile execute: extra end init>>
contains
recursive subroutine compile_libraries (libname)
type(string_t), dimension(:), intent(in) :: libname
integer :: i
type(string_t), dimension(:), allocatable :: libname_extra
type(process_library_t), pointer :: lib_saved
do i = 1, size (libname)
call compile_library (libname(i), cmd%local)
lib_saved => global%prclib
call spawn_extra_libraries &
(libname(i), cmd%local, global, libname_extra)
call compile_libraries (libname_extra)
call global%update_prclib (lib_saved)
end do
end subroutine compile_libraries
end subroutine cmd_compile_execute
@ %def cmd_compile_execute
<<Commands: cmd compile execute: extra variables>>=
<<Commands: cmd compile execute: extra init>>=
<<Commands: cmd compile execute: extra end init>>=
@ The parallelization leads to undefined behavior while writing simultaneously to one file.
The master worker has to initialize single-handed the corresponding library files.
The slave worker will wait with a blocking [[MPI_BCAST]] until they receive a logical flag.
<<MPI: Commands: cmd compile execute: extra variables>>=
logical :: compile_init
integer :: rank, n_size
<<MPI: Commands: cmd compile execute: extra init>>=
if (debug_on) call msg_debug (D_MPI, "cmd_compile_execute")
compile_init = .false.
call mpi_get_comm_id (n_size, rank)
if (debug_on) call msg_debug (D_MPI, "n_size", rank)
if (debug_on) call msg_debug (D_MPI, "rank", rank)
if (rank /= 0) then
if (debug_on) call msg_debug (D_MPI, "wait for master")
call MPI_bcast (compile_init, 1, MPI_LOGICAL, 0, MPI_COMM_WORLD)
else
compile_init = .true.
end if
if (compile_init) then
<<MPI: Commands: cmd compile execute: extra end init>>=
if (rank == 0) then
if (debug_on) call msg_debug (D_MPI, "load slaves")
call MPI_bcast (compile_init, 1, MPI_LOGICAL, 0, MPI_COMM_WORLD)
end if
end if
call MPI_barrier (MPI_COMM_WORLD)
@ %def cmd_compile_execute_mpi
@
This is the interface to the external procedure which returns the
names of all static libraries which are part of the executable. (The
default is none.) The routine must allocate the array.
<<Commands: public>>=
public :: get_prclib_static
<<Commands: interfaces>>=
interface
subroutine get_prclib_static (libname)
import
type(string_t), dimension(:), intent(inout), allocatable :: libname
end subroutine get_prclib_static
end interface
@ %def get_prclib_static
@
Spawn extra libraries. We can ask the processes within a compiled
library, which we have available at this point, whether they need additional
processes which should go into their own libraries.
The current implementation only concerns resonant subprocesses.
Note that the libraries should be created (source code), but not be
compiled here. This is done afterwards.
<<Commands: procedures>>=
subroutine spawn_extra_libraries (libname, local, global, libname_extra)
type(string_t), intent(in) :: libname
type(rt_data_t), intent(inout), target :: local
type(rt_data_t), intent(inout), target :: global
type(string_t), dimension(:), allocatable, intent(out) :: libname_extra
type(string_t), dimension(:), allocatable :: libname_res
allocate (libname_extra (0))
call spawn_resonant_subprocess_libraries &
(libname, local, global, libname_res)
if (allocated (libname_res)) libname_extra = [libname_extra, libname_res]
end subroutine spawn_extra_libraries
@ %def spawn_extra_libraries
@
\subsubsection{Execute a shell command}
The argument is a string expression.
<<Commands: types>>=
type, extends (command_t) :: cmd_exec_t
private
type(parse_node_t), pointer :: pn_command => null ()
contains
<<Commands: cmd exec: TBP>>
end type cmd_exec_t
@ %def cmd_exec_t
@ Simply tell the status.
<<Commands: cmd exec: TBP>>=
procedure :: write => cmd_exec_write
<<Commands: procedures>>=
subroutine cmd_exec_write (cmd, unit, indent)
class(cmd_exec_t), intent(in) :: cmd
integer, intent(in), optional :: unit, indent
integer :: u
u = given_output_unit (unit); if (u < 0) return
call write_indent (u, indent)
if (associated (cmd%pn_command)) then
write (u, "(1x,A)") "exec: [command associated]"
else
write (u, "(1x,A)") "exec: [undefined]"
end if
end subroutine cmd_exec_write
@ %def cmd_exec_write
@ Compile the exec command.
<<Commands: cmd exec: TBP>>=
procedure :: compile => cmd_exec_compile
<<Commands: procedures>>=
subroutine cmd_exec_compile (cmd, global)
class(cmd_exec_t), intent(inout) :: cmd
type(rt_data_t), intent(inout), target :: global
type(parse_node_t), pointer :: pn_arg, pn_command
pn_arg => parse_node_get_sub_ptr (cmd%pn, 2)
pn_command => parse_node_get_sub_ptr (pn_arg)
cmd%pn_command => pn_command
end subroutine cmd_exec_compile
@ %def cmd_exec_compile
@ Execute the specified shell command.
<<Commands: cmd exec: TBP>>=
procedure :: execute => cmd_exec_execute
<<Commands: procedures>>=
subroutine cmd_exec_execute (cmd, global)
class(cmd_exec_t), intent(inout) :: cmd
type(rt_data_t), intent(inout), target :: global
type(string_t) :: command
logical :: is_known
integer :: status
command = eval_string (cmd%pn_command, global%var_list, is_known=is_known)
if (is_known) then
if (command /= "") then
call os_system_call (command, status, verbose=.true.)
if (status /= 0) then
write (msg_buffer, "(A,I0)") "Return code = ", status
call msg_message ()
call msg_error ("System command returned with nonzero status code")
end if
end if
end if
end subroutine cmd_exec_execute
@ %def cmd_exec_execute
@
\subsubsection{Variable declaration}
A variable can have various types. Hold the definition as an eval
tree.
There are intrinsic variables, user variables, and model variables.
The latter are further divided in independent variables and dependent
variables.
Regarding model variables: When dealing with them, we always look at
two variable lists in parallel. The global (or local) variable list
contains the user-visible values. It includes variables that
correspond to variables in the current model's list. These, in turn,
are pointers to the model's parameter list, so the model is always in
sync, internally. To keep the global variable list in sync with the
model, the global variables carry the [[is_copy]] property and contain
a separate pointer to the model variable. (The pointer is reassigned
whenever the model changes.) Modifying the global variable changes
two values simultaneously: the visible value and the model variable,
via this extra pointer. After each modification, we update dependent
parameters in the model variable list and re-synchronize the global
variable list (again, using these pointers) with the model variable
this. In the last step, modifications in the derived parameters
become visible.
When we integrate a process, we capture the current variable list of
the current model in a separate model instance, which is stored in the
process object. Thus, the model parameters associated to this process
at this time are preserved for the lifetime of the process object.
When we generate or rescan events, we can again capture a local model
variable list in a model instance. This allows us to reweight event
by event with different parameter sets simultaneously.
<<Commands: types>>=
type, extends (command_t) :: cmd_var_t
private
type(string_t) :: name
integer :: type = V_NONE
type(parse_node_t), pointer :: pn_value => null ()
logical :: is_intrinsic = .false.
logical :: is_model_var = .false.
contains
<<Commands: cmd var: TBP>>
end type cmd_var_t
@ %def cmd_var_t
@ Output. We know name, type, and properties, but not the value.
<<Commands: cmd var: TBP>>=
procedure :: write => cmd_var_write
<<Commands: procedures>>=
subroutine cmd_var_write (cmd, unit, indent)
class(cmd_var_t), intent(in) :: cmd
integer, intent(in), optional :: unit, indent
integer :: u
u = given_output_unit (unit); if (u < 0) return
call write_indent (u, indent)
write (u, "(1x,A,A,A)", advance="no") "var: ", char (cmd%name), " ("
select case (cmd%type)
case (V_NONE)
write (u, "(A)", advance="no") "[unknown]"
case (V_LOG)
write (u, "(A)", advance="no") "logical"
case (V_INT)
write (u, "(A)", advance="no") "int"
case (V_REAL)
write (u, "(A)", advance="no") "real"
case (V_CMPLX)
write (u, "(A)", advance="no") "complex"
case (V_STR)
write (u, "(A)", advance="no") "string"
case (V_PDG)
write (u, "(A)", advance="no") "alias"
end select
if (cmd%is_intrinsic) then
write (u, "(A)", advance="no") ", intrinsic"
end if
if (cmd%is_model_var) then
write (u, "(A)", advance="no") ", model"
end if
write (u, "(A)") ")"
end subroutine cmd_var_write
@ %def cmd_var_write
@ Compile the lhs and determine the variable name and type. Check whether
this variable can be created or modified as requested, and append the value to
the variable list, if appropriate. The value is initially undefined.
The rhs is assigned to a pointer, to be compiled and evaluated when the
command is executed.
<<Commands: cmd var: TBP>>=
procedure :: compile => cmd_var_compile
<<Commands: procedures>>=
subroutine cmd_var_compile (cmd, global)
class(cmd_var_t), intent(inout) :: cmd
type(rt_data_t), intent(inout), target :: global
type(parse_node_t), pointer :: pn_var, pn_name
type(parse_node_t), pointer :: pn_result, pn_proc
type(string_t) :: var_name
type(var_list_t), pointer :: model_vars
integer :: type
logical :: new
pn_result => null ()
new = .false.
select case (char (parse_node_get_rule_key (cmd%pn)))
case ("cmd_log_decl"); type = V_LOG
pn_var => parse_node_get_sub_ptr (cmd%pn, 2)
if (.not. associated (pn_var)) then ! handle masked syntax error
cmd%type = V_NONE; return
end if
pn_name => parse_node_get_sub_ptr (pn_var, 2)
new = .true.
case ("cmd_log"); type = V_LOG
pn_name => parse_node_get_sub_ptr (cmd%pn, 2)
case ("cmd_int"); type = V_INT
pn_name => parse_node_get_sub_ptr (cmd%pn, 2)
new = .true.
case ("cmd_real"); type = V_REAL
pn_name => parse_node_get_sub_ptr (cmd%pn, 2)
new = .true.
case ("cmd_complex"); type = V_CMPLX
pn_name => parse_node_get_sub_ptr (cmd%pn, 2)
new = .true.
case ("cmd_num"); type = V_NONE
pn_name => parse_node_get_sub_ptr (cmd%pn)
case ("cmd_string_decl"); type = V_STR
pn_var => parse_node_get_sub_ptr (cmd%pn, 2)
if (.not. associated (pn_var)) then ! handle masked syntax error
cmd%type = V_NONE; return
end if
pn_name => parse_node_get_sub_ptr (pn_var, 2)
new = .true.
case ("cmd_string"); type = V_STR
pn_name => parse_node_get_sub_ptr (cmd%pn, 2)
case ("cmd_alias"); type = V_PDG
pn_name => parse_node_get_sub_ptr (cmd%pn, 2)
new = .true.
case ("cmd_result"); type = V_REAL
pn_name => parse_node_get_sub_ptr (cmd%pn)
pn_result => parse_node_get_sub_ptr (pn_name)
pn_proc => parse_node_get_next_ptr (pn_result)
case default
call parse_node_mismatch &
("logical|int|real|complex|?|$|alias|var_name", cmd%pn) ! $
end select
if (.not. associated (pn_name)) then ! handle masked syntax error
cmd%type = V_NONE; return
end if
if (.not. associated (pn_result)) then
var_name = parse_node_get_string (pn_name)
else
var_name = parse_node_get_key (pn_result) &
// "(" // parse_node_get_string (pn_proc) // ")"
end if
select case (type)
case (V_LOG); var_name = "?" // var_name
case (V_STR); var_name = "$" // var_name ! $
end select
if (associated (global%model)) then
model_vars => global%model%get_var_list_ptr ()
else
model_vars => null ()
end if
call var_list_check_observable (global%var_list, var_name, type)
call var_list_check_result_var (global%var_list, var_name, type)
call global%var_list%check_user_var (var_name, type, new)
cmd%name = var_name
cmd%pn_value => parse_node_get_next_ptr (pn_name, 2)
if (global%var_list%contains (cmd%name, follow_link = .false.)) then
! local variable
cmd%is_intrinsic = &
global%var_list%is_intrinsic (cmd%name, follow_link = .false.)
cmd%type = &
global%var_list%get_type (cmd%name, follow_link = .false.)
else
if (new) cmd%type = type
if (global%var_list%contains (cmd%name, follow_link = .true.)) then
! global variable
cmd%is_intrinsic = &
global%var_list%is_intrinsic (cmd%name, follow_link = .true.)
if (cmd%type == V_NONE) then
cmd%type = &
global%var_list%get_type (cmd%name, follow_link = .true.)
end if
else if (associated (model_vars)) then ! check model variable
cmd%is_model_var = &
model_vars%contains (cmd%name)
if (cmd%type == V_NONE) then
cmd%type = &
model_vars%get_type (cmd%name)
end if
end if
if (cmd%type == V_NONE) then
call msg_fatal ("Variable '" // char (cmd%name) // "' " &
// "set without declaration")
cmd%type = V_NONE; return
end if
if (cmd%is_model_var) then
if (new) then
call msg_fatal ("Model variable '" // char (cmd%name) // "' " &
// "redeclared")
else if (model_vars%is_locked (cmd%name)) then
call msg_fatal ("Model variable '" // char (cmd%name) // "' " &
// "is locked")
end if
else
select case (cmd%type)
case (V_LOG)
call global%var_list%append_log (cmd%name, &
intrinsic=cmd%is_intrinsic, user=.true.)
case (V_INT)
call global%var_list%append_int (cmd%name, &
intrinsic=cmd%is_intrinsic, user=.true.)
case (V_REAL)
call global%var_list%append_real (cmd%name, &
intrinsic=cmd%is_intrinsic, user=.true.)
case (V_CMPLX)
call global%var_list%append_cmplx (cmd%name, &
intrinsic=cmd%is_intrinsic, user=.true.)
case (V_PDG)
call global%var_list%append_pdg_array (cmd%name, &
intrinsic=cmd%is_intrinsic, user=.true.)
case (V_STR)
call global%var_list%append_string (cmd%name, &
intrinsic=cmd%is_intrinsic, user=.true.)
end select
end if
end if
end subroutine cmd_var_compile
@ %def cmd_var_compile
@ Execute. Evaluate the definition and assign the variable value.
If the variable is a model variable, take a snapshot of the model if necessary
and set the variable in the local model.
<<Commands: cmd var: TBP>>=
procedure :: execute => cmd_var_execute
<<Commands: procedures>>=
subroutine cmd_var_execute (cmd, global)
class(cmd_var_t), intent(inout) :: cmd
type(rt_data_t), intent(inout), target :: global
type(var_list_t), pointer :: var_list
real(default) :: rval
logical :: is_known, pacified
var_list => global%get_var_list_ptr ()
if (cmd%is_model_var) then
pacified = var_list%get_lval (var_str ("?pacify"))
rval = eval_real (cmd%pn_value, var_list, is_known=is_known)
call global%model_set_real &
(cmd%name, rval, verbose=.true., pacified=pacified)
else if (cmd%type /= V_NONE) then
call cmd%set_value (var_list, verbose=.true.)
end if
end subroutine cmd_var_execute
@ %def cmd_var_execute
@ Copy the value to the variable list, where the variable should already exist.
<<Commands: cmd var: TBP>>=
procedure :: set_value => cmd_var_set_value
<<Commands: procedures>>=
subroutine cmd_var_set_value (var, var_list, verbose, model_name)
class(cmd_var_t), intent(inout) :: var
type(var_list_t), intent(inout), target :: var_list
logical, intent(in), optional :: verbose
type(string_t), intent(in), optional :: model_name
logical :: lval, pacified
integer :: ival
real(default) :: rval
complex(default) :: cval
type(pdg_array_t) :: aval
type(string_t) :: sval
logical :: is_known
pacified = var_list%get_lval (var_str ("?pacify"))
select case (var%type)
case (V_LOG)
lval = eval_log (var%pn_value, var_list, is_known=is_known)
call var_list%set_log (var%name, &
lval, is_known, verbose=verbose, model_name=model_name)
case (V_INT)
ival = eval_int (var%pn_value, var_list, is_known=is_known)
call var_list%set_int (var%name, &
ival, is_known, verbose=verbose, model_name=model_name)
case (V_REAL)
rval = eval_real (var%pn_value, var_list, is_known=is_known)
call var_list%set_real (var%name, &
rval, is_known, verbose=verbose, &
model_name=model_name, pacified = pacified)
case (V_CMPLX)
cval = eval_cmplx (var%pn_value, var_list, is_known=is_known)
call var_list%set_cmplx (var%name, &
cval, is_known, verbose=verbose, &
model_name=model_name, pacified = pacified)
case (V_PDG)
aval = eval_pdg_array (var%pn_value, var_list, is_known=is_known)
call var_list%set_pdg_array (var%name, &
aval, is_known, verbose=verbose, model_name=model_name)
case (V_STR)
sval = eval_string (var%pn_value, var_list, is_known=is_known)
call var_list%set_string (var%name, &
sval, is_known, verbose=verbose, model_name=model_name)
end select
end subroutine cmd_var_set_value
@ %def cmd_var_set_value
@
\subsubsection{SLHA}
Read a SLHA (SUSY Les Houches Accord) file to fill the appropriate
model parameters. We do not access the current variable record, but
directly work on the appropriate SUSY model, which is loaded if
necessary.
We may be in read or write mode. In the latter case, we may write
just input parameters, or the complete spectrum, or the spectrum with
all decays.
<<Commands: types>>=
type, extends (command_t) :: cmd_slha_t
private
type(string_t) :: file
logical :: write_mode = .false.
contains
<<Commands: cmd slha: TBP>>
end type cmd_slha_t
@ %def cmd_slha_t
@ Output.
<<Commands: cmd slha: TBP>>=
procedure :: write => cmd_slha_write
<<Commands: procedures>>=
subroutine cmd_slha_write (cmd, unit, indent)
class(cmd_slha_t), intent(in) :: cmd
integer, intent(in), optional :: unit, indent
integer :: u
u = given_output_unit (unit); if (u < 0) return
call write_indent (u, indent)
write (u, "(1x,A,A)") "slha: file name = ", char (cmd%file)
write (u, "(1x,A,L1)") "slha: write mode = ", cmd%write_mode
end subroutine cmd_slha_write
@ %def cmd_slha_write
@ Compile. Read the filename and store it.
<<Commands: cmd slha: TBP>>=
procedure :: compile => cmd_slha_compile
<<Commands: procedures>>=
subroutine cmd_slha_compile (cmd, global)
class(cmd_slha_t), intent(inout) :: cmd
type(rt_data_t), intent(inout), target :: global
type(parse_node_t), pointer :: pn_key, pn_arg, pn_file
pn_key => parse_node_get_sub_ptr (cmd%pn)
pn_arg => parse_node_get_next_ptr (pn_key)
pn_file => parse_node_get_sub_ptr (pn_arg)
call cmd%compile_options (global)
cmd%pn_opt => parse_node_get_next_ptr (pn_arg)
select case (char (parse_node_get_key (pn_key)))
case ("read_slha")
cmd%write_mode = .false.
case ("write_slha")
cmd%write_mode = .true.
case default
call parse_node_mismatch ("read_slha|write_slha", cmd%pn)
end select
cmd%file = parse_node_get_string (pn_file)
end subroutine cmd_slha_compile
@ %def cmd_slha_compile
@ Execute. Read or write the specified SLHA file. Behind the scenes,
this will first read the WHIZARD model file, then read the SLHA file
and assign the SLHA parameters as far as determined by
[[dispatch_slha]]. Finally, the global variables are synchronized
with the model. This is similar to executing [[cmd_model]].
<<Commands: cmd slha: TBP>>=
procedure :: execute => cmd_slha_execute
<<Commands: procedures>>=
subroutine cmd_slha_execute (cmd, global)
class(cmd_slha_t), intent(inout) :: cmd
type(rt_data_t), intent(inout), target :: global
logical :: input, spectrum, decays
if (cmd%write_mode) then
input = .true.
spectrum = .false.
decays = .false.
if (.not. associated (cmd%local%model)) then
call msg_fatal ("SLHA: local model not associated")
return
end if
call slha_write_file &
(cmd%file, cmd%local%model, &
input = input, spectrum = spectrum, decays = decays)
else
if (.not. associated (global%model)) then
call msg_fatal ("SLHA: global model not associated")
return
end if
call dispatch_slha (cmd%local%var_list, &
input = input, spectrum = spectrum, decays = decays)
call global%ensure_model_copy ()
call slha_read_file &
(cmd%file, cmd%local%os_data, global%model, &
input = input, spectrum = spectrum, decays = decays)
end if
end subroutine cmd_slha_execute
@ %def cmd_slha_execute
@
\subsubsection{Show values}
This command shows the current values of variables or other objects,
in a suitably condensed form.
<<Commands: types>>=
type, extends (command_t) :: cmd_show_t
private
type(string_t), dimension(:), allocatable :: name
contains
<<Commands: cmd show: TBP>>
end type cmd_show_t
@ %def cmd_show_t
@ Output: list the object names, not values.
<<Commands: cmd show: TBP>>=
procedure :: write => cmd_show_write
<<Commands: procedures>>=
subroutine cmd_show_write (cmd, unit, indent)
class(cmd_show_t), intent(in) :: cmd
integer, intent(in), optional :: unit, indent
integer :: u, i
u = given_output_unit (unit); if (u < 0) return
call write_indent (u, indent)
write (u, "(1x,A)", advance="no") "show: "
if (allocated (cmd%name)) then
do i = 1, size (cmd%name)
write (u, "(1x,A)", advance="no") char (cmd%name(i))
end do
write (u, *)
else
write (u, "(5x,A)") "[undefined]"
end if
end subroutine cmd_show_write
@ %def cmd_show_write
@ Compile. Allocate an array which is filled with the names of the
variables to show.
<<Commands: cmd show: TBP>>=
procedure :: compile => cmd_show_compile
<<Commands: procedures>>=
subroutine cmd_show_compile (cmd, global)
class(cmd_show_t), intent(inout) :: cmd
type(rt_data_t), intent(inout), target :: global
type(parse_node_t), pointer :: pn_arg, pn_var, pn_prefix, pn_name
type(string_t) :: key
integer :: i, n_args
pn_arg => parse_node_get_sub_ptr (cmd%pn, 2)
if (associated (pn_arg)) then
select case (char (parse_node_get_rule_key (pn_arg)))
case ("show_arg")
cmd%pn_opt => parse_node_get_next_ptr (pn_arg)
case default
cmd%pn_opt => pn_arg
pn_arg => null ()
end select
end if
call cmd%compile_options (global)
if (associated (pn_arg)) then
n_args = parse_node_get_n_sub (pn_arg)
allocate (cmd%name (n_args))
pn_var => parse_node_get_sub_ptr (pn_arg)
i = 0
do while (associated (pn_var))
i = i + 1
select case (char (parse_node_get_rule_key (pn_var)))
case ("model", "library", "beams", "iterations", &
"cuts", "weight", "int", "real", "complex", &
"scale", "factorization_scale", "renormalization_scale", &
"selection", "reweight", "analysis", "pdg", &
"stable", "unstable", "polarized", "unpolarized", &
"results", "expect", "intrinsic", "string", "logical")
cmd%name(i) = parse_node_get_key (pn_var)
case ("result_var")
pn_prefix => parse_node_get_sub_ptr (pn_var)
pn_name => parse_node_get_next_ptr (pn_prefix)
if (associated (pn_name)) then
cmd%name(i) = parse_node_get_key (pn_prefix) &
// "(" // parse_node_get_string (pn_name) // ")"
else
cmd%name(i) = parse_node_get_key (pn_prefix)
end if
case ("log_var", "string_var", "alias_var")
pn_prefix => parse_node_get_sub_ptr (pn_var)
pn_name => parse_node_get_next_ptr (pn_prefix)
key = parse_node_get_key (pn_prefix)
if (associated (pn_name)) then
select case (char (parse_node_get_rule_key (pn_name)))
case ("var_name")
select case (char (key))
case ("?", "$") ! $ sign
cmd%name(i) = key // parse_node_get_string (pn_name)
case ("alias")
cmd%name(i) = parse_node_get_string (pn_name)
end select
case default
call parse_node_mismatch &
("var_name", pn_name)
end select
else
cmd%name(i) = key
end if
case default
cmd%name(i) = parse_node_get_string (pn_var)
end select
pn_var => parse_node_get_next_ptr (pn_var)
end do
else
allocate (cmd%name (0))
end if
end subroutine cmd_show_compile
@ %def cmd_show_compile
@ Execute. Scan the list of objects to show.
<<Commands: parameters>>=
integer, parameter, public :: SHOW_BUFFER_SIZE = 4096
<<Commands: cmd show: TBP>>=
procedure :: execute => cmd_show_execute
<<Commands: procedures>>=
subroutine cmd_show_execute (cmd, global)
class(cmd_show_t), intent(inout) :: cmd
type(rt_data_t), intent(inout), target :: global
type(var_list_t), pointer :: var_list, model_vars
type(model_t), pointer :: model
type(string_t) :: name
integer :: n, pdg
type(flavor_t) :: flv
type(process_library_t), pointer :: prc_lib
type(process_t), pointer :: process
logical :: pacified
character(SHOW_BUFFER_SIZE) :: buffer
type(string_t) :: out_file
integer :: i, j, u, u_log, u_out, u_ext
u = free_unit ()
var_list => cmd%local%var_list
if (associated (cmd%local%model)) then
model_vars => cmd%local%model%get_var_list_ptr ()
else
model_vars => null ()
end if
pacified = var_list%get_lval (var_str ("?pacify"))
out_file = var_list%get_sval (var_str ("$out_file"))
if (file_list_is_open (global%out_files, out_file, action="write")) then
call msg_message ("show: copying output to file '" &
// char (out_file) // "'")
u_ext = file_list_get_unit (global%out_files, out_file)
else
u_ext = -1
end if
open (u, status = "scratch", action = "readwrite")
if (associated (cmd%local%model)) then
name = cmd%local%model%get_name ()
end if
if (size (cmd%name) == 0) then
if (associated (model_vars)) then
call model_vars%write (model_name = name, &
unit = u, pacified = pacified, follow_link = .false.)
end if
call var_list%write (unit = u, pacified = pacified)
else
do i = 1, size (cmd%name)
select case (char (cmd%name(i)))
case ("model")
if (associated (cmd%local%model)) then
call cmd%local%model%show (u)
else
write (u, "(A)") "Model: [undefined]"
end if
case ("library")
if (associated (cmd%local%prclib)) then
call cmd%local%prclib%show (u)
else
write (u, "(A)") "Process library: [undefined]"
end if
case ("beams")
call cmd%local%show_beams (u)
case ("iterations")
call cmd%local%it_list%write (u)
case ("results")
call cmd%local%process_stack%show (u, fifo=.true.)
case ("stable")
call cmd%local%model%show_stable (u)
case ("polarized")
call cmd%local%model%show_polarized (u)
case ("unpolarized")
call cmd%local%model%show_unpolarized (u)
case ("unstable")
model => cmd%local%model
call model%show_unstable (u)
n = model%get_n_field ()
do j = 1, n
pdg = model%get_pdg (j)
call flv%init (pdg, model)
if (.not. flv%is_stable ()) &
call show_unstable (cmd%local, pdg, u)
if (flv%has_antiparticle ()) then
associate (anti => flv%anti ())
if (.not. anti%is_stable ()) &
call show_unstable (cmd%local, -pdg, u)
end associate
end if
end do
case ("cuts", "weight", "scale", &
"factorization_scale", "renormalization_scale", &
"selection", "reweight", "analysis")
call cmd%local%pn%show (cmd%name(i), u)
case ("expect")
call expect_summary (force = .true.)
case ("intrinsic")
call var_list%write (intrinsic=.true., unit=u, &
pacified = pacified)
case ("logical")
if (associated (model_vars)) then
call model_vars%write (only_type=V_LOG, &
model_name = name, unit=u, pacified = pacified, &
follow_link=.false.)
end if
call var_list%write (&
only_type=V_LOG, unit=u, pacified = pacified)
case ("int")
if (associated (model_vars)) then
call model_vars%write (only_type=V_INT, &
model_name = name, unit=u, pacified = pacified, &
follow_link=.false.)
end if
call var_list%write (only_type=V_INT, &
unit=u, pacified = pacified)
case ("real")
if (associated (model_vars)) then
call model_vars%write (only_type=V_REAL, &
model_name = name, unit=u, pacified = pacified, &
follow_link=.false.)
end if
call var_list%write (only_type=V_REAL, &
unit=u, pacified = pacified)
case ("complex")
if (associated (model_vars)) then
call model_vars%write (only_type=V_CMPLX, &
model_name = name, unit=u, pacified = pacified, &
follow_link=.false.)
end if
call var_list%write (only_type=V_CMPLX, &
unit=u, pacified = pacified)
case ("pdg")
if (associated (model_vars)) then
call model_vars%write (only_type=V_PDG, &
model_name = name, unit=u, pacified = pacified, &
follow_link=.false.)
end if
call var_list%write (only_type=V_PDG, &
unit=u, pacified = pacified)
case ("string")
if (associated (model_vars)) then
call model_vars%write (only_type=V_STR, &
model_name = name, unit=u, pacified = pacified, &
follow_link=.false.)
end if
call var_list%write (only_type=V_STR, &
unit=u, pacified = pacified)
case default
if (analysis_exists (cmd%name(i))) then
call analysis_write (cmd%name(i), u)
else if (cmd%local%process_stack%exists (cmd%name(i))) then
process => cmd%local%process_stack%get_process_ptr (cmd%name(i))
call process%show (u)
else if (associated (cmd%local%prclib_stack%get_library_ptr &
(cmd%name(i)))) then
prc_lib => cmd%local%prclib_stack%get_library_ptr (cmd%name(i))
call prc_lib%show (u)
else if (associated (model_vars)) then
if (model_vars%contains (cmd%name(i), follow_link=.false.)) then
call model_vars%write_var (cmd%name(i), &
unit = u, model_name = name, pacified = pacified)
else if (var_list%contains (cmd%name(i))) then
call var_list%write_var (cmd%name(i), &
unit = u, pacified = pacified)
else
call msg_error ("show: object '" // char (cmd%name(i)) &
// "' not found")
end if
else if (var_list%contains (cmd%name(i))) then
call var_list%write_var (cmd%name(i), &
unit = u, pacified = pacified)
else
call msg_error ("show: object '" // char (cmd%name(i)) &
// "' not found")
end if
end select
end do
end if
rewind (u)
u_log = logfile_unit ()
u_out = given_output_unit ()
do
read (u, "(A)", end = 1) buffer
if (u_log > 0) write (u_log, "(A)") trim (buffer)
if (u_out > 0) write (u_out, "(A)") trim (buffer)
if (u_ext > 0) write (u_ext, "(A)") trim (buffer)
end do
1 close (u)
if (u_log > 0) flush (u_log)
if (u_out > 0) flush (u_out)
if (u_ext > 0) flush (u_ext)
end subroutine cmd_show_execute
@ %def cmd_show_execute
@
\subsubsection{Clear values}
This command clears the current values of variables or other objects,
where this makes sense. It parallels the [[show]] command. The
objects are cleared, but not deleted.
<<Commands: types>>=
type, extends (command_t) :: cmd_clear_t
private
type(string_t), dimension(:), allocatable :: name
contains
<<Commands: cmd clear: TBP>>
end type cmd_clear_t
@ %def cmd_clear_t
@ Output: list the names of the objects to be cleared.
<<Commands: cmd clear: TBP>>=
procedure :: write => cmd_clear_write
<<Commands: procedures>>=
subroutine cmd_clear_write (cmd, unit, indent)
class(cmd_clear_t), intent(in) :: cmd
integer, intent(in), optional :: unit, indent
integer :: u, i
u = given_output_unit (unit); if (u < 0) return
call write_indent (u, indent)
write (u, "(1x,A)", advance="no") "clear: "
if (allocated (cmd%name)) then
do i = 1, size (cmd%name)
write (u, "(1x,A)", advance="no") char (cmd%name(i))
end do
write (u, *)
else
write (u, "(5x,A)") "[undefined]"
end if
end subroutine cmd_clear_write
@ %def cmd_clear_write
@ Compile. Allocate an array which is filled with the names of the
objects to be cleared.
Note: there is currently no need to account for options, but we
prepare for that possibility.
<<Commands: cmd clear: TBP>>=
procedure :: compile => cmd_clear_compile
<<Commands: procedures>>=
subroutine cmd_clear_compile (cmd, global)
class(cmd_clear_t), intent(inout) :: cmd
type(rt_data_t), intent(inout), target :: global
type(parse_node_t), pointer :: pn_arg, pn_var, pn_prefix, pn_name
type(string_t) :: key
integer :: i, n_args
pn_arg => parse_node_get_sub_ptr (cmd%pn, 2)
if (associated (pn_arg)) then
select case (char (parse_node_get_rule_key (pn_arg)))
case ("clear_arg")
cmd%pn_opt => parse_node_get_next_ptr (pn_arg)
case default
cmd%pn_opt => pn_arg
pn_arg => null ()
end select
end if
call cmd%compile_options (global)
if (associated (pn_arg)) then
n_args = parse_node_get_n_sub (pn_arg)
allocate (cmd%name (n_args))
pn_var => parse_node_get_sub_ptr (pn_arg)
i = 0
do while (associated (pn_var))
i = i + 1
select case (char (parse_node_get_rule_key (pn_var)))
case ("beams", "iterations", &
"cuts", "weight", &
"scale", "factorization_scale", "renormalization_scale", &
"selection", "reweight", "analysis", &
"unstable", "polarized", &
"expect")
cmd%name(i) = parse_node_get_key (pn_var)
case ("log_var", "string_var")
pn_prefix => parse_node_get_sub_ptr (pn_var)
pn_name => parse_node_get_next_ptr (pn_prefix)
key = parse_node_get_key (pn_prefix)
if (associated (pn_name)) then
select case (char (parse_node_get_rule_key (pn_name)))
case ("var_name")
select case (char (key))
case ("?", "$") ! $ sign
cmd%name(i) = key // parse_node_get_string (pn_name)
end select
case default
call parse_node_mismatch &
("var_name", pn_name)
end select
else
cmd%name(i) = key
end if
case default
cmd%name(i) = parse_node_get_string (pn_var)
end select
pn_var => parse_node_get_next_ptr (pn_var)
end do
else
allocate (cmd%name (0))
end if
end subroutine cmd_clear_compile
@ %def cmd_clear_compile
@ Execute. Scan the list of objects to clear.
Objects that can be shown but not cleared: model, library, results
<<Commands: cmd clear: TBP>>=
procedure :: execute => cmd_clear_execute
<<Commands: procedures>>=
subroutine cmd_clear_execute (cmd, global)
class(cmd_clear_t), intent(inout) :: cmd
type(rt_data_t), intent(inout), target :: global
integer :: i
logical :: success
type(var_list_t), pointer :: model_vars
if (size (cmd%name) == 0) then
call msg_warning ("clear: no object specified")
else
do i = 1, size (cmd%name)
success = .true.
select case (char (cmd%name(i)))
case ("beams")
call cmd%local%clear_beams ()
case ("iterations")
call cmd%local%it_list%clear ()
case ("polarized")
call cmd%local%model%clear_polarized ()
case ("unstable")
call cmd%local%model%clear_unstable ()
case ("cuts", "weight", "scale", &
"factorization_scale", "renormalization_scale", &
"selection", "reweight", "analysis")
call cmd%local%pn%clear (cmd%name(i))
case ("expect")
call expect_clear ()
case default
if (analysis_exists (cmd%name(i))) then
call analysis_clear (cmd%name(i))
else if (cmd%local%var_list%contains (cmd%name(i))) then
if (.not. cmd%local%var_list%is_locked (cmd%name(i))) then
call cmd%local%var_list%unset (cmd%name(i))
else
call msg_error ("clear: variable '" // char (cmd%name(i)) &
// "' is locked and can't be cleared")
success = .false.
end if
else if (associated (cmd%local%model)) then
model_vars => cmd%local%model%get_var_list_ptr ()
if (model_vars%contains (cmd%name(i), follow_link=.false.)) then
call msg_error ("clear: variable '" // char (cmd%name(i)) &
// "' is a model variable and can't be cleared")
else
call msg_error ("clear: object '" // char (cmd%name(i)) &
// "' not found")
end if
success = .false.
else
call msg_error ("clear: object '" // char (cmd%name(i)) &
// "' not found")
success = .false.
end if
end select
if (success) call msg_message ("cleared: " // char (cmd%name(i)))
end do
end if
end subroutine cmd_clear_execute
@ %def cmd_clear_execute
@
\subsubsection{Compare values of variables to expectation}
The implementation is similar to the [[show]] command. There are just
two arguments: two values that should be compared. For providing
local values for the numerical tolerance, the command has a local
argument list.
If the expectation fails, an error condition is recorded.
<<Commands: types>>=
type, extends (command_t) :: cmd_expect_t
private
type(parse_node_t), pointer :: pn_lexpr => null ()
contains
<<Commands: cmd expect: TBP>>
end type cmd_expect_t
@ %def cmd_expect_t
@ Simply tell the status.
<<Commands: cmd expect: TBP>>=
procedure :: write => cmd_expect_write
<<Commands: procedures>>=
subroutine cmd_expect_write (cmd, unit, indent)
class(cmd_expect_t), intent(in) :: cmd
integer, intent(in), optional :: unit, indent
integer :: u
u = given_output_unit (unit); if (u < 0) return
call write_indent (u, indent)
if (associated (cmd%pn_lexpr)) then
write (u, "(1x,A)") "expect: [expression associated]"
else
write (u, "(1x,A)") "expect: [undefined]"
end if
end subroutine cmd_expect_write
@ %def cmd_expect_write
@ Compile. This merely assigns the parse node, the actual compilation is done
at execution. This is necessary because the origin of variables
(local/global) may change during execution.
<<Commands: cmd expect: TBP>>=
procedure :: compile => cmd_expect_compile
<<Commands: procedures>>=
subroutine cmd_expect_compile (cmd, global)
class(cmd_expect_t), intent(inout) :: cmd
type(rt_data_t), intent(inout), target :: global
type(parse_node_t), pointer :: pn_arg
pn_arg => parse_node_get_sub_ptr (cmd%pn, 2)
cmd%pn_opt => parse_node_get_next_ptr (pn_arg)
cmd%pn_lexpr => parse_node_get_sub_ptr (pn_arg)
call cmd%compile_options (global)
end subroutine cmd_expect_compile
@ %def cmd_expect_compile
@ Execute. Evaluate both arguments, print them and their difference
(if numerical), and whether they agree. Record the result.
<<Commands: cmd expect: TBP>>=
procedure :: execute => cmd_expect_execute
<<Commands: procedures>>=
subroutine cmd_expect_execute (cmd, global)
class(cmd_expect_t), intent(inout) :: cmd
type(rt_data_t), intent(inout), target :: global
type(var_list_t), pointer :: var_list
logical :: success, is_known
var_list => cmd%local%get_var_list_ptr ()
success = eval_log (cmd%pn_lexpr, var_list, is_known=is_known)
if (is_known) then
if (success) then
call msg_message ("expect: success")
else
call msg_error ("expect: failure")
end if
else
call msg_error ("expect: undefined result")
success = .false.
end if
call expect_record (success)
end subroutine cmd_expect_execute
@ %def cmd_expect_execute
@
\subsubsection{Beams}
The beam command includes both beam and structure-function
definition.
<<Commands: types>>=
type, extends (command_t) :: cmd_beams_t
private
integer :: n_in = 0
type(parse_node_p), dimension(:), allocatable :: pn_pdg
integer :: n_sf_record = 0
integer, dimension(:), allocatable :: n_entry
type(parse_node_p), dimension(:,:), allocatable :: pn_sf_entry
contains
<<Commands: cmd beams: TBP>>
end type cmd_beams_t
@ %def cmd_beams_t
@ Output. The particle expressions are not resolved.
<<Commands: cmd beams: TBP>>=
procedure :: write => cmd_beams_write
<<Commands: procedures>>=
subroutine cmd_beams_write (cmd, unit, indent)
class(cmd_beams_t), intent(in) :: cmd
integer, intent(in), optional :: unit, indent
integer :: u
u = given_output_unit (unit); if (u < 0) return
call write_indent (u, indent)
select case (cmd%n_in)
case (1)
write (u, "(1x,A)") "beams: 1 [decay]"
case (2)
write (u, "(1x,A)") "beams: 2 [scattering]"
case default
write (u, "(1x,A)") "beams: [undefined]"
end select
if (allocated (cmd%n_entry)) then
if (cmd%n_sf_record > 0) then
write (u, "(1x,A,99(1x,I0))") "structure function entries:", &
cmd%n_entry
end if
end if
end subroutine cmd_beams_write
@ %def cmd_beams_write
@ Compile. Find and assign the parse nodes.
Note: local environments are not yet supported.
<<Commands: cmd beams: TBP>>=
procedure :: compile => cmd_beams_compile
<<Commands: procedures>>=
subroutine cmd_beams_compile (cmd, global)
class(cmd_beams_t), intent(inout) :: cmd
type(rt_data_t), intent(inout), target :: global
type(parse_node_t), pointer :: pn_beam_def, pn_beam_spec
type(parse_node_t), pointer :: pn_beam_list
type(parse_node_t), pointer :: pn_codes
type(parse_node_t), pointer :: pn_strfun_seq, pn_strfun_pair
type(parse_node_t), pointer :: pn_strfun_def
integer :: i
pn_beam_def => parse_node_get_sub_ptr (cmd%pn, 3)
pn_beam_spec => parse_node_get_sub_ptr (pn_beam_def)
pn_strfun_seq => parse_node_get_next_ptr (pn_beam_spec)
pn_beam_list => parse_node_get_sub_ptr (pn_beam_spec)
call cmd%compile_options (global)
cmd%n_in = parse_node_get_n_sub (pn_beam_list)
allocate (cmd%pn_pdg (cmd%n_in))
pn_codes => parse_node_get_sub_ptr (pn_beam_list)
do i = 1, cmd%n_in
cmd%pn_pdg(i)%ptr => pn_codes
pn_codes => parse_node_get_next_ptr (pn_codes)
end do
if (associated (pn_strfun_seq)) then
cmd%n_sf_record = parse_node_get_n_sub (pn_beam_def) - 1
allocate (cmd%n_entry (cmd%n_sf_record), source = 1)
allocate (cmd%pn_sf_entry (2, cmd%n_sf_record))
do i = 1, cmd%n_sf_record
pn_strfun_pair => parse_node_get_sub_ptr (pn_strfun_seq, 2)
pn_strfun_def => parse_node_get_sub_ptr (pn_strfun_pair)
cmd%pn_sf_entry(1,i)%ptr => pn_strfun_def
pn_strfun_def => parse_node_get_next_ptr (pn_strfun_def)
cmd%pn_sf_entry(2,i)%ptr => pn_strfun_def
if (associated (pn_strfun_def)) cmd%n_entry(i) = 2
pn_strfun_seq => parse_node_get_next_ptr (pn_strfun_seq)
end do
else
allocate (cmd%n_entry (0))
allocate (cmd%pn_sf_entry (0, 0))
end if
end subroutine cmd_beams_compile
@ %def cmd_beams_compile
@ Command execution: Determine beam particles and structure-function
names, if any. The results are stored in the [[beam_structure]]
component of the [[global]] data block.
<<Commands: cmd beams: TBP>>=
procedure :: execute => cmd_beams_execute
<<Commands: procedures>>=
subroutine cmd_beams_execute (cmd, global)
class(cmd_beams_t), intent(inout) :: cmd
type(rt_data_t), intent(inout), target :: global
type(var_list_t), pointer :: var_list
type(pdg_array_t) :: pdg_array
integer, dimension(:), allocatable :: pdg
type(flavor_t), dimension(:), allocatable :: flv
type(parse_node_t), pointer :: pn_key
type(string_t) :: sf_name
integer :: i, j
call lhapdf_global_reset ()
var_list => cmd%local%get_var_list_ptr ()
allocate (flv (cmd%n_in))
do i = 1, cmd%n_in
pdg_array = eval_pdg_array (cmd%pn_pdg(i)%ptr, var_list)
pdg = pdg_array
select case (size (pdg))
case (1)
call flv(i)%init ( pdg(1), cmd%local%model)
case default
call msg_fatal ("Beams: beam particles must be unique")
end select
end do
select case (cmd%n_in)
case (1)
if (cmd%n_sf_record > 0) then
call msg_fatal ("Beam setup: no structure functions allowed &
&for decay")
end if
call global%beam_structure%init_sf (flv%get_name ())
case (2)
call global%beam_structure%init_sf (flv%get_name (), cmd%n_entry)
do i = 1, cmd%n_sf_record
do j = 1, cmd%n_entry(i)
pn_key => parse_node_get_sub_ptr (cmd%pn_sf_entry(j,i)%ptr)
sf_name = parse_node_get_key (pn_key)
call global%beam_structure%set_sf (i, j, sf_name)
end do
end do
end select
end subroutine cmd_beams_execute
@ %def cmd_beams_execute
@
\subsubsection{Density matrices for beam polarization}
For holding beam polarization, we define a notation and a data
structure for sparse matrices. The entries (and the index
expressions) are numerical expressions, so we use evaluation trees.
Each entry in the sparse matrix is an n-tuple of expressions. The first
tuple elements represent index values, the last one is an arbitrary
(complex) number. Absent expressions are replaced by default-value rules.
Note: Here, and in some other commands, we would like to store an evaluation
tree, not just a parse node pointer. However, the current expression handler
wants all variables defined, so the evaluation tree can only be built by
[[evaluate]], i.e., compiled just-in-time and evaluated immediately.
<<Commands: types>>=
type :: sentry_expr_t
type(parse_node_p), dimension(:), allocatable :: expr
contains
<<Commands: sentry expr: TBP>>
end type sentry_expr_t
@ %def sentry_expr_t
@ Compile parse nodes into evaluation trees.
<<Commands: sentry expr: TBP>>=
procedure :: compile => sentry_expr_compile
<<Commands: procedures>>=
subroutine sentry_expr_compile (sentry, pn)
class(sentry_expr_t), intent(out) :: sentry
type(parse_node_t), intent(in), target :: pn
type(parse_node_t), pointer :: pn_expr, pn_extra
integer :: n_expr, i
n_expr = parse_node_get_n_sub (pn)
allocate (sentry%expr (n_expr))
if (n_expr > 0) then
i = 0
pn_expr => parse_node_get_sub_ptr (pn)
pn_extra => parse_node_get_next_ptr (pn_expr)
do i = 1, n_expr
sentry%expr(i)%ptr => pn_expr
if (associated (pn_extra)) then
pn_expr => parse_node_get_sub_ptr (pn_extra, 2)
pn_extra => parse_node_get_next_ptr (pn_extra)
end if
end do
end if
end subroutine sentry_expr_compile
@ %def sentry_expr_compile
@ Evaluate the expressions and return an index array of predefined
length together with a complex value. If the value (as the last expression)
is undefined, set it to unity. If index values are undefined, repeat
the previous index value.
<<Commands: sentry expr: TBP>>=
procedure :: evaluate => sentry_expr_evaluate
<<Commands: procedures>>=
subroutine sentry_expr_evaluate (sentry, index, value, global)
class(sentry_expr_t), intent(inout) :: sentry
integer, dimension(:), intent(out) :: index
complex(default), intent(out) :: value
type(rt_data_t), intent(in), target :: global
type(var_list_t), pointer :: var_list
integer :: i, n_expr, n_index
type(eval_tree_t) :: eval_tree
var_list => global%get_var_list_ptr ()
n_expr = size (sentry%expr)
n_index = size (index)
if (n_expr <= n_index + 1) then
do i = 1, min (n_expr, n_index)
associate (expr => sentry%expr(i))
call eval_tree%init_expr (expr%ptr, var_list)
call eval_tree%evaluate ()
if (eval_tree%is_known ()) then
index(i) = eval_tree%get_int ()
else
call msg_fatal ("Evaluating density matrix: undefined index")
end if
end associate
end do
do i = n_expr + 1, n_index
index(i) = index(n_expr)
end do
if (n_expr == n_index + 1) then
associate (expr => sentry%expr(n_expr))
call eval_tree%init_expr (expr%ptr, var_list)
call eval_tree%evaluate ()
if (eval_tree%is_known ()) then
value = eval_tree%get_cmplx ()
else
call msg_fatal ("Evaluating density matrix: undefined index")
end if
call eval_tree%final ()
end associate
else
value = 1
end if
else
call msg_fatal ("Evaluating density matrix: index expression too long")
end if
end subroutine sentry_expr_evaluate
@ %def sentry_expr_evaluate
@ The sparse matrix itself consists of an arbitrary number of entries.
<<Commands: types>>=
type :: smatrix_expr_t
type(sentry_expr_t), dimension(:), allocatable :: entry
contains
<<Commands: smatrix expr: TBP>>
end type smatrix_expr_t
@ %def smatrix_expr_t
@ Compile: assign sub-nodes to sentry-expressions and compile those.
<<Commands: smatrix expr: TBP>>=
procedure :: compile => smatrix_expr_compile
<<Commands: procedures>>=
subroutine smatrix_expr_compile (smatrix_expr, pn)
class(smatrix_expr_t), intent(out) :: smatrix_expr
type(parse_node_t), intent(in), target :: pn
type(parse_node_t), pointer :: pn_arg, pn_entry
integer :: n_entry, i
pn_arg => parse_node_get_sub_ptr (pn, 2)
if (associated (pn_arg)) then
n_entry = parse_node_get_n_sub (pn_arg)
allocate (smatrix_expr%entry (n_entry))
pn_entry => parse_node_get_sub_ptr (pn_arg)
do i = 1, n_entry
call smatrix_expr%entry(i)%compile (pn_entry)
pn_entry => parse_node_get_next_ptr (pn_entry)
end do
else
allocate (smatrix_expr%entry (0))
end if
end subroutine smatrix_expr_compile
@ %def smatrix_expr_compile
@ Evaluate the entries and build a new [[smatrix]] object, which
contains just the numerical results.
<<Commands: smatrix expr: TBP>>=
procedure :: evaluate => smatrix_expr_evaluate
<<Commands: procedures>>=
subroutine smatrix_expr_evaluate (smatrix_expr, smatrix, global)
class(smatrix_expr_t), intent(inout) :: smatrix_expr
type(smatrix_t), intent(out) :: smatrix
type(rt_data_t), intent(in), target :: global
integer, dimension(2) :: idx
complex(default) :: value
integer :: i, n_entry
n_entry = size (smatrix_expr%entry)
call smatrix%init (2, n_entry)
do i = 1, n_entry
call smatrix_expr%entry(i)%evaluate (idx, value, global)
call smatrix%set_entry (i, idx, value)
end do
end subroutine smatrix_expr_evaluate
@ %def smatrix_expr_evaluate
@
\subsubsection{Beam polarization density}
The beam polarization command defines spin density matrix for one or
two beams (scattering or decay).
<<Commands: types>>=
type, extends (command_t) :: cmd_beams_pol_density_t
private
integer :: n_in = 0
type(smatrix_expr_t), dimension(:), allocatable :: smatrix
contains
<<Commands: cmd beams pol density: TBP>>
end type cmd_beams_pol_density_t
@ %def cmd_beams_pol_density_t
@ Output.
<<Commands: cmd beams pol density: TBP>>=
procedure :: write => cmd_beams_pol_density_write
<<Commands: procedures>>=
subroutine cmd_beams_pol_density_write (cmd, unit, indent)
class(cmd_beams_pol_density_t), intent(in) :: cmd
integer, intent(in), optional :: unit, indent
integer :: u
u = given_output_unit (unit); if (u < 0) return
call write_indent (u, indent)
select case (cmd%n_in)
case (1)
write (u, "(1x,A)") "beams polarization setup: 1 [decay]"
case (2)
write (u, "(1x,A)") "beams polarization setup: 2 [scattering]"
case default
write (u, "(1x,A)") "beams polarization setup: [undefined]"
end select
end subroutine cmd_beams_pol_density_write
@ %def cmd_beams_pol_density_write
@ Compile. Find and assign the parse nodes.
Note: local environments are not yet supported.
<<Commands: cmd beams pol density: TBP>>=
procedure :: compile => cmd_beams_pol_density_compile
<<Commands: procedures>>=
subroutine cmd_beams_pol_density_compile (cmd, global)
class(cmd_beams_pol_density_t), intent(inout) :: cmd
type(rt_data_t), intent(inout), target :: global
type(parse_node_t), pointer :: pn_pol_spec, pn_smatrix
integer :: i
pn_pol_spec => parse_node_get_sub_ptr (cmd%pn, 3)
call cmd%compile_options (global)
cmd%n_in = parse_node_get_n_sub (pn_pol_spec)
allocate (cmd%smatrix (cmd%n_in))
pn_smatrix => parse_node_get_sub_ptr (pn_pol_spec)
do i = 1, cmd%n_in
call cmd%smatrix(i)%compile (pn_smatrix)
pn_smatrix => parse_node_get_next_ptr (pn_smatrix)
end do
end subroutine cmd_beams_pol_density_compile
@ %def cmd_beams_pol_density_compile
@ Command execution: Fill polarization density matrices. No check
yet, the matrices are checked and normalized when the actual beam
object is created, just before integration. For intermediate storage,
we use the [[beam_structure]] object in the [[global]] data set.
<<Commands: cmd beams pol density: TBP>>=
procedure :: execute => cmd_beams_pol_density_execute
<<Commands: procedures>>=
subroutine cmd_beams_pol_density_execute (cmd, global)
class(cmd_beams_pol_density_t), intent(inout) :: cmd
type(rt_data_t), intent(inout), target :: global
type(smatrix_t) :: smatrix
integer :: i
call global%beam_structure%init_pol (cmd%n_in)
do i = 1, cmd%n_in
call cmd%smatrix(i)%evaluate (smatrix, global)
call global%beam_structure%set_smatrix (i, smatrix)
end do
end subroutine cmd_beams_pol_density_execute
@ %def cmd_beams_pol_density_execute
@
\subsubsection{Beam polarization fraction}
In addition to the polarization density matrix, we can independently
specify the polarization fraction for one or both beams.
<<Commands: types>>=
type, extends (command_t) :: cmd_beams_pol_fraction_t
private
integer :: n_in = 0
type(parse_node_p), dimension(:), allocatable :: expr
contains
<<Commands: cmd beams pol fraction: TBP>>
end type cmd_beams_pol_fraction_t
@ %def cmd_beams_pol_fraction_t
@ Output.
<<Commands: cmd beams pol fraction: TBP>>=
procedure :: write => cmd_beams_pol_fraction_write
<<Commands: procedures>>=
subroutine cmd_beams_pol_fraction_write (cmd, unit, indent)
class(cmd_beams_pol_fraction_t), intent(in) :: cmd
integer, intent(in), optional :: unit, indent
integer :: u
u = given_output_unit (unit); if (u < 0) return
call write_indent (u, indent)
select case (cmd%n_in)
case (1)
write (u, "(1x,A)") "beams polarization fraction: 1 [decay]"
case (2)
write (u, "(1x,A)") "beams polarization fraction: 2 [scattering]"
case default
write (u, "(1x,A)") "beams polarization fraction: [undefined]"
end select
end subroutine cmd_beams_pol_fraction_write
@ %def cmd_beams_pol_fraction_write
@ Compile. Find and assign the parse nodes.
Note: local environments are not yet supported.
<<Commands: cmd beams pol fraction: TBP>>=
procedure :: compile => cmd_beams_pol_fraction_compile
<<Commands: procedures>>=
subroutine cmd_beams_pol_fraction_compile (cmd, global)
class(cmd_beams_pol_fraction_t), intent(inout) :: cmd
type(rt_data_t), intent(inout), target :: global
type(parse_node_t), pointer :: pn_frac_spec, pn_expr
integer :: i
pn_frac_spec => parse_node_get_sub_ptr (cmd%pn, 3)
call cmd%compile_options (global)
cmd%n_in = parse_node_get_n_sub (pn_frac_spec)
allocate (cmd%expr (cmd%n_in))
pn_expr => parse_node_get_sub_ptr (pn_frac_spec)
do i = 1, cmd%n_in
cmd%expr(i)%ptr => pn_expr
pn_expr => parse_node_get_next_ptr (pn_expr)
end do
end subroutine cmd_beams_pol_fraction_compile
@ %def cmd_beams_pol_fraction_compile
@ Command execution: Retrieve the numerical values of the beam
polarization fractions. The results are stored in the
[[beam_structure]] component of the [[global]] data block.
<<Commands: cmd beams pol fraction: TBP>>=
procedure :: execute => cmd_beams_pol_fraction_execute
<<Commands: procedures>>=
subroutine cmd_beams_pol_fraction_execute (cmd, global)
class(cmd_beams_pol_fraction_t), intent(inout) :: cmd
type(rt_data_t), intent(inout), target :: global
type(var_list_t), pointer :: var_list
real(default), dimension(:), allocatable :: pol_f
type(eval_tree_t) :: expr
integer :: i
var_list => global%get_var_list_ptr ()
allocate (pol_f (cmd%n_in))
do i = 1, cmd%n_in
call expr%init_expr (cmd%expr(i)%ptr, var_list)
call expr%evaluate ()
if (expr%is_known ()) then
pol_f(i) = expr%get_real ()
else
call msg_fatal ("beams polarization fraction: undefined value")
end if
call expr%final ()
end do
call global%beam_structure%set_pol_f (pol_f)
end subroutine cmd_beams_pol_fraction_execute
@ %def cmd_beams_pol_fraction_execute
@
\subsubsection{Beam momentum}
This is completely analogous to the previous command, hence we can use
inheritance.
<<Commands: types>>=
type, extends (cmd_beams_pol_fraction_t) :: cmd_beams_momentum_t
contains
<<Commands: cmd beams momentum: TBP>>
end type cmd_beams_momentum_t
@ %def cmd_beams_momentum_t
@ Output.
<<Commands: cmd beams momentum: TBP>>=
procedure :: write => cmd_beams_momentum_write
<<Commands: procedures>>=
subroutine cmd_beams_momentum_write (cmd, unit, indent)
class(cmd_beams_momentum_t), intent(in) :: cmd
integer, intent(in), optional :: unit, indent
integer :: u
u = given_output_unit (unit); if (u < 0) return
call write_indent (u, indent)
select case (cmd%n_in)
case (1)
write (u, "(1x,A)") "beams momentum: 1 [decay]"
case (2)
write (u, "(1x,A)") "beams momentum: 2 [scattering]"
case default
write (u, "(1x,A)") "beams momentum: [undefined]"
end select
end subroutine cmd_beams_momentum_write
@ %def cmd_beams_momentum_write
@ Compile: inherited.
Command execution: Not inherited, but just the error string and the final
command are changed.
<<Commands: cmd beams momentum: TBP>>=
procedure :: execute => cmd_beams_momentum_execute
<<Commands: procedures>>=
subroutine cmd_beams_momentum_execute (cmd, global)
class(cmd_beams_momentum_t), intent(inout) :: cmd
type(rt_data_t), intent(inout), target :: global
type(var_list_t), pointer :: var_list
real(default), dimension(:), allocatable :: p
type(eval_tree_t) :: expr
integer :: i
var_list => global%get_var_list_ptr ()
allocate (p (cmd%n_in))
do i = 1, cmd%n_in
call expr%init_expr (cmd%expr(i)%ptr, var_list)
call expr%evaluate ()
if (expr%is_known ()) then
p(i) = expr%get_real ()
else
call msg_fatal ("beams momentum: undefined value")
end if
call expr%final ()
end do
call global%beam_structure%set_momentum (p)
end subroutine cmd_beams_momentum_execute
@ %def cmd_beams_momentum_execute
@
\subsubsection{Beam angles}
Again, this is analogous. There are two angles, polar angle $\theta$
and azimuthal angle $\phi$, which can be set independently for both beams.
<<Commands: types>>=
type, extends (cmd_beams_pol_fraction_t) :: cmd_beams_theta_t
contains
<<Commands: cmd beams theta: TBP>>
end type cmd_beams_theta_t
type, extends (cmd_beams_pol_fraction_t) :: cmd_beams_phi_t
contains
<<Commands: cmd beams phi: TBP>>
end type cmd_beams_phi_t
@ %def cmd_beams_theta_t
@ %def cmd_beams_phi_t
@ Output.
<<Commands: cmd beams theta: TBP>>=
procedure :: write => cmd_beams_theta_write
<<Commands: cmd beams phi: TBP>>=
procedure :: write => cmd_beams_phi_write
<<Commands: procedures>>=
subroutine cmd_beams_theta_write (cmd, unit, indent)
class(cmd_beams_theta_t), intent(in) :: cmd
integer, intent(in), optional :: unit, indent
integer :: u
u = given_output_unit (unit); if (u < 0) return
call write_indent (u, indent)
select case (cmd%n_in)
case (1)
write (u, "(1x,A)") "beams theta: 1 [decay]"
case (2)
write (u, "(1x,A)") "beams theta: 2 [scattering]"
case default
write (u, "(1x,A)") "beams theta: [undefined]"
end select
end subroutine cmd_beams_theta_write
subroutine cmd_beams_phi_write (cmd, unit, indent)
class(cmd_beams_phi_t), intent(in) :: cmd
integer, intent(in), optional :: unit, indent
integer :: u
u = given_output_unit (unit); if (u < 0) return
call write_indent (u, indent)
select case (cmd%n_in)
case (1)
write (u, "(1x,A)") "beams phi: 1 [decay]"
case (2)
write (u, "(1x,A)") "beams phi: 2 [scattering]"
case default
write (u, "(1x,A)") "beams phi: [undefined]"
end select
end subroutine cmd_beams_phi_write
@ %def cmd_beams_theta_write
@ %def cmd_beams_phi_write
@ Compile: inherited.
Command execution: Not inherited, but just the error string and the final
command are changed.
<<Commands: cmd beams theta: TBP>>=
procedure :: execute => cmd_beams_theta_execute
<<Commands: cmd beams phi: TBP>>=
procedure :: execute => cmd_beams_phi_execute
<<Commands: procedures>>=
subroutine cmd_beams_theta_execute (cmd, global)
class(cmd_beams_theta_t), intent(inout) :: cmd
type(rt_data_t), intent(inout), target :: global
type(var_list_t), pointer :: var_list
real(default), dimension(:), allocatable :: theta
type(eval_tree_t) :: expr
integer :: i
var_list => global%get_var_list_ptr ()
allocate (theta (cmd%n_in))
do i = 1, cmd%n_in
call expr%init_expr (cmd%expr(i)%ptr, var_list)
call expr%evaluate ()
if (expr%is_known ()) then
theta(i) = expr%get_real ()
else
call msg_fatal ("beams theta: undefined value")
end if
call expr%final ()
end do
call global%beam_structure%set_theta (theta)
end subroutine cmd_beams_theta_execute
subroutine cmd_beams_phi_execute (cmd, global)
class(cmd_beams_phi_t), intent(inout) :: cmd
type(rt_data_t), intent(inout), target :: global
type(var_list_t), pointer :: var_list
real(default), dimension(:), allocatable :: phi
type(eval_tree_t) :: expr
integer :: i
var_list => global%get_var_list_ptr ()
allocate (phi (cmd%n_in))
do i = 1, cmd%n_in
call expr%init_expr (cmd%expr(i)%ptr, var_list)
call expr%evaluate ()
if (expr%is_known ()) then
phi(i) = expr%get_real ()
else
call msg_fatal ("beams phi: undefined value")
end if
call expr%final ()
end do
call global%beam_structure%set_phi (phi)
end subroutine cmd_beams_phi_execute
@ %def cmd_beams_theta_execute
@ %def cmd_beams_phi_execute
@
\subsubsection{Cuts}
Define a cut expression. We store the parse tree for the right-hand
side instead of compiling it. Compilation is deferred to the process
environment where the cut expression is used.
<<Commands: types>>=
type, extends (command_t) :: cmd_cuts_t
private
type(parse_node_t), pointer :: pn_lexpr => null ()
contains
<<Commands: cmd cuts: TBP>>
end type cmd_cuts_t
@ %def cmd_cuts_t
@ Output. Do not print the parse tree, since this may get cluttered.
Just a message that cuts have been defined.
<<Commands: cmd cuts: TBP>>=
procedure :: write => cmd_cuts_write
<<Commands: procedures>>=
subroutine cmd_cuts_write (cmd, unit, indent)
class(cmd_cuts_t), intent(in) :: cmd
integer, intent(in), optional :: unit, indent
integer :: u
u = given_output_unit (unit); if (u < 0) return
call write_indent (u, indent)
write (u, "(1x,A)") "cuts: [defined]"
end subroutine cmd_cuts_write
@ %def cmd_cuts_write
@ Compile. Simply store the parse (sub)tree.
<<Commands: cmd cuts: TBP>>=
procedure :: compile => cmd_cuts_compile
<<Commands: procedures>>=
subroutine cmd_cuts_compile (cmd, global)
class(cmd_cuts_t), intent(inout) :: cmd
type(rt_data_t), intent(inout), target :: global
cmd%pn_lexpr => parse_node_get_sub_ptr (cmd%pn, 3)
end subroutine cmd_cuts_compile
@ %def cmd_cuts_compile
@ Instead of evaluating the cut expression, link the parse tree to the
global data set, such that it is compiled and executed in the
appropriate process context.
<<Commands: cmd cuts: TBP>>=
procedure :: execute => cmd_cuts_execute
<<Commands: procedures>>=
subroutine cmd_cuts_execute (cmd, global)
class(cmd_cuts_t), intent(inout) :: cmd
type(rt_data_t), intent(inout), target :: global
global%pn%cuts_lexpr => cmd%pn_lexpr
end subroutine cmd_cuts_execute
@ %def cmd_cuts_execute
@
\subsubsection{General, Factorization and Renormalization Scales}
Define a scale expression for either the renormalization or the
factorization scale. We store the parse tree for the right-hand
side instead of compiling it. Compilation is deferred to the process
environment where the expression is used.
<<Commands: types>>=
type, extends (command_t) :: cmd_scale_t
private
type(parse_node_t), pointer :: pn_expr => null ()
contains
<<Commands: cmd scale: TBP>>
end type cmd_scale_t
@ %def cmd_scale_t
<<Commands: types>>=
type, extends (command_t) :: cmd_fac_scale_t
private
type(parse_node_t), pointer :: pn_expr => null ()
contains
<<Commands: cmd fac scale: TBP>>
end type cmd_fac_scale_t
@ %def cmd_fac_scale_t
<<Commands: types>>=
type, extends (command_t) :: cmd_ren_scale_t
private
type(parse_node_t), pointer :: pn_expr => null ()
contains
<<Commands: cmd ren scale: TBP>>
end type cmd_ren_scale_t
@ %def cmd_ren_scale_t
@ Output. Do not print the parse tree, since this may get cluttered.
Just a message that scale, renormalization and factorization have been
defined, respectively.
<<Commands: cmd scale: TBP>>=
procedure :: write => cmd_scale_write
<<Commands: procedures>>=
subroutine cmd_scale_write (cmd, unit, indent)
class(cmd_scale_t), intent(in) :: cmd
integer, intent(in), optional :: unit, indent
integer :: u
u = given_output_unit (unit); if (u < 0) return
call write_indent (u, indent)
write (u, "(1x,A)") "scale: [defined]"
end subroutine cmd_scale_write
@ %def cmd_scale_write
@
<<Commands: cmd fac scale: TBP>>=
procedure :: write => cmd_fac_scale_write
<<Commands: procedures>>=
subroutine cmd_fac_scale_write (cmd, unit, indent)
class(cmd_fac_scale_t), intent(in) :: cmd
integer, intent(in), optional :: unit, indent
integer :: u
u = given_output_unit (unit); if (u < 0) return
call write_indent (u, indent)
write (u, "(1x,A)") "factorization scale: [defined]"
end subroutine cmd_fac_scale_write
@ %def cmd_fac_scale_write
@
<<Commands: cmd ren scale: TBP>>=
procedure :: write => cmd_ren_scale_write
<<Commands: procedures>>=
subroutine cmd_ren_scale_write (cmd, unit, indent)
class(cmd_ren_scale_t), intent(in) :: cmd
integer, intent(in), optional :: unit, indent
integer :: u
u = given_output_unit (unit); if (u < 0) return
call write_indent (u, indent)
write (u, "(1x,A)") "renormalization scale: [defined]"
end subroutine cmd_ren_scale_write
@ %def cmd_ren_scale_write
@ Compile. Simply store the parse (sub)tree.
<<Commands: cmd scale: TBP>>=
procedure :: compile => cmd_scale_compile
<<Commands: procedures>>=
subroutine cmd_scale_compile (cmd, global)
class(cmd_scale_t), intent(inout) :: cmd
type(rt_data_t), intent(inout), target :: global
cmd%pn_expr => parse_node_get_sub_ptr (cmd%pn, 3)
end subroutine cmd_scale_compile
@ %def cmd_scale_compile
@
<<Commands: cmd fac scale: TBP>>=
procedure :: compile => cmd_fac_scale_compile
<<Commands: procedures>>=
subroutine cmd_fac_scale_compile (cmd, global)
class(cmd_fac_scale_t), intent(inout) :: cmd
type(rt_data_t), intent(inout), target :: global
cmd%pn_expr => parse_node_get_sub_ptr (cmd%pn, 3)
end subroutine cmd_fac_scale_compile
@ %def cmd_fac_scale_compile
@
<<Commands: cmd ren scale: TBP>>=
procedure :: compile => cmd_ren_scale_compile
<<Commands: procedures>>=
subroutine cmd_ren_scale_compile (cmd, global)
class(cmd_ren_scale_t), intent(inout) :: cmd
type(rt_data_t), intent(inout), target :: global
cmd%pn_expr => parse_node_get_sub_ptr (cmd%pn, 3)
end subroutine cmd_ren_scale_compile
@ %def cmd_ren_scale_compile
@ Instead of evaluating the scale expression, link the parse tree to the
global data set, such that it is compiled and executed in the
appropriate process context.
<<Commands: cmd scale: TBP>>=
procedure :: execute => cmd_scale_execute
<<Commands: procedures>>=
subroutine cmd_scale_execute (cmd, global)
class(cmd_scale_t), intent(inout) :: cmd
type(rt_data_t), intent(inout), target :: global
global%pn%scale_expr => cmd%pn_expr
end subroutine cmd_scale_execute
@ %def cmd_scale_execute
@
<<Commands: cmd fac scale: TBP>>=
procedure :: execute => cmd_fac_scale_execute
<<Commands: procedures>>=
subroutine cmd_fac_scale_execute (cmd, global)
class(cmd_fac_scale_t), intent(inout) :: cmd
type(rt_data_t), intent(inout), target :: global
global%pn%fac_scale_expr => cmd%pn_expr
end subroutine cmd_fac_scale_execute
@ %def cmd_fac_scale_execute
@
<<Commands: cmd ren scale: TBP>>=
procedure :: execute => cmd_ren_scale_execute
<<Commands: procedures>>=
subroutine cmd_ren_scale_execute (cmd, global)
class(cmd_ren_scale_t), intent(inout) :: cmd
type(rt_data_t), intent(inout), target :: global
global%pn%ren_scale_expr => cmd%pn_expr
end subroutine cmd_ren_scale_execute
@ %def cmd_ren_scale_execute
@
\subsubsection{Weight}
Define a weight expression. The weight is applied to a process to be
integrated, event by event. We store the parse tree for the right-hand
side instead of compiling it. Compilation is deferred to the process
environment where the expression is used.
<<Commands: types>>=
type, extends (command_t) :: cmd_weight_t
private
type(parse_node_t), pointer :: pn_expr => null ()
contains
<<Commands: cmd weight: TBP>>
end type cmd_weight_t
@ %def cmd_weight_t
@ Output. Do not print the parse tree, since this may get cluttered.
Just a message that scale, renormalization and factorization have been
defined, respectively.
<<Commands: cmd weight: TBP>>=
procedure :: write => cmd_weight_write
<<Commands: procedures>>=
subroutine cmd_weight_write (cmd, unit, indent)
class(cmd_weight_t), intent(in) :: cmd
integer, intent(in), optional :: unit, indent
integer :: u
u = given_output_unit (unit); if (u < 0) return
call write_indent (u, indent)
write (u, "(1x,A)") "weight expression: [defined]"
end subroutine cmd_weight_write
@ %def cmd_weight_write
@ Compile. Simply store the parse (sub)tree.
<<Commands: cmd weight: TBP>>=
procedure :: compile => cmd_weight_compile
<<Commands: procedures>>=
subroutine cmd_weight_compile (cmd, global)
class(cmd_weight_t), intent(inout) :: cmd
type(rt_data_t), intent(inout), target :: global
cmd%pn_expr => parse_node_get_sub_ptr (cmd%pn, 3)
end subroutine cmd_weight_compile
@ %def cmd_weight_compile
@ Instead of evaluating the expression, link the parse tree to the
global data set, such that it is compiled and executed in the
appropriate process context.
<<Commands: cmd weight: TBP>>=
procedure :: execute => cmd_weight_execute
<<Commands: procedures>>=
subroutine cmd_weight_execute (cmd, global)
class(cmd_weight_t), intent(inout) :: cmd
type(rt_data_t), intent(inout), target :: global
global%pn%weight_expr => cmd%pn_expr
end subroutine cmd_weight_execute
@ %def cmd_weight_execute
@
\subsubsection{Selection}
Define a selection expression. This is to be applied upon simulation or
event-file rescanning, event by event. We store the parse tree for the
right-hand side instead of compiling it. Compilation is deferred to the
environment where the expression is used.
<<Commands: types>>=
type, extends (command_t) :: cmd_selection_t
private
type(parse_node_t), pointer :: pn_expr => null ()
contains
<<Commands: cmd selection: TBP>>
end type cmd_selection_t
@ %def cmd_selection_t
@ Output. Do not print the parse tree, since this may get cluttered.
Just a message that scale, renormalization and factorization have been
defined, respectively.
<<Commands: cmd selection: TBP>>=
procedure :: write => cmd_selection_write
<<Commands: procedures>>=
subroutine cmd_selection_write (cmd, unit, indent)
class(cmd_selection_t), intent(in) :: cmd
integer, intent(in), optional :: unit, indent
integer :: u
u = given_output_unit (unit); if (u < 0) return
call write_indent (u, indent)
write (u, "(1x,A)") "selection expression: [defined]"
end subroutine cmd_selection_write
@ %def cmd_selection_write
@ Compile. Simply store the parse (sub)tree.
<<Commands: cmd selection: TBP>>=
procedure :: compile => cmd_selection_compile
<<Commands: procedures>>=
subroutine cmd_selection_compile (cmd, global)
class(cmd_selection_t), intent(inout) :: cmd
type(rt_data_t), intent(inout), target :: global
cmd%pn_expr => parse_node_get_sub_ptr (cmd%pn, 3)
end subroutine cmd_selection_compile
@ %def cmd_selection_compile
@ Instead of evaluating the expression, link the parse tree to the
global data set, such that it is compiled and executed in the
appropriate process context.
<<Commands: cmd selection: TBP>>=
procedure :: execute => cmd_selection_execute
<<Commands: procedures>>=
subroutine cmd_selection_execute (cmd, global)
class(cmd_selection_t), intent(inout) :: cmd
type(rt_data_t), intent(inout), target :: global
global%pn%selection_lexpr => cmd%pn_expr
end subroutine cmd_selection_execute
@ %def cmd_selection_execute
@
\subsubsection{Reweight}
Define a reweight expression. This is to be applied upon simulation or
event-file rescanning, event by event. We store the parse tree for the
right-hand side instead of compiling it. Compilation is deferred to the
environment where the expression is used.
<<Commands: types>>=
type, extends (command_t) :: cmd_reweight_t
private
type(parse_node_t), pointer :: pn_expr => null ()
contains
<<Commands: cmd reweight: TBP>>
end type cmd_reweight_t
@ %def cmd_reweight_t
@ Output. Do not print the parse tree, since this may get cluttered.
Just a message that scale, renormalization and factorization have been
defined, respectively.
<<Commands: cmd reweight: TBP>>=
procedure :: write => cmd_reweight_write
<<Commands: procedures>>=
subroutine cmd_reweight_write (cmd, unit, indent)
class(cmd_reweight_t), intent(in) :: cmd
integer, intent(in), optional :: unit, indent
integer :: u
u = given_output_unit (unit); if (u < 0) return
call write_indent (u, indent)
write (u, "(1x,A)") "reweight expression: [defined]"
end subroutine cmd_reweight_write
@ %def cmd_reweight_write
@ Compile. Simply store the parse (sub)tree.
<<Commands: cmd reweight: TBP>>=
procedure :: compile => cmd_reweight_compile
<<Commands: procedures>>=
subroutine cmd_reweight_compile (cmd, global)
class(cmd_reweight_t), intent(inout) :: cmd
type(rt_data_t), intent(inout), target :: global
cmd%pn_expr => parse_node_get_sub_ptr (cmd%pn, 3)
end subroutine cmd_reweight_compile
@ %def cmd_reweight_compile
@ Instead of evaluating the expression, link the parse tree to the
global data set, such that it is compiled and executed in the
appropriate process context.
<<Commands: cmd reweight: TBP>>=
procedure :: execute => cmd_reweight_execute
<<Commands: procedures>>=
subroutine cmd_reweight_execute (cmd, global)
class(cmd_reweight_t), intent(inout) :: cmd
type(rt_data_t), intent(inout), target :: global
global%pn%reweight_expr => cmd%pn_expr
end subroutine cmd_reweight_execute
@ %def cmd_reweight_execute
@
\subsubsection{Alternative Simulation Setups}
Together with simulation, we can re-evaluate event weights in the context of
alternative setups. The [[cmd_alt_setup_t]] object is designed to hold these
setups, which are brace-enclosed command lists. Compilation is deferred to
the simulation environment where the setup expression is used.
<<Commands: types>>=
type, extends (command_t) :: cmd_alt_setup_t
private
type(parse_node_p), dimension(:), allocatable :: setup
contains
<<Commands: cmd alt setup: TBP>>
end type cmd_alt_setup_t
@ %def cmd_alt_setup_t
@ Output. Print just a message that the alternative setup list has been
defined.
<<Commands: cmd alt setup: TBP>>=
procedure :: write => cmd_alt_setup_write
<<Commands: procedures>>=
subroutine cmd_alt_setup_write (cmd, unit, indent)
class(cmd_alt_setup_t), intent(in) :: cmd
integer, intent(in), optional :: unit, indent
integer :: u
u = given_output_unit (unit); if (u < 0) return
call write_indent (u, indent)
write (u, "(1x,A,I0,A)") "alt_setup: ", size (cmd%setup), " entries"
end subroutine cmd_alt_setup_write
@ %def cmd_alt_setup_write
@ Compile. Store the parse sub-trees in an array.
<<Commands: cmd alt setup: TBP>>=
procedure :: compile => cmd_alt_setup_compile
<<Commands: procedures>>=
subroutine cmd_alt_setup_compile (cmd, global)
class(cmd_alt_setup_t), intent(inout) :: cmd
type(rt_data_t), intent(inout), target :: global
type(parse_node_t), pointer :: pn_list, pn_setup
integer :: i
pn_list => parse_node_get_sub_ptr (cmd%pn, 3)
if (associated (pn_list)) then
allocate (cmd%setup (parse_node_get_n_sub (pn_list)))
i = 1
pn_setup => parse_node_get_sub_ptr (pn_list)
do while (associated (pn_setup))
cmd%setup(i)%ptr => pn_setup
i = i + 1
pn_setup => parse_node_get_next_ptr (pn_setup)
end do
else
allocate (cmd%setup (0))
end if
end subroutine cmd_alt_setup_compile
@ %def cmd_alt_setup_compile
@ Execute. Transfer the array of command lists to the global environment.
<<Commands: cmd alt setup: TBP>>=
procedure :: execute => cmd_alt_setup_execute
<<Commands: procedures>>=
subroutine cmd_alt_setup_execute (cmd, global)
class(cmd_alt_setup_t), intent(inout) :: cmd
type(rt_data_t), intent(inout), target :: global
if (allocated (global%pn%alt_setup)) deallocate (global%pn%alt_setup)
allocate (global%pn%alt_setup (size (cmd%setup)))
global%pn%alt_setup = cmd%setup
end subroutine cmd_alt_setup_execute
@ %def cmd_alt_setup_execute
@
\subsubsection{Integration}
Integrate several processes, consecutively with identical parameters.
<<Commands: types>>=
type, extends (command_t) :: cmd_integrate_t
private
integer :: n_proc = 0
type(string_t), dimension(:), allocatable :: process_id
contains
<<Commands: cmd integrate: TBP>>
end type cmd_integrate_t
@ %def cmd_integrate_t
@ Output: we know the process IDs.
<<Commands: cmd integrate: TBP>>=
procedure :: write => cmd_integrate_write
<<Commands: procedures>>=
subroutine cmd_integrate_write (cmd, unit, indent)
class(cmd_integrate_t), intent(in) :: cmd
integer, intent(in), optional :: unit, indent
integer :: u, i
u = given_output_unit (unit); if (u < 0) return
call write_indent (u, indent)
write (u, "(1x,A)", advance="no") "integrate ("
do i = 1, cmd%n_proc
if (i > 1) write (u, "(A,1x)", advance="no") ","
write (u, "(A)", advance="no") char (cmd%process_id(i))
end do
write (u, "(A)") ")"
end subroutine cmd_integrate_write
@ %def cmd_integrate_write
@ Compile.
<<Commands: cmd integrate: TBP>>=
procedure :: compile => cmd_integrate_compile
<<Commands: procedures>>=
subroutine cmd_integrate_compile (cmd, global)
class(cmd_integrate_t), intent(inout) :: cmd
type(rt_data_t), intent(inout), target :: global
type(parse_node_t), pointer :: pn_proclist, pn_proc
integer :: i
pn_proclist => parse_node_get_sub_ptr (cmd%pn, 2)
cmd%pn_opt => parse_node_get_next_ptr (pn_proclist)
call cmd%compile_options (global)
cmd%n_proc = parse_node_get_n_sub (pn_proclist)
allocate (cmd%process_id (cmd%n_proc))
pn_proc => parse_node_get_sub_ptr (pn_proclist)
do i = 1, cmd%n_proc
cmd%process_id(i) = parse_node_get_string (pn_proc)
call global%process_stack%init_result_vars (cmd%process_id(i))
pn_proc => parse_node_get_next_ptr (pn_proc)
end do
end subroutine cmd_integrate_compile
@ %def cmd_integrate_compile
@ Command execution. Integrate the process(es) with the predefined number
of passes, iterations and calls. For structure functions, cuts,
weight and scale, use local definitions if present; by default, the local
definitions are initialized with the global ones.
The [[integrate]] procedure should take its input from the currently
active local environment, but produce a process record in the stack of
the global environment.
Since the process acquires a snapshot of the variable list, so if the global
list (or the local one) is deleted, this does no harm. This implies that
later changes of the variable list do not affect the stored process.
<<Commands: cmd integrate: TBP>>=
procedure :: execute => cmd_integrate_execute
<<Commands: procedures>>=
subroutine cmd_integrate_execute (cmd, global)
class(cmd_integrate_t), intent(inout) :: cmd
type(rt_data_t), intent(inout), target :: global
integer :: i
if (debug_on) call msg_debug (D_CORE, "cmd_integrate_execute")
do i = 1, cmd%n_proc
if (debug_on) call msg_debug (D_CORE, "cmd%process_id(i) ", cmd%process_id(i))
call integrate_process (cmd%process_id(i), cmd%local, global)
call global%process_stack%fill_result_vars (cmd%process_id(i))
call global%process_stack%update_result_vars &
(cmd%process_id(i), global%var_list)
if (signal_is_pending ()) return
end do
end subroutine cmd_integrate_execute
@ %def cmd_integrate_execute
@
\subsubsection{Observables}
Declare an observable. After the declaration, it can be used to
record data, and at the end one can retrieve average and error.
<<Commands: types>>=
type, extends (command_t) :: cmd_observable_t
private
type(string_t) :: id
contains
<<Commands: cmd observable: TBP>>
end type cmd_observable_t
@ %def cmd_observable_t
@ Output. We know the ID.
<<Commands: cmd observable: TBP>>=
procedure :: write => cmd_observable_write
<<Commands: procedures>>=
subroutine cmd_observable_write (cmd, unit, indent)
class(cmd_observable_t), intent(in) :: cmd
integer, intent(in), optional :: unit, indent
integer :: u
u = given_output_unit (unit); if (u < 0) return
call write_indent (u, indent)
write (u, "(1x,A,A)") "observable: ", char (cmd%id)
end subroutine cmd_observable_write
@ %def cmd_observable_write
@ Compile. Just record the observable ID.
<<Commands: cmd observable: TBP>>=
procedure :: compile => cmd_observable_compile
<<Commands: procedures>>=
subroutine cmd_observable_compile (cmd, global)
class(cmd_observable_t), intent(inout) :: cmd
type(rt_data_t), intent(inout), target :: global
type(parse_node_t), pointer :: pn_tag
pn_tag => parse_node_get_sub_ptr (cmd%pn, 2)
if (associated (pn_tag)) then
cmd%pn_opt => parse_node_get_next_ptr (pn_tag)
end if
call cmd%compile_options (global)
select case (char (parse_node_get_rule_key (pn_tag)))
case ("analysis_id")
cmd%id = parse_node_get_string (pn_tag)
case default
call msg_bug ("observable: name expression not implemented (yet)")
end select
end subroutine cmd_observable_compile
@ %def cmd_observable_compile
@ Command execution. This declares the observable and allocates it in
the analysis store.
<<Commands: cmd observable: TBP>>=
procedure :: execute => cmd_observable_execute
<<Commands: procedures>>=
subroutine cmd_observable_execute (cmd, global)
class(cmd_observable_t), intent(inout) :: cmd
type(rt_data_t), intent(inout), target :: global
type(var_list_t), pointer :: var_list
type(graph_options_t) :: graph_options
type(string_t) :: label, unit
var_list => cmd%local%get_var_list_ptr ()
label = var_list%get_sval (var_str ("$obs_label"))
unit = var_list%get_sval (var_str ("$obs_unit"))
call graph_options_init (graph_options)
call set_graph_options (graph_options, var_list)
call analysis_init_observable (cmd%id, label, unit, graph_options)
end subroutine cmd_observable_execute
@ %def cmd_observable_execute
@
\subsubsection{Histograms}
Declare a histogram. At minimum, we have to set lower and upper bound
and bin width.
<<Commands: types>>=
type, extends (command_t) :: cmd_histogram_t
private
type(string_t) :: id
type(parse_node_t), pointer :: pn_lower_bound => null ()
type(parse_node_t), pointer :: pn_upper_bound => null ()
type(parse_node_t), pointer :: pn_bin_width => null ()
contains
<<Commands: cmd histogram: TBP>>
end type cmd_histogram_t
@ %def cmd_histogram_t
@ Output. Just print the ID.
<<Commands: cmd histogram: TBP>>=
procedure :: write => cmd_histogram_write
<<Commands: procedures>>=
subroutine cmd_histogram_write (cmd, unit, indent)
class(cmd_histogram_t), intent(in) :: cmd
integer, intent(in), optional :: unit, indent
integer :: u
u = given_output_unit (unit); if (u < 0) return
call write_indent (u, indent)
write (u, "(1x,A,A)") "histogram: ", char (cmd%id)
end subroutine cmd_histogram_write
@ %def cmd_histogram_write
@ Compile. Record the histogram ID and initialize lower, upper bound
and bin width.
<<Commands: cmd histogram: TBP>>=
procedure :: compile => cmd_histogram_compile
<<Commands: procedures>>=
subroutine cmd_histogram_compile (cmd, global)
class(cmd_histogram_t), intent(inout) :: cmd
type(rt_data_t), intent(inout), target :: global
type(parse_node_t), pointer :: pn_tag, pn_args, pn_arg1, pn_arg2, pn_arg3
character(*), parameter :: e_illegal_use = &
"illegal usage of 'histogram': insufficient number of arguments"
pn_tag => parse_node_get_sub_ptr (cmd%pn, 2)
pn_args => parse_node_get_next_ptr (pn_tag)
if (associated (pn_args)) then
pn_arg1 => parse_node_get_sub_ptr (pn_args)
if (.not. associated (pn_arg1)) call msg_fatal (e_illegal_use)
pn_arg2 => parse_node_get_next_ptr (pn_arg1)
if (.not. associated (pn_arg2)) call msg_fatal (e_illegal_use)
pn_arg3 => parse_node_get_next_ptr (pn_arg2)
cmd%pn_opt => parse_node_get_next_ptr (pn_args)
end if
call cmd%compile_options (global)
select case (char (parse_node_get_rule_key (pn_tag)))
case ("analysis_id")
cmd%id = parse_node_get_string (pn_tag)
case default
call msg_bug ("histogram: name expression not implemented (yet)")
end select
cmd%pn_lower_bound => pn_arg1
cmd%pn_upper_bound => pn_arg2
cmd%pn_bin_width => pn_arg3
end subroutine cmd_histogram_compile
@ %def cmd_histogram_compile
@ Command execution. This declares the histogram and allocates it in
the analysis store.
<<Commands: cmd histogram: TBP>>=
procedure :: execute => cmd_histogram_execute
<<Commands: procedures>>=
subroutine cmd_histogram_execute (cmd, global)
class(cmd_histogram_t), intent(inout) :: cmd
type(rt_data_t), intent(inout), target :: global
type(var_list_t), pointer :: var_list
real(default) :: lower_bound, upper_bound, bin_width
integer :: bin_number
logical :: bin_width_is_used, normalize_bins
type(string_t) :: obs_label, obs_unit
type(graph_options_t) :: graph_options
type(drawing_options_t) :: drawing_options
var_list => cmd%local%get_var_list_ptr ()
lower_bound = eval_real (cmd%pn_lower_bound, var_list)
upper_bound = eval_real (cmd%pn_upper_bound, var_list)
if (associated (cmd%pn_bin_width)) then
bin_width = eval_real (cmd%pn_bin_width, var_list)
bin_width_is_used = .true.
else if (var_list%is_known (var_str ("n_bins"))) then
bin_number = &
var_list%get_ival (var_str ("n_bins"))
bin_width_is_used = .false.
else
call msg_error ("Cmd '" // char (cmd%id) // &
"': neither bin width nor number is defined")
end if
normalize_bins = &
var_list%get_lval (var_str ("?normalize_bins"))
obs_label = &
var_list%get_sval (var_str ("$obs_label"))
obs_unit = &
var_list%get_sval (var_str ("$obs_unit"))
call graph_options_init (graph_options)
call set_graph_options (graph_options, var_list)
call drawing_options_init_histogram (drawing_options)
call set_drawing_options (drawing_options, var_list)
if (bin_width_is_used) then
call analysis_init_histogram &
(cmd%id, lower_bound, upper_bound, bin_width, &
normalize_bins, &
obs_label, obs_unit, &
graph_options, drawing_options)
else
call analysis_init_histogram &
(cmd%id, lower_bound, upper_bound, bin_number, &
normalize_bins, &
obs_label, obs_unit, &
graph_options, drawing_options)
end if
end subroutine cmd_histogram_execute
@ %def cmd_histogram_execute
@ Set the graph options from a variable list.
<<Commands: procedures>>=
subroutine set_graph_options (gro, var_list)
type(graph_options_t), intent(inout) :: gro
type(var_list_t), intent(in) :: var_list
call graph_options_set (gro, title = &
var_list%get_sval (var_str ("$title")))
call graph_options_set (gro, description = &
var_list%get_sval (var_str ("$description")))
call graph_options_set (gro, x_label = &
var_list%get_sval (var_str ("$x_label")))
call graph_options_set (gro, y_label = &
var_list%get_sval (var_str ("$y_label")))
call graph_options_set (gro, width_mm = &
var_list%get_ival (var_str ("graph_width_mm")))
call graph_options_set (gro, height_mm = &
var_list%get_ival (var_str ("graph_height_mm")))
call graph_options_set (gro, x_log = &
var_list%get_lval (var_str ("?x_log")))
call graph_options_set (gro, y_log = &
var_list%get_lval (var_str ("?y_log")))
if (var_list%is_known (var_str ("x_min"))) &
call graph_options_set (gro, x_min = &
var_list%get_rval (var_str ("x_min")))
if (var_list%is_known (var_str ("x_max"))) &
call graph_options_set (gro, x_max = &
var_list%get_rval (var_str ("x_max")))
if (var_list%is_known (var_str ("y_min"))) &
call graph_options_set (gro, y_min = &
var_list%get_rval (var_str ("y_min")))
if (var_list%is_known (var_str ("y_max"))) &
call graph_options_set (gro, y_max = &
var_list%get_rval (var_str ("y_max")))
call graph_options_set (gro, gmlcode_bg = &
var_list%get_sval (var_str ("$gmlcode_bg")))
call graph_options_set (gro, gmlcode_fg = &
var_list%get_sval (var_str ("$gmlcode_fg")))
end subroutine set_graph_options
@ %def set_graph_options
@ Set the drawing options from a variable list.
<<Commands: procedures>>=
subroutine set_drawing_options (dro, var_list)
type(drawing_options_t), intent(inout) :: dro
type(var_list_t), intent(in) :: var_list
if (var_list%is_known (var_str ("?draw_histogram"))) then
if (var_list%get_lval (var_str ("?draw_histogram"))) then
call drawing_options_set (dro, with_hbars = .true.)
else
call drawing_options_set (dro, with_hbars = .false., &
with_base = .false., fill = .false., piecewise = .false.)
end if
end if
if (var_list%is_known (var_str ("?draw_base"))) then
if (var_list%get_lval (var_str ("?draw_base"))) then
call drawing_options_set (dro, with_base = .true.)
else
call drawing_options_set (dro, with_base = .false., fill = .false.)
end if
end if
if (var_list%is_known (var_str ("?draw_piecewise"))) then
if (var_list%get_lval (var_str ("?draw_piecewise"))) then
call drawing_options_set (dro, piecewise = .true.)
else
call drawing_options_set (dro, piecewise = .false.)
end if
end if
if (var_list%is_known (var_str ("?fill_curve"))) then
if (var_list%get_lval (var_str ("?fill_curve"))) then
call drawing_options_set (dro, fill = .true., with_base = .true.)
else
call drawing_options_set (dro, fill = .false.)
end if
end if
if (var_list%is_known (var_str ("?draw_curve"))) then
if (var_list%get_lval (var_str ("?draw_curve"))) then
call drawing_options_set (dro, draw = .true.)
else
call drawing_options_set (dro, draw = .false.)
end if
end if
if (var_list%is_known (var_str ("?draw_errors"))) then
if (var_list%get_lval (var_str ("?draw_errors"))) then
call drawing_options_set (dro, err = .true.)
else
call drawing_options_set (dro, err = .false.)
end if
end if
if (var_list%is_known (var_str ("?draw_symbols"))) then
if (var_list%get_lval (var_str ("?draw_symbols"))) then
call drawing_options_set (dro, symbols = .true.)
else
call drawing_options_set (dro, symbols = .false.)
end if
end if
if (var_list%is_known (var_str ("$fill_options"))) then
call drawing_options_set (dro, fill_options = &
var_list%get_sval (var_str ("$fill_options")))
end if
if (var_list%is_known (var_str ("$draw_options"))) then
call drawing_options_set (dro, draw_options = &
var_list%get_sval (var_str ("$draw_options")))
end if
if (var_list%is_known (var_str ("$err_options"))) then
call drawing_options_set (dro, err_options = &
var_list%get_sval (var_str ("$err_options")))
end if
if (var_list%is_known (var_str ("$symbol"))) then
call drawing_options_set (dro, symbol = &
var_list%get_sval (var_str ("$symbol")))
end if
if (var_list%is_known (var_str ("$gmlcode_bg"))) then
call drawing_options_set (dro, gmlcode_bg = &
var_list%get_sval (var_str ("$gmlcode_bg")))
end if
if (var_list%is_known (var_str ("$gmlcode_fg"))) then
call drawing_options_set (dro, gmlcode_fg = &
var_list%get_sval (var_str ("$gmlcode_fg")))
end if
end subroutine set_drawing_options
@ %def set_drawing_options
@
\subsubsection{Plots}
Declare a plot. No mandatory arguments, just options.
<<Commands: types>>=
type, extends (command_t) :: cmd_plot_t
private
type(string_t) :: id
contains
<<Commands: cmd plot: TBP>>
end type cmd_plot_t
@ %def cmd_plot_t
@ Output. Just print the ID.
<<Commands: cmd plot: TBP>>=
procedure :: write => cmd_plot_write
<<Commands: procedures>>=
subroutine cmd_plot_write (cmd, unit, indent)
class(cmd_plot_t), intent(in) :: cmd
integer, intent(in), optional :: unit, indent
integer :: u
u = given_output_unit (unit); if (u < 0) return
call write_indent (u, indent)
write (u, "(1x,A,A)") "plot: ", char (cmd%id)
end subroutine cmd_plot_write
@ %def cmd_plot_write
@ Compile. Record the plot ID and initialize lower, upper bound
and bin width.
<<Commands: cmd plot: TBP>>=
procedure :: compile => cmd_plot_compile
<<Commands: procedures>>=
subroutine cmd_plot_compile (cmd, global)
class(cmd_plot_t), intent(inout) :: cmd
type(rt_data_t), intent(inout), target :: global
type(parse_node_t), pointer :: pn_tag
pn_tag => parse_node_get_sub_ptr (cmd%pn, 2)
cmd%pn_opt => parse_node_get_next_ptr (pn_tag)
call cmd%init (pn_tag, global)
end subroutine cmd_plot_compile
@ %def cmd_plot_compile
@ This init routine is separated because it is reused below for graph
initialization.
<<Commands: cmd plot: TBP>>=
procedure :: init => cmd_plot_init
<<Commands: procedures>>=
subroutine cmd_plot_init (plot, pn_tag, global)
class(cmd_plot_t), intent(inout) :: plot
type(parse_node_t), intent(in), pointer :: pn_tag
type(rt_data_t), intent(inout), target :: global
call plot%compile_options (global)
select case (char (parse_node_get_rule_key (pn_tag)))
case ("analysis_id")
plot%id = parse_node_get_string (pn_tag)
case default
call msg_bug ("plot: name expression not implemented (yet)")
end select
end subroutine cmd_plot_init
@ %def cmd_plot_init
@ Command execution. This declares the plot and allocates it in
the analysis store.
<<Commands: cmd plot: TBP>>=
procedure :: execute => cmd_plot_execute
<<Commands: procedures>>=
subroutine cmd_plot_execute (cmd, global)
class(cmd_plot_t), intent(inout) :: cmd
type(rt_data_t), intent(inout), target :: global
type(var_list_t), pointer :: var_list
type(graph_options_t) :: graph_options
type(drawing_options_t) :: drawing_options
var_list => cmd%local%get_var_list_ptr ()
call graph_options_init (graph_options)
call set_graph_options (graph_options, var_list)
call drawing_options_init_plot (drawing_options)
call set_drawing_options (drawing_options, var_list)
call analysis_init_plot (cmd%id, graph_options, drawing_options)
end subroutine cmd_plot_execute
@ %def cmd_plot_execute
@
\subsubsection{Graphs}
Declare a graph. The graph is defined in terms of its contents. Both the
graph and its contents may carry options.
The graph object contains its own ID as well as the IDs of its elements. For
the elements, we reuse the [[cmd_plot_t]] defined above.
<<Commands: types>>=
type, extends (command_t) :: cmd_graph_t
private
type(string_t) :: id
integer :: n_elements = 0
type(cmd_plot_t), dimension(:), allocatable :: el
type(string_t), dimension(:), allocatable :: element_id
contains
<<Commands: cmd graph: TBP>>
end type cmd_graph_t
@ %def cmd_graph_t
@ Output. Just print the ID.
<<Commands: cmd graph: TBP>>=
procedure :: write => cmd_graph_write
<<Commands: procedures>>=
subroutine cmd_graph_write (cmd, unit, indent)
class(cmd_graph_t), intent(in) :: cmd
integer, intent(in), optional :: unit, indent
integer :: u
u = given_output_unit (unit); if (u < 0) return
call write_indent (u, indent)
write (u, "(1x,A,A,A,I0,A)") "graph: ", char (cmd%id), &
" (", cmd%n_elements, " entries)"
end subroutine cmd_graph_write
@ %def cmd_graph_write
@ Compile. Record the graph ID and initialize lower, upper bound
and bin width. For compiling the graph element syntax, we use part of the
[[cmd_plot_t]] compiler.
Note: currently, we do not respect options, therefore just IDs on the RHS.
<<Commands: cmd graph: TBP>>=
procedure :: compile => cmd_graph_compile
<<Commands: procedures>>=
subroutine cmd_graph_compile (cmd, global)
class(cmd_graph_t), intent(inout) :: cmd
type(rt_data_t), intent(inout), target :: global
type(parse_node_t), pointer :: pn_term, pn_tag, pn_def, pn_app
integer :: i
pn_term => parse_node_get_sub_ptr (cmd%pn, 2)
pn_tag => parse_node_get_sub_ptr (pn_term)
cmd%pn_opt => parse_node_get_next_ptr (pn_tag)
call cmd%compile_options (global)
select case (char (parse_node_get_rule_key (pn_tag)))
case ("analysis_id")
cmd%id = parse_node_get_string (pn_tag)
case default
call msg_bug ("graph: name expression not implemented (yet)")
end select
pn_def => parse_node_get_next_ptr (pn_term, 2)
cmd%n_elements = parse_node_get_n_sub (pn_def)
allocate (cmd%element_id (cmd%n_elements))
allocate (cmd%el (cmd%n_elements))
pn_term => parse_node_get_sub_ptr (pn_def)
pn_tag => parse_node_get_sub_ptr (pn_term)
cmd%el(1)%pn_opt => parse_node_get_next_ptr (pn_tag)
call cmd%el(1)%init (pn_tag, global)
cmd%element_id(1) = parse_node_get_string (pn_tag)
pn_app => parse_node_get_next_ptr (pn_term)
do i = 2, cmd%n_elements
pn_term => parse_node_get_sub_ptr (pn_app, 2)
pn_tag => parse_node_get_sub_ptr (pn_term)
cmd%el(i)%pn_opt => parse_node_get_next_ptr (pn_tag)
call cmd%el(i)%init (pn_tag, global)
cmd%element_id(i) = parse_node_get_string (pn_tag)
pn_app => parse_node_get_next_ptr (pn_app)
end do
end subroutine cmd_graph_compile
@ %def cmd_graph_compile
@ Command execution. This declares the graph, allocates it in
the analysis store, and copies the graph elements.
For the graph, we set graph and default drawing options. For the elements, we
reset individual drawing options.
This accesses internals of the contained elements of type [[cmd_plot_t]], see
above. We might disentangle such an interdependency when this code is
rewritten using proper type extension.
<<Commands: cmd graph: TBP>>=
procedure :: execute => cmd_graph_execute
<<Commands: procedures>>=
subroutine cmd_graph_execute (cmd, global)
class(cmd_graph_t), intent(inout) :: cmd
type(rt_data_t), intent(inout), target :: global
type(var_list_t), pointer :: var_list
type(graph_options_t) :: graph_options
type(drawing_options_t) :: drawing_options
integer :: i, type
var_list => cmd%local%get_var_list_ptr ()
call graph_options_init (graph_options)
call set_graph_options (graph_options, var_list)
call analysis_init_graph (cmd%id, cmd%n_elements, graph_options)
do i = 1, cmd%n_elements
if (associated (cmd%el(i)%options)) then
call cmd%el(i)%options%execute (cmd%el(i)%local)
end if
type = analysis_store_get_object_type (cmd%element_id(i))
select case (type)
case (AN_HISTOGRAM)
call drawing_options_init_histogram (drawing_options)
case (AN_PLOT)
call drawing_options_init_plot (drawing_options)
end select
call set_drawing_options (drawing_options, var_list)
if (associated (cmd%el(i)%options)) then
call set_drawing_options (drawing_options, cmd%el(i)%local%var_list)
end if
call analysis_fill_graph (cmd%id, i, cmd%element_id(i), drawing_options)
end do
end subroutine cmd_graph_execute
@ %def cmd_graph_execute
@
\subsubsection{Analysis}
Hold the analysis ID either as a string or as an expression:
<<Commands: types>>=
type :: analysis_id_t
type(string_t) :: tag
type(parse_node_t), pointer :: pn_sexpr => null ()
end type analysis_id_t
@ %def analysis_id_t
@ Define the analysis expression. We store the parse tree for the
right-hand side instead of compiling it. Compilation is deferred to
the process environment where the analysis expression is used.
<<Commands: types>>=
type, extends (command_t) :: cmd_analysis_t
private
type(parse_node_t), pointer :: pn_lexpr => null ()
contains
<<Commands: cmd analysis: TBP>>
end type cmd_analysis_t
@ %def cmd_analysis_t
@ Output. Print just a message that analysis has been defined.
<<Commands: cmd analysis: TBP>>=
procedure :: write => cmd_analysis_write
<<Commands: procedures>>=
subroutine cmd_analysis_write (cmd, unit, indent)
class(cmd_analysis_t), intent(in) :: cmd
integer, intent(in), optional :: unit, indent
integer :: u
u = given_output_unit (unit); if (u < 0) return
call write_indent (u, indent)
write (u, "(1x,A)") "analysis: [defined]"
end subroutine cmd_analysis_write
@ %def cmd_analysis_write
@ Compile. Simply store the parse (sub)tree.
<<Commands: cmd analysis: TBP>>=
procedure :: compile => cmd_analysis_compile
<<Commands: procedures>>=
subroutine cmd_analysis_compile (cmd, global)
class(cmd_analysis_t), intent(inout) :: cmd
type(rt_data_t), intent(inout), target :: global
cmd%pn_lexpr => parse_node_get_sub_ptr (cmd%pn, 3)
end subroutine cmd_analysis_compile
@ %def cmd_analysis_compile
@ Instead of evaluating the cut expression, link the parse tree to the
global data set, such that it is compiled and executed in the
appropriate process context.
<<Commands: cmd analysis: TBP>>=
procedure :: execute => cmd_analysis_execute
<<Commands: procedures>>=
subroutine cmd_analysis_execute (cmd, global)
class(cmd_analysis_t), intent(inout) :: cmd
type(rt_data_t), intent(inout), target :: global
global%pn%analysis_lexpr => cmd%pn_lexpr
end subroutine cmd_analysis_execute
@ %def cmd_analysis_execute
@
\subsubsection{Write histograms and plots}
The data type encapsulating the command:
<<Commands: types>>=
type, extends (command_t) :: cmd_write_analysis_t
private
type(analysis_id_t), dimension(:), allocatable :: id
type(string_t), dimension(:), allocatable :: tag
contains
<<Commands: cmd write analysis: TBP>>
end type cmd_write_analysis_t
@ %def analysis_id_t
@ %def cmd_write_analysis_t
@ Output. Just the keyword.
<<Commands: cmd write analysis: TBP>>=
procedure :: write => cmd_write_analysis_write
<<Commands: procedures>>=
subroutine cmd_write_analysis_write (cmd, unit, indent)
class(cmd_write_analysis_t), intent(in) :: cmd
integer, intent(in), optional :: unit, indent
integer :: u
u = given_output_unit (unit); if (u < 0) return
call write_indent (u, indent)
write (u, "(1x,A)") "write_analysis"
end subroutine cmd_write_analysis_write
@ %def cmd_write_analysis_write
@ Compile.
<<Commands: cmd write analysis: TBP>>=
procedure :: compile => cmd_write_analysis_compile
<<Commands: procedures>>=
subroutine cmd_write_analysis_compile (cmd, global)
class(cmd_write_analysis_t), intent(inout) :: cmd
type(rt_data_t), intent(inout), target :: global
type(parse_node_t), pointer :: pn_clause, pn_args, pn_id
integer :: n, i
pn_clause => parse_node_get_sub_ptr (cmd%pn)
pn_args => parse_node_get_sub_ptr (pn_clause, 2)
cmd%pn_opt => parse_node_get_next_ptr (pn_clause)
call cmd%compile_options (global)
if (associated (pn_args)) then
n = parse_node_get_n_sub (pn_args)
allocate (cmd%id (n))
do i = 1, n
pn_id => parse_node_get_sub_ptr (pn_args, i)
if (char (parse_node_get_rule_key (pn_id)) == "analysis_id") then
cmd%id(i)%tag = parse_node_get_string (pn_id)
else
cmd%id(i)%pn_sexpr => pn_id
end if
end do
else
allocate (cmd%id (0))
end if
end subroutine cmd_write_analysis_compile
@ %def cmd_write_analysis_compile
@ The output format for real data values:
<<Commands: parameters>>=
character(*), parameter, public :: &
DEFAULT_ANALYSIS_FILENAME = "whizard_analysis.dat"
character(len=1), dimension(2), parameter, public :: &
FORBIDDEN_ENDINGS1 = [ "o", "a" ]
character(len=2), dimension(6), parameter, public :: &
FORBIDDEN_ENDINGS2 = [ "mp", "ps", "vg", "pg", "lo", "la" ]
character(len=3), dimension(18), parameter, public :: &
FORBIDDEN_ENDINGS3 = [ "aux", "dvi", "evt", "evx", "f03", "f90", &
"f95", "log", "ltp", "mpx", "olc", "olp", "pdf", "phs", "sin", &
"tex", "vg2", "vgx" ]
@ %def DEFAULT_ANALYSIS_FILENAME
@ %def FORBIDDEN_ENDINGS1
@ %def FORBIDDEN_ENDINGS2
@ %def FORBIDDEN_ENDINGS3
@ As this contains a lot of similar code to [[cmd_compile_analysis_execute]]
we outsource the main code to a subroutine.
<<Commands: cmd write analysis: TBP>>=
procedure :: execute => cmd_write_analysis_execute
<<Commands: procedures>>=
subroutine cmd_write_analysis_execute (cmd, global)
class(cmd_write_analysis_t), intent(inout) :: cmd
type(rt_data_t), intent(inout), target :: global
type(var_list_t), pointer :: var_list
var_list => cmd%local%get_var_list_ptr ()
call write_analysis_wrap (var_list, global%out_files, &
cmd%id, tag = cmd%tag)
end subroutine cmd_write_analysis_execute
@ %def cmd_write_analysis_execute
@ If the [[data_file]] optional argument is present, this is
called from [[cmd_compile_analysis_execute]], which needs the file name for
further processing, and requires the default format. For the moment,
parameters and macros for custom data processing are disabled.
<<Commands: procedures>>=
subroutine write_analysis_wrap (var_list, out_files, id, tag, data_file)
type(var_list_t), intent(inout), target :: var_list
type(file_list_t), intent(inout), target :: out_files
type(analysis_id_t), dimension(:), intent(in), target :: id
type(string_t), dimension(:), allocatable, intent(out) :: tag
type(string_t), intent(out), optional :: data_file
type(string_t) :: defaultfile, file
integer :: i
logical :: keep_open !, custom, header, columns
type(string_t) :: extension !, comment_prefix, separator
!!! JRR: WK please check (#542)
! integer :: type
! type(ifile_t) :: ifile
logical :: one_file !, has_writer
! type(analysis_iterator_t) :: iterator
! type(rt_data_t), target :: sandbox
! type(command_list_t) :: writer
defaultfile = var_list%get_sval (var_str ("$out_file"))
if (present (data_file)) then
if (defaultfile == "" .or. defaultfile == ".") then
defaultfile = DEFAULT_ANALYSIS_FILENAME
else
if (scan (".", defaultfile) > 0) then
call split (defaultfile, extension, ".", back=.true.)
if (any (lower_case (char(extension)) == FORBIDDEN_ENDINGS1) .or. &
any (lower_case (char(extension)) == FORBIDDEN_ENDINGS2) .or. &
any (lower_case (char(extension)) == FORBIDDEN_ENDINGS3)) &
call msg_fatal ("The ending " // char(extension) // &
" is internal and not allowed as data file.")
if (extension /= "") then
if (defaultfile /= "") then
defaultfile = defaultfile // "." // extension
else
defaultfile = "whizard_analysis." // extension
end if
else
defaultfile = defaultfile // ".dat"
endif
else
defaultfile = defaultfile // ".dat"
end if
end if
data_file = defaultfile
end if
one_file = defaultfile /= ""
if (one_file) then
file = defaultfile
keep_open = file_list_is_open (out_files, file, &
action = "write")
if (keep_open) then
if (present (data_file)) then
call msg_fatal ("Compiling analysis: File '" &
// char (data_file) &
// "' can't be used, it is already open.")
else
call msg_message ("Appending analysis data to file '" &
// char (file) // "'")
end if
else
call file_list_open (out_files, file, &
action = "write", status = "replace", position = "asis")
call msg_message ("Writing analysis data to file '" &
// char (file) // "'")
end if
end if
!!! JRR: WK please check. Custom data output. Ticket #542
! if (present (data_file)) then
! custom = .false.
! else
! custom = var_list%get_lval (&
! var_str ("?out_custom"))
! end if
! comment_prefix = var_list%get_sval (&
! var_str ("$out_comment"))
! header = var_list%get_lval (&
! var_str ("?out_header"))
! write_yerr = var_list%get_lval (&
! var_str ("?out_yerr"))
! write_xerr = var_list%get_lval (&
! var_str ("?out_xerr"))
call get_analysis_tags (tag, id, var_list)
do i = 1, size (tag)
call file_list_write_analysis &
(out_files, file, tag(i))
end do
if (one_file .and. .not. keep_open) then
call file_list_close (out_files, file)
end if
contains
subroutine get_analysis_tags (analysis_tag, id, var_list)
type(string_t), dimension(:), intent(out), allocatable :: analysis_tag
type(analysis_id_t), dimension(:), intent(in) :: id
type(var_list_t), intent(in), target :: var_list
if (size (id) /= 0) then
allocate (analysis_tag (size (id)))
do i = 1, size (id)
if (associated (id(i)%pn_sexpr)) then
analysis_tag(i) = eval_string (id(i)%pn_sexpr, var_list)
else
analysis_tag(i) = id(i)%tag
end if
end do
else
call analysis_store_get_ids (tag)
end if
end subroutine get_analysis_tags
end subroutine write_analysis_wrap
@ %def write_analysis_wrap
\subsubsection{Compile analysis results}
This command writes files in a form suitable for GAMELAN and executes the
appropriate commands to compile them. The first part is identical to
[[cmd_write_analysis]].
<<Commands: types>>=
type, extends (command_t) :: cmd_compile_analysis_t
private
type(analysis_id_t), dimension(:), allocatable :: id
type(string_t), dimension(:), allocatable :: tag
contains
<<Commands: cmd compile analysis: TBP>>
end type cmd_compile_analysis_t
@ %def cmd_compile_analysis_t
@ Output. Just the keyword.
<<Commands: cmd compile analysis: TBP>>=
procedure :: write => cmd_compile_analysis_write
<<Commands: procedures>>=
subroutine cmd_compile_analysis_write (cmd, unit, indent)
class(cmd_compile_analysis_t), intent(in) :: cmd
integer, intent(in), optional :: unit, indent
integer :: u
u = given_output_unit (unit); if (u < 0) return
call write_indent (u, indent)
write (u, "(1x,A)") "compile_analysis"
end subroutine cmd_compile_analysis_write
@ %def cmd_compile_analysis_write
@ Compile.
<<Commands: cmd compile analysis: TBP>>=
procedure :: compile => cmd_compile_analysis_compile
<<Commands: procedures>>=
subroutine cmd_compile_analysis_compile (cmd, global)
class(cmd_compile_analysis_t), intent(inout) :: cmd
type(rt_data_t), intent(inout), target :: global
type(parse_node_t), pointer :: pn_clause, pn_args, pn_id
integer :: n, i
pn_clause => parse_node_get_sub_ptr (cmd%pn)
pn_args => parse_node_get_sub_ptr (pn_clause, 2)
cmd%pn_opt => parse_node_get_next_ptr (pn_clause)
call cmd%compile_options (global)
if (associated (pn_args)) then
n = parse_node_get_n_sub (pn_args)
allocate (cmd%id (n))
do i = 1, n
pn_id => parse_node_get_sub_ptr (pn_args, i)
if (char (parse_node_get_rule_key (pn_id)) == "analysis_id") then
cmd%id(i)%tag = parse_node_get_string (pn_id)
else
cmd%id(i)%pn_sexpr => pn_id
end if
end do
else
allocate (cmd%id (0))
end if
end subroutine cmd_compile_analysis_compile
@ %def cmd_compile_analysis_compile
@ First write the analysis data to file, then write a GAMELAN driver and
produce MetaPost and \TeX\ output.
<<Commands: cmd compile analysis: TBP>>=
procedure :: execute => cmd_compile_analysis_execute
<<Commands: procedures>>=
subroutine cmd_compile_analysis_execute (cmd, global)
class(cmd_compile_analysis_t), intent(inout) :: cmd
type(rt_data_t), intent(inout), target :: global
type(var_list_t), pointer :: var_list
type(string_t) :: file, basename, extension, driver_file, &
makefile
integer :: u_driver, u_makefile
logical :: has_gmlcode, only_file
var_list => cmd%local%get_var_list_ptr ()
call write_analysis_wrap (var_list, &
global%out_files, cmd%id, tag = cmd%tag, &
data_file = file)
basename = file
if (scan (".", basename) > 0) then
call split (basename, extension, ".", back=.true.)
else
extension = ""
end if
driver_file = basename // ".tex"
makefile = basename // "_ana.makefile"
u_driver = free_unit ()
open (unit=u_driver, file=char(driver_file), &
action="write", status="replace")
if (allocated (cmd%tag)) then
call analysis_write_driver (file, cmd%tag, unit=u_driver)
has_gmlcode = analysis_has_plots (cmd%tag)
else
call analysis_write_driver (file, unit=u_driver)
has_gmlcode = analysis_has_plots ()
end if
close (u_driver)
u_makefile = free_unit ()
open (unit=u_makefile, file=char(makefile), &
action="write", status="replace")
call analysis_write_makefile (basename, u_makefile, &
has_gmlcode, global%os_data)
close (u_makefile)
call msg_message ("Compiling analysis results display in '" &
// char (driver_file) // "'")
call msg_message ("Providing analysis steering makefile '" &
// char (makefile) // "'")
only_file = global%var_list%get_lval &
(var_str ("?analysis_file_only"))
if (.not. only_file) call analysis_compile_tex &
(basename, has_gmlcode, global%os_data)
end subroutine cmd_compile_analysis_execute
@ %def cmd_compile_analysis_execute
@
\subsection{User-controlled output to data files}
\subsubsection{Open file (output)}
Open a file for output.
<<Commands: types>>=
type, extends (command_t) :: cmd_open_out_t
private
type(parse_node_t), pointer :: file_expr => null ()
contains
<<Commands: cmd open out: TBP>>
end type cmd_open_out_t
@ %def cmd_open_out
@ Finalizer for the embedded eval tree.
<<Commands: procedures>>=
subroutine cmd_open_out_final (object)
class(cmd_open_out_t), intent(inout) :: object
end subroutine cmd_open_out_final
@ %def cmd_open_out_final
@ Output (trivial here).
<<Commands: cmd open out: TBP>>=
procedure :: write => cmd_open_out_write
<<Commands: procedures>>=
subroutine cmd_open_out_write (cmd, unit, indent)
class(cmd_open_out_t), intent(in) :: cmd
integer, intent(in), optional :: unit, indent
integer :: u
u = given_output_unit (unit); if (u < 0) return
call write_indent (u, indent)
write (u, "(1x,A)", advance="no") "open_out: <filename>"
end subroutine cmd_open_out_write
@ %def cmd_open_out_write
@ Compile: create an eval tree for the filename expression.
<<Commands: cmd open out: TBP>>=
procedure :: compile => cmd_open_out_compile
<<Commands: procedures>>=
subroutine cmd_open_out_compile (cmd, global)
class(cmd_open_out_t), intent(inout) :: cmd
type(rt_data_t), intent(inout), target :: global
cmd%file_expr => parse_node_get_sub_ptr (cmd%pn, 2)
if (associated (cmd%file_expr)) then
cmd%pn_opt => parse_node_get_next_ptr (cmd%file_expr)
end if
call cmd%compile_options (global)
end subroutine cmd_open_out_compile
@ %def cmd_open_out_compile
@ Execute: append the file to the global list of open files.
<<Commands: cmd open out: TBP>>=
procedure :: execute => cmd_open_out_execute
<<Commands: procedures>>=
subroutine cmd_open_out_execute (cmd, global)
class(cmd_open_out_t), intent(inout) :: cmd
type(rt_data_t), intent(inout), target :: global
type(var_list_t), pointer :: var_list
type(eval_tree_t) :: file_expr
type(string_t) :: file
var_list => cmd%local%get_var_list_ptr ()
call file_expr%init_sexpr (cmd%file_expr, var_list)
call file_expr%evaluate ()
if (file_expr%is_known ()) then
file = file_expr%get_string ()
call file_list_open (global%out_files, file, &
action = "write", status = "replace", position = "asis")
else
call msg_fatal ("open_out: file name argument evaluates to unknown")
end if
call file_expr%final ()
end subroutine cmd_open_out_execute
@ %def cmd_open_out_execute
\subsubsection{Open file (output)}
Close an output file. Except for the [[execute]] method, everything is
analogous to the open command, so we can just inherit.
<<Commands: types>>=
type, extends (cmd_open_out_t) :: cmd_close_out_t
private
contains
<<Commands: cmd close out: TBP>>
end type cmd_close_out_t
@ %def cmd_close_out
@ Execute: remove the file from the global list of output files.
<<Commands: cmd close out: TBP>>=
procedure :: execute => cmd_close_out_execute
<<Commands: procedures>>=
subroutine cmd_close_out_execute (cmd, global)
class(cmd_close_out_t), intent(inout) :: cmd
type(rt_data_t), intent(inout), target :: global
type(var_list_t), pointer :: var_list
type(eval_tree_t) :: file_expr
type(string_t) :: file
var_list => cmd%local%var_list
call file_expr%init_sexpr (cmd%file_expr, var_list)
call file_expr%evaluate ()
if (file_expr%is_known ()) then
file = file_expr%get_string ()
call file_list_close (global%out_files, file)
else
call msg_fatal ("close_out: file name argument evaluates to unknown")
end if
call file_expr%final ()
end subroutine cmd_close_out_execute
@ %def cmd_close_out_execute
@
\subsection{Print custom-formatted values}
<<Commands: types>>=
type, extends (command_t) :: cmd_printf_t
private
type(parse_node_t), pointer :: sexpr => null ()
type(parse_node_t), pointer :: sprintf_fun => null ()
type(parse_node_t), pointer :: sprintf_clause => null ()
type(parse_node_t), pointer :: sprintf => null ()
contains
<<Commands: cmd printf: TBP>>
end type cmd_printf_t
@ %def cmd_printf_t
@ Finalize.
<<Commands: cmd printf: TBP>>=
procedure :: final => cmd_printf_final
<<Commands: procedures>>=
subroutine cmd_printf_final (cmd)
class(cmd_printf_t), intent(inout) :: cmd
call parse_node_final (cmd%sexpr, recursive = .false.)
deallocate (cmd%sexpr)
call parse_node_final (cmd%sprintf_fun, recursive = .false.)
deallocate (cmd%sprintf_fun)
call parse_node_final (cmd%sprintf_clause, recursive = .false.)
deallocate (cmd%sprintf_clause)
call parse_node_final (cmd%sprintf, recursive = .false.)
deallocate (cmd%sprintf)
end subroutine cmd_printf_final
@ %def cmd_printf_final
@ Output. Do not print the parse tree, since this may get cluttered.
Just a message that cuts have been defined.
<<Commands: cmd printf: TBP>>=
procedure :: write => cmd_printf_write
<<Commands: procedures>>=
subroutine cmd_printf_write (cmd, unit, indent)
class(cmd_printf_t), intent(in) :: cmd
integer, intent(in), optional :: unit, indent
integer :: u
u = given_output_unit (unit); if (u < 0) return
call write_indent (u, indent)
write (u, "(1x,A)") "printf:"
end subroutine cmd_printf_write
@ %def cmd_printf_write
@ Compile. We create a fake parse node (subtree) with a [[sprintf]] command
with identical arguments which can then be handled by the corresponding
evaluation procedure.
<<Commands: cmd printf: TBP>>=
procedure :: compile => cmd_printf_compile
<<Commands: procedures>>=
subroutine cmd_printf_compile (cmd, global)
class(cmd_printf_t), intent(inout) :: cmd
type(rt_data_t), intent(inout), target :: global
type(parse_node_t), pointer :: pn_cmd, pn_clause, pn_args, pn_format
pn_cmd => parse_node_get_sub_ptr (cmd%pn)
pn_clause => parse_node_get_sub_ptr (pn_cmd)
pn_format => parse_node_get_sub_ptr (pn_clause, 2)
pn_args => parse_node_get_next_ptr (pn_clause)
cmd%pn_opt => parse_node_get_next_ptr (pn_cmd)
call cmd%compile_options (global)
allocate (cmd%sexpr)
call parse_node_create_branch (cmd%sexpr, &
syntax_get_rule_ptr (syntax_cmd_list, var_str ("sexpr")))
allocate (cmd%sprintf_fun)
call parse_node_create_branch (cmd%sprintf_fun, &
syntax_get_rule_ptr (syntax_cmd_list, var_str ("sprintf_fun")))
allocate (cmd%sprintf_clause)
call parse_node_create_branch (cmd%sprintf_clause, &
syntax_get_rule_ptr (syntax_cmd_list, var_str ("sprintf_clause")))
allocate (cmd%sprintf)
call parse_node_create_key (cmd%sprintf, &
syntax_get_rule_ptr (syntax_cmd_list, var_str ("sprintf")))
call parse_node_append_sub (cmd%sprintf_clause, cmd%sprintf)
call parse_node_append_sub (cmd%sprintf_clause, pn_format)
call parse_node_freeze_branch (cmd%sprintf_clause)
call parse_node_append_sub (cmd%sprintf_fun, cmd%sprintf_clause)
if (associated (pn_args)) then
call parse_node_append_sub (cmd%sprintf_fun, pn_args)
end if
call parse_node_freeze_branch (cmd%sprintf_fun)
call parse_node_append_sub (cmd%sexpr, cmd%sprintf_fun)
call parse_node_freeze_branch (cmd%sexpr)
end subroutine cmd_printf_compile
@ %def cmd_printf_compile
@ Execute. Evaluate the string (pretending this is a [[sprintf]] expression)
and print it.
<<Commands: cmd printf: TBP>>=
procedure :: execute => cmd_printf_execute
<<Commands: procedures>>=
subroutine cmd_printf_execute (cmd, global)
class(cmd_printf_t), intent(inout) :: cmd
type(rt_data_t), intent(inout), target :: global
type(var_list_t), pointer :: var_list
type(string_t) :: string, file
type(eval_tree_t) :: sprintf_expr
logical :: advance
var_list => cmd%local%get_var_list_ptr ()
advance = var_list%get_lval (&
var_str ("?out_advance"))
file = var_list%get_sval (&
var_str ("$out_file"))
call sprintf_expr%init_sexpr (cmd%sexpr, var_list)
call sprintf_expr%evaluate ()
if (sprintf_expr%is_known ()) then
string = sprintf_expr%get_string ()
if (len (file) == 0) then
call msg_result (char (string))
else
call file_list_write (global%out_files, file, string, advance)
end if
end if
end subroutine cmd_printf_execute
@ %def cmd_printf_execute
@
\subsubsection{Record data}
The expression syntax already contains a [[record]] keyword; this evaluates to
a logical which is always true, but it has the side-effect of recording data
into analysis objects. Here we define a command as an interface to this
construct.
<<Commands: types>>=
type, extends (command_t) :: cmd_record_t
private
type(parse_node_t), pointer :: pn_lexpr => null ()
contains
<<Commands: cmd record: TBP>>
end type cmd_record_t
@ %def cmd_record_t
@ Output. With the compile hack below, there is nothing of interest
to print here.
<<Commands: cmd record: TBP>>=
procedure :: write => cmd_record_write
<<Commands: procedures>>=
subroutine cmd_record_write (cmd, unit, indent)
class(cmd_record_t), intent(in) :: cmd
integer, intent(in), optional :: unit, indent
integer :: u
u = given_output_unit (unit); if (u < 0) return
call write_indent (u, indent)
write (u, "(1x,A)") "record"
end subroutine cmd_record_write
@ %def cmd_record_write
@ Compile. This is a hack which transforms the [[record]] command
into a [[record]] expression, which we handle in the [[expressions]]
module.
<<Commands: cmd record: TBP>>=
procedure :: compile => cmd_record_compile
<<Commands: procedures>>=
subroutine cmd_record_compile (cmd, global)
class(cmd_record_t), intent(inout) :: cmd
type(rt_data_t), intent(inout), target :: global
type(parse_node_t), pointer :: pn_lexpr, pn_lsinglet, pn_lterm, pn_record
call parse_node_create_branch (pn_lexpr, &
syntax_get_rule_ptr (syntax_cmd_list, var_str ("lexpr")))
call parse_node_create_branch (pn_lsinglet, &
syntax_get_rule_ptr (syntax_cmd_list, var_str ("lsinglet")))
call parse_node_append_sub (pn_lexpr, pn_lsinglet)
call parse_node_create_branch (pn_lterm, &
syntax_get_rule_ptr (syntax_cmd_list, var_str ("lterm")))
call parse_node_append_sub (pn_lsinglet, pn_lterm)
pn_record => parse_node_get_sub_ptr (cmd%pn)
call parse_node_append_sub (pn_lterm, pn_record)
cmd%pn_lexpr => pn_lexpr
end subroutine cmd_record_compile
@ %def cmd_record_compile
@ Command execution. Again, transfer this to the embedded expression
and just forget the logical result.
<<Commands: cmd record: TBP>>=
procedure :: execute => cmd_record_execute
<<Commands: procedures>>=
subroutine cmd_record_execute (cmd, global)
class(cmd_record_t), intent(inout) :: cmd
type(rt_data_t), intent(inout), target :: global
type(var_list_t), pointer :: var_list
logical :: lval
var_list => global%get_var_list_ptr ()
lval = eval_log (cmd%pn_lexpr, var_list)
end subroutine cmd_record_execute
@ %def cmd_record_execute
@
\subsubsection{Unstable particles}
Mark a particle as unstable. For each unstable particle, we store a
number of decay channels and compute their respective BRs.
<<Commands: types>>=
type, extends (command_t) :: cmd_unstable_t
private
integer :: n_proc = 0
type(string_t), dimension(:), allocatable :: process_id
type(parse_node_t), pointer :: pn_prt_in => null ()
contains
<<Commands: cmd unstable: TBP>>
end type cmd_unstable_t
@ %def cmd_unstable_t
@ Output: we know the process IDs.
<<Commands: cmd unstable: TBP>>=
procedure :: write => cmd_unstable_write
<<Commands: procedures>>=
subroutine cmd_unstable_write (cmd, unit, indent)
class(cmd_unstable_t), intent(in) :: cmd
integer, intent(in), optional :: unit, indent
integer :: u, i
u = given_output_unit (unit); if (u < 0) return
call write_indent (u, indent)
write (u, "(1x,A,1x,I0,1x,A)", advance="no") &
"unstable:", 1, "("
do i = 1, cmd%n_proc
if (i > 1) write (u, "(A,1x)", advance="no") ","
write (u, "(A)", advance="no") char (cmd%process_id(i))
end do
write (u, "(A)") ")"
end subroutine cmd_unstable_write
@ %def cmd_unstable_write
@ Compile. Initiate an eval tree for the decaying particle and
determine the decay channel process IDs.
<<Commands: cmd unstable: TBP>>=
procedure :: compile => cmd_unstable_compile
<<Commands: procedures>>=
subroutine cmd_unstable_compile (cmd, global)
class(cmd_unstable_t), intent(inout) :: cmd
type(rt_data_t), intent(inout), target :: global
type(parse_node_t), pointer :: pn_list, pn_proc
integer :: i
cmd%pn_prt_in => parse_node_get_sub_ptr (cmd%pn, 2)
pn_list => parse_node_get_next_ptr (cmd%pn_prt_in)
if (associated (pn_list)) then
select case (char (parse_node_get_rule_key (pn_list)))
case ("unstable_arg")
cmd%n_proc = parse_node_get_n_sub (pn_list)
cmd%pn_opt => parse_node_get_next_ptr (pn_list)
case default
cmd%n_proc = 0
cmd%pn_opt => pn_list
pn_list => null ()
end select
end if
call cmd%compile_options (global)
if (associated (pn_list)) then
allocate (cmd%process_id (cmd%n_proc))
pn_proc => parse_node_get_sub_ptr (pn_list)
do i = 1, cmd%n_proc
cmd%process_id(i) = parse_node_get_string (pn_proc)
call cmd%local%process_stack%init_result_vars (cmd%process_id(i))
pn_proc => parse_node_get_next_ptr (pn_proc)
end do
else
allocate (cmd%process_id (0))
end if
end subroutine cmd_unstable_compile
@ %def cmd_unstable_compile
@ Command execution. Evaluate the decaying particle and mark the decays in
the current model object.
<<Commands: cmd unstable: TBP>>=
procedure :: execute => cmd_unstable_execute
<<Commands: procedures>>=
subroutine cmd_unstable_execute (cmd, global)
class(cmd_unstable_t), intent(inout) :: cmd
type(rt_data_t), intent(inout), target :: global
type(var_list_t), pointer :: var_list
logical :: auto_decays, auto_decays_radiative
integer :: auto_decays_multiplicity
logical :: isotropic_decay, diagonal_decay, polarized_decay
integer :: decay_helicity
type(pdg_array_t) :: pa_in
integer :: pdg_in
type(string_t) :: libname_cur, libname_dec
type(string_t), dimension(:), allocatable :: auto_id, tmp_id
integer :: n_proc_user
integer :: i, u_tmp
character(80) :: buffer
var_list => cmd%local%get_var_list_ptr ()
auto_decays = &
var_list%get_lval (var_str ("?auto_decays"))
if (auto_decays) then
auto_decays_multiplicity = &
var_list%get_ival (var_str ("auto_decays_multiplicity"))
auto_decays_radiative = &
var_list%get_lval (var_str ("?auto_decays_radiative"))
end if
isotropic_decay = &
var_list%get_lval (var_str ("?isotropic_decay"))
if (isotropic_decay) then
diagonal_decay = .false.
polarized_decay = .false.
else
diagonal_decay = &
var_list%get_lval (var_str ("?diagonal_decay"))
if (diagonal_decay) then
polarized_decay = .false.
else
polarized_decay = &
var_list%is_known (var_str ("decay_helicity"))
if (polarized_decay) then
decay_helicity = var_list%get_ival (var_str ("decay_helicity"))
end if
end if
end if
pa_in = eval_pdg_array (cmd%pn_prt_in, var_list)
if (pdg_array_get_length (pa_in) /= 1) &
call msg_fatal ("Unstable: decaying particle must be unique")
pdg_in = pdg_array_get (pa_in, 1)
n_proc_user = cmd%n_proc
if (auto_decays) then
call create_auto_decays (pdg_in, &
auto_decays_multiplicity, auto_decays_radiative, &
libname_dec, auto_id, cmd%local)
allocate (tmp_id (cmd%n_proc + size (auto_id)))
tmp_id(:cmd%n_proc) = cmd%process_id
tmp_id(cmd%n_proc+1:) = auto_id
call move_alloc (from = tmp_id, to = cmd%process_id)
cmd%n_proc = size (cmd%process_id)
end if
libname_cur = cmd%local%prclib%get_name ()
do i = 1, cmd%n_proc
if (i == n_proc_user + 1) then
call cmd%local%update_prclib &
(cmd%local%prclib_stack%get_library_ptr (libname_dec))
end if
if (.not. global%process_stack%exists (cmd%process_id(i))) then
call var_list%set_log &
(var_str ("?decay_rest_frame"), .false., is_known = .true.)
call integrate_process (cmd%process_id(i), cmd%local, global)
call global%process_stack%fill_result_vars (cmd%process_id(i))
end if
end do
call cmd%local%update_prclib &
(cmd%local%prclib_stack%get_library_ptr (libname_cur))
if (cmd%n_proc > 0) then
if (polarized_decay) then
call global%modify_particle (pdg_in, stable = .false., &
decay = cmd%process_id, &
isotropic_decay = .false., &
diagonal_decay = .false., &
decay_helicity = decay_helicity, &
polarized = .false.)
else
call global%modify_particle (pdg_in, stable = .false., &
decay = cmd%process_id, &
isotropic_decay = isotropic_decay, &
diagonal_decay = diagonal_decay, &
polarized = .false.)
end if
u_tmp = free_unit ()
open (u_tmp, status = "scratch", action = "readwrite")
call show_unstable (global, pdg_in, u_tmp)
rewind (u_tmp)
do
read (u_tmp, "(A)", end = 1) buffer
write (msg_buffer, "(A)") trim (buffer)
call msg_message ()
end do
1 continue
close (u_tmp)
else
call err_unstable (global, pdg_in)
end if
end subroutine cmd_unstable_execute
@ %def cmd_unstable_execute
@ Show data for the current unstable particle. This is called both by
the [[unstable]] and by the [[show]] command.
To determine decay branching rations, we look at the decay process IDs
and inspect the corresponding [[integral()]] result variables.
<<Commands: procedures>>=
subroutine show_unstable (global, pdg, u)
type(rt_data_t), intent(in), target :: global
integer, intent(in) :: pdg, u
type(flavor_t) :: flv
type(string_t), dimension(:), allocatable :: decay
real(default), dimension(:), allocatable :: br
real(default) :: width
type(process_t), pointer :: process
type(process_component_def_t), pointer :: prc_def
type(string_t), dimension(:), allocatable :: prt_out, prt_out_str
integer :: i, j
logical :: opened
call flv%init (pdg, global%model)
call flv%get_decays (decay)
if (.not. allocated (decay)) return
allocate (prt_out_str (size (decay)))
allocate (br (size (decay)))
do i = 1, size (br)
process => global%process_stack%get_process_ptr (decay(i))
prc_def => process%get_component_def_ptr (1)
call prc_def%get_prt_out (prt_out)
prt_out_str(i) = prt_out(1)
do j = 2, size (prt_out)
prt_out_str(i) = prt_out_str(i) // ", " // prt_out(j)
end do
br(i) = global%get_rval ("integral(" // decay(i) // ")")
end do
if (all (br >= 0)) then
if (any (br > 0)) then
width = sum (br)
br = br / sum (br)
write (u, "(A)") "Unstable particle " &
// char (flv%get_name ()) &
// ": computed branching ratios:"
do i = 1, size (br)
write (u, "(2x,A,':'," // FMT_14 // ",3x,A)") &
char (decay(i)), br(i), char (prt_out_str(i))
end do
write (u, "(2x,'Total width ='," // FMT_14 // ",' GeV (computed)')") width
write (u, "(2x,' ='," // FMT_14 // ",' GeV (preset)')") &
flv%get_width ()
if (flv%decays_isotropically ()) then
write (u, "(2x,A)") "Decay options: isotropic"
else if (flv%decays_diagonal ()) then
write (u, "(2x,A)") "Decay options: &
&projection on diagonal helicity states"
else if (flv%has_decay_helicity ()) then
write (u, "(2x,A,1x,I0)") "Decay options: projection onto helicity =", &
flv%get_decay_helicity ()
else
write (u, "(2x,A)") "Decay options: helicity treated exactly"
end if
else
inquire (unit = u, opened = opened)
if (opened .and. .not. mask_fatal_errors) close (u)
call msg_fatal ("Unstable particle " &
// char (flv%get_name ()) &
// ": partial width vanishes for all decay channels")
end if
else
inquire (unit = u, opened = opened)
if (opened .and. .not. mask_fatal_errors) close (u)
call msg_fatal ("Unstable particle " &
// char (flv%get_name ()) &
// ": partial width is negative")
end if
end subroutine show_unstable
@ %def show_unstable
@ If no decays have been found, issue a non-fatal error.
<<Commands: procedures>>=
subroutine err_unstable (global, pdg)
type(rt_data_t), intent(in), target :: global
integer, intent(in) :: pdg
type(flavor_t) :: flv
call flv%init (pdg, global%model)
call msg_error ("Unstable: no allowed decays found for particle " &
// char (flv%get_name ()) // ", keeping as stable")
end subroutine err_unstable
@ %def err_unstable
@ Auto decays: create process IDs and make up process
configurations, using the PDG codes generated by the [[ds_table]] make
method.
We allocate and use a self-contained process library that contains only the
decay processes of the current particle. When done, we revert the global
library pointer to the original library but return the name of the new one.
The new library becomes part of the global library stack and can thus be
referred to at any time.
<<Commands: procedures>>=
subroutine create_auto_decays &
(pdg_in, mult, rad, libname_dec, process_id, global)
integer, intent(in) :: pdg_in
integer, intent(in) :: mult
logical, intent(in) :: rad
type(string_t), intent(out) :: libname_dec
type(string_t), dimension(:), allocatable, intent(out) :: process_id
type(rt_data_t), intent(inout) :: global
type(prclib_entry_t), pointer :: lib_entry
type(process_library_t), pointer :: lib
type(ds_table_t) :: ds_table
type(split_constraints_t) :: constraints
type(pdg_array_t), dimension(:), allocatable :: pa_out
character(80) :: buffer
character :: p_or_a
type(string_t) :: process_string, libname_cur
type(flavor_t) :: flv_in, flv_out
type(string_t) :: prt_in
type(string_t), dimension(:), allocatable :: prt_out
type(process_configuration_t) :: prc_config
integer :: i, j, k
call flv_in%init (pdg_in, global%model)
if (rad) then
call constraints%init (2)
else
call constraints%init (3)
call constraints%set (3, constrain_radiation ())
end if
call constraints%set (1, constrain_n_tot (mult))
call constraints%set (2, &
constrain_mass_sum (flv_in%get_mass (), margin = 0._default))
call ds_table%make (global%model, pdg_in, constraints)
prt_in = flv_in%get_name ()
if (pdg_in > 0) then
p_or_a = "p"
else
p_or_a = "a"
end if
if (ds_table%get_length () == 0) then
call msg_warning ("Auto-decays: Particle " // char (prt_in) // ": " &
// "no decays found")
libname_dec = ""
allocate (process_id (0))
else
call msg_message ("Creating decay process library for particle " &
// char (prt_in))
libname_cur = global%prclib%get_name ()
write (buffer, "(A,A,I0)") "_d", p_or_a, abs (pdg_in)
libname_dec = libname_cur // trim (buffer)
lib => global%prclib_stack%get_library_ptr (libname_dec)
if (.not. (associated (lib))) then
allocate (lib_entry)
call lib_entry%init (libname_dec)
lib => lib_entry%process_library_t
call global%add_prclib (lib_entry)
else
call global%update_prclib (lib)
end if
allocate (process_id (ds_table%get_length ()))
do i = 1, size (process_id)
write (buffer, "(A,'_',A,I0,'_',I0)") &
"decay", p_or_a, abs (pdg_in), i
process_id(i) = trim (buffer)
process_string = process_id(i) // ": " // prt_in // " =>"
call ds_table%get_pdg_out (i, pa_out)
allocate (prt_out (size (pa_out)))
do j = 1, size (pa_out)
do k = 1, pa_out(j)%get_length ()
call flv_out%init (pa_out(j)%get (k), global%model)
if (k == 1) then
prt_out(j) = flv_out%get_name ()
else
prt_out(j) = prt_out(j) // ":" // flv_out%get_name ()
end if
end do
process_string = process_string // " " // prt_out(j)
end do
call msg_message (char (process_string))
call prc_config%init (process_id(i), 1, 1, &
global%model, global%var_list, &
nlo_process = global%nlo_fixed_order)
call prc_config%setup_component (1, new_prt_spec ([prt_in]), &
new_prt_spec (prt_out), global%model, global%var_list)
call prc_config%record (global)
deallocate (prt_out)
deallocate (pa_out)
end do
lib => global%prclib_stack%get_library_ptr (libname_cur)
call global%update_prclib (lib)
end if
call ds_table%final ()
end subroutine create_auto_decays
@ %def create_auto_decays
@
\subsubsection{(Stable particles}
Revert the unstable declaration for a list of particles.
<<Commands: types>>=
type, extends (command_t) :: cmd_stable_t
private
type(parse_node_p), dimension(:), allocatable :: pn_pdg
contains
<<Commands: cmd stable: TBP>>
end type cmd_stable_t
@ %def cmd_stable_t
@ Output: we know only the number of particles.
<<Commands: cmd stable: TBP>>=
procedure :: write => cmd_stable_write
<<Commands: procedures>>=
subroutine cmd_stable_write (cmd, unit, indent)
class(cmd_stable_t), intent(in) :: cmd
integer, intent(in), optional :: unit, indent
integer :: u
u = given_output_unit (unit); if (u < 0) return
call write_indent (u, indent)
write (u, "(1x,A,1x,I0)") "stable:", size (cmd%pn_pdg)
end subroutine cmd_stable_write
@ %def cmd_stable_write
@ Compile. Assign parse nodes for the particle IDs.
<<Commands: cmd stable: TBP>>=
procedure :: compile => cmd_stable_compile
<<Commands: procedures>>=
subroutine cmd_stable_compile (cmd, global)
class(cmd_stable_t), intent(inout) :: cmd
type(rt_data_t), intent(inout), target :: global
type(parse_node_t), pointer :: pn_list, pn_prt
integer :: n, i
pn_list => parse_node_get_sub_ptr (cmd%pn, 2)
cmd%pn_opt => parse_node_get_next_ptr (pn_list)
call cmd%compile_options (global)
n = parse_node_get_n_sub (pn_list)
allocate (cmd%pn_pdg (n))
pn_prt => parse_node_get_sub_ptr (pn_list)
i = 1
do while (associated (pn_prt))
cmd%pn_pdg(i)%ptr => pn_prt
pn_prt => parse_node_get_next_ptr (pn_prt)
i = i + 1
end do
end subroutine cmd_stable_compile
@ %def cmd_stable_compile
@ Execute: apply the modifications to the current model.
<<Commands: cmd stable: TBP>>=
procedure :: execute => cmd_stable_execute
<<Commands: procedures>>=
subroutine cmd_stable_execute (cmd, global)
class(cmd_stable_t), intent(inout) :: cmd
type(rt_data_t), target, intent(inout) :: global
type(var_list_t), pointer :: var_list
type(pdg_array_t) :: pa
integer :: pdg
type(flavor_t) :: flv
integer :: i
var_list => cmd%local%get_var_list_ptr ()
do i = 1, size (cmd%pn_pdg)
pa = eval_pdg_array (cmd%pn_pdg(i)%ptr, var_list)
if (pdg_array_get_length (pa) /= 1) &
call msg_fatal ("Stable: listed particles must be unique")
pdg = pdg_array_get (pa, 1)
call global%modify_particle (pdg, stable = .true., &
isotropic_decay = .false., &
diagonal_decay = .false., &
polarized = .false.)
call flv%init (pdg, cmd%local%model)
call msg_message ("Particle " &
// char (flv%get_name ()) &
// " declared as stable")
end do
end subroutine cmd_stable_execute
@ %def cmd_stable_execute
@
\subsubsection{Polarized particles}
These commands mark particles as (un)polarized, to be applied in
subsequent simulation passes. Since this is technically the same as
the [[stable]] command, we take a shortcut and make this an extension,
just overriding methods.
<<Commands: types>>=
type, extends (cmd_stable_t) :: cmd_polarized_t
contains
<<Commands: cmd polarized: TBP>>
end type cmd_polarized_t
type, extends (cmd_stable_t) :: cmd_unpolarized_t
contains
<<Commands: cmd unpolarized: TBP>>
end type cmd_unpolarized_t
@ %def cmd_polarized_t cmd_unpolarized_t
@ Output: we know only the number of particles.
<<Commands: cmd polarized: TBP>>=
procedure :: write => cmd_polarized_write
<<Commands: cmd unpolarized: TBP>>=
procedure :: write => cmd_unpolarized_write
<<Commands: procedures>>=
subroutine cmd_polarized_write (cmd, unit, indent)
class(cmd_polarized_t), intent(in) :: cmd
integer, intent(in), optional :: unit, indent
integer :: u
u = given_output_unit (unit); if (u < 0) return
call write_indent (u, indent)
write (u, "(1x,A,1x,I0)") "polarized:", size (cmd%pn_pdg)
end subroutine cmd_polarized_write
subroutine cmd_unpolarized_write (cmd, unit, indent)
class(cmd_unpolarized_t), intent(in) :: cmd
integer, intent(in), optional :: unit, indent
integer :: u
u = given_output_unit (unit); if (u < 0) return
call write_indent (u, indent)
write (u, "(1x,A,1x,I0)") "unpolarized:", size (cmd%pn_pdg)
end subroutine cmd_unpolarized_write
@ %def cmd_polarized_write
@ %def cmd_unpolarized_write
@ Compile: accounted for by the base command.
Execute: apply the modifications to the current model.
<<Commands: cmd polarized: TBP>>=
procedure :: execute => cmd_polarized_execute
<<Commands: cmd unpolarized: TBP>>=
procedure :: execute => cmd_unpolarized_execute
<<Commands: procedures>>=
subroutine cmd_polarized_execute (cmd, global)
class(cmd_polarized_t), intent(inout) :: cmd
type(rt_data_t), target, intent(inout) :: global
type(var_list_t), pointer :: var_list
type(pdg_array_t) :: pa
integer :: pdg
type(flavor_t) :: flv
integer :: i
var_list => cmd%local%get_var_list_ptr ()
do i = 1, size (cmd%pn_pdg)
pa = eval_pdg_array (cmd%pn_pdg(i)%ptr, var_list)
if (pdg_array_get_length (pa) /= 1) &
call msg_fatal ("Polarized: listed particles must be unique")
pdg = pdg_array_get (pa, 1)
call global%modify_particle (pdg, polarized = .true., &
stable = .true., &
isotropic_decay = .false., &
diagonal_decay = .false.)
call flv%init (pdg, cmd%local%model)
call msg_message ("Particle " &
// char (flv%get_name ()) &
// " declared as polarized")
end do
end subroutine cmd_polarized_execute
subroutine cmd_unpolarized_execute (cmd, global)
class(cmd_unpolarized_t), intent(inout) :: cmd
type(rt_data_t), target, intent(inout) :: global
type(var_list_t), pointer :: var_list
type(pdg_array_t) :: pa
integer :: pdg
type(flavor_t) :: flv
integer :: i
var_list => cmd%local%get_var_list_ptr ()
do i = 1, size (cmd%pn_pdg)
pa = eval_pdg_array (cmd%pn_pdg(i)%ptr, var_list)
if (pdg_array_get_length (pa) /= 1) &
call msg_fatal ("Unpolarized: listed particles must be unique")
pdg = pdg_array_get (pa, 1)
call global%modify_particle (pdg, polarized = .false., &
stable = .true., &
isotropic_decay = .false., &
diagonal_decay = .false.)
call flv%init (pdg, cmd%local%model)
call msg_message ("Particle " &
// char (flv%get_name ()) &
// " declared as unpolarized")
end do
end subroutine cmd_unpolarized_execute
@ %def cmd_polarized_execute
@ %def cmd_unpolarized_execute
@
\subsubsection{Parameters: formats for event-sample output}
Specify all event formats that are to be used for output files in the
subsequent simulation run. (The raw format is on by default and can be turned
off here.)
<<Commands: types>>=
type, extends (command_t) :: cmd_sample_format_t
private
type(string_t), dimension(:), allocatable :: format
contains
<<Commands: cmd sample format: TBP>>
end type cmd_sample_format_t
@ %def cmd_sample_format_t
@ Output: here, everything is known.
<<Commands: cmd sample format: TBP>>=
procedure :: write => cmd_sample_format_write
<<Commands: procedures>>=
subroutine cmd_sample_format_write (cmd, unit, indent)
class(cmd_sample_format_t), intent(in) :: cmd
integer, intent(in), optional :: unit, indent
integer :: u, i
u = given_output_unit (unit); if (u < 0) return
call write_indent (u, indent)
write (u, "(1x,A)", advance="no") "sample_format = "
do i = 1, size (cmd%format)
if (i > 1) write (u, "(A,1x)", advance="no") ","
write (u, "(A)", advance="no") char (cmd%format(i))
end do
write (u, "(A)")
end subroutine cmd_sample_format_write
@ %def cmd_sample_format_write
@ Compile. Initialize evaluation trees.
<<Commands: cmd sample format: TBP>>=
procedure :: compile => cmd_sample_format_compile
<<Commands: procedures>>=
subroutine cmd_sample_format_compile (cmd, global)
class(cmd_sample_format_t), intent(inout) :: cmd
type(rt_data_t), intent(inout), target :: global
type(parse_node_t), pointer :: pn_arg
type(parse_node_t), pointer :: pn_format
integer :: i, n_format
pn_arg => parse_node_get_sub_ptr (cmd%pn, 3)
if (associated (pn_arg)) then
n_format = parse_node_get_n_sub (pn_arg)
allocate (cmd%format (n_format))
pn_format => parse_node_get_sub_ptr (pn_arg)
i = 0
do while (associated (pn_format))
i = i + 1
cmd%format(i) = parse_node_get_string (pn_format)
pn_format => parse_node_get_next_ptr (pn_format)
end do
else
allocate (cmd%format (0))
end if
end subroutine cmd_sample_format_compile
@ %def cmd_sample_format_compile
@ Execute. Transfer the list of format specifications to the
corresponding array in the runtime data set.
<<Commands: cmd sample format: TBP>>=
procedure :: execute => cmd_sample_format_execute
<<Commands: procedures>>=
subroutine cmd_sample_format_execute (cmd, global)
class(cmd_sample_format_t), intent(inout) :: cmd
type(rt_data_t), intent(inout), target :: global
if (allocated (global%sample_fmt)) deallocate (global%sample_fmt)
allocate (global%sample_fmt (size (cmd%format)), source = cmd%format)
end subroutine cmd_sample_format_execute
@ %def cmd_sample_format_execute
@
\subsubsection{The simulate command}
This is the actual SINDARIN command.
<<Commands: types>>=
type, extends (command_t) :: cmd_simulate_t
! not private anymore as required by the whizard-c-interface
integer :: n_proc = 0
type(string_t), dimension(:), allocatable :: process_id
contains
<<Commands: cmd simulate: TBP>>
end type cmd_simulate_t
@ %def cmd_simulate_t
@ Output: we know the process IDs.
<<Commands: cmd simulate: TBP>>=
procedure :: write => cmd_simulate_write
<<Commands: procedures>>=
subroutine cmd_simulate_write (cmd, unit, indent)
class(cmd_simulate_t), intent(in) :: cmd
integer, intent(in), optional :: unit, indent
integer :: u, i
u = given_output_unit (unit); if (u < 0) return
call write_indent (u, indent)
write (u, "(1x,A)", advance="no") "simulate ("
do i = 1, cmd%n_proc
if (i > 1) write (u, "(A,1x)", advance="no") ","
write (u, "(A)", advance="no") char (cmd%process_id(i))
end do
write (u, "(A)") ")"
end subroutine cmd_simulate_write
@ %def cmd_simulate_write
@ Compile. In contrast to WHIZARD 1 the confusing option to give the
number of unweighted events for weighted events as if unweighting were
to take place has been abandoned. (We both use [[n_events]] for
weighted and unweighted events, the variable [[n_calls]] from WHIZARD
1 has been discarded.
<<Commands: cmd simulate: TBP>>=
procedure :: compile => cmd_simulate_compile
<<Commands: procedures>>=
subroutine cmd_simulate_compile (cmd, global)
class(cmd_simulate_t), intent(inout) :: cmd
type(rt_data_t), intent(inout), target :: global
type(parse_node_t), pointer :: pn_proclist, pn_proc
integer :: i
pn_proclist => parse_node_get_sub_ptr (cmd%pn, 2)
cmd%pn_opt => parse_node_get_next_ptr (pn_proclist)
call cmd%compile_options (global)
cmd%n_proc = parse_node_get_n_sub (pn_proclist)
allocate (cmd%process_id (cmd%n_proc))
pn_proc => parse_node_get_sub_ptr (pn_proclist)
do i = 1, cmd%n_proc
cmd%process_id(i) = parse_node_get_string (pn_proc)
call global%process_stack%init_result_vars (cmd%process_id(i))
pn_proc => parse_node_get_next_ptr (pn_proc)
end do
end subroutine cmd_simulate_compile
@ %def cmd_simulate_compile
@ Execute command: Simulate events. This is done via a [[simulation_t]]
object and its associated methods.
Signal handling: the [[generate]] method may exit abnormally if there is a
pending signal. The current logic ensures that the [[es_array]] output
channels are closed before the [[execute]] routine returns. The program will
terminate then in [[command_list_execute]].
<<Commands: cmd simulate: TBP>>=
procedure :: execute => cmd_simulate_execute
<<Commands: procedures>>=
subroutine cmd_simulate_execute (cmd, global)
class(cmd_simulate_t), intent(inout) :: cmd
type(rt_data_t), intent(inout), target :: global
type(var_list_t), pointer :: var_list
type(rt_data_t), dimension(:), allocatable, target :: alt_env
integer :: n_events
type(simulation_t), target :: sim
type(event_stream_array_t) :: es_array
integer :: i, checkpoint, callback
var_list => cmd%local%var_list
if (cmd%local%nlo_fixed_order) then
call check_nlo_options (cmd%local)
end if
if (allocated (cmd%local%pn%alt_setup)) then
allocate (alt_env (size (cmd%local%pn%alt_setup)))
do i = 1, size (alt_env)
call build_alt_setup (alt_env(i), cmd%local, &
cmd%local%pn%alt_setup(i)%ptr)
end do
call sim%init (cmd%process_id, .true., .true., cmd%local, global, &
alt_env)
else
call sim%init (cmd%process_id, .true., .true., cmd%local, global)
end if
if (signal_is_pending ()) return
if (sim%is_valid ()) then
call sim%init_process_selector ()
call sim%setup_openmp ()
call sim%compute_n_events (n_events)
call sim%set_n_events_requested (n_events)
call sim%activate_extra_logging ()
call sim%prepare_event_streams (es_array)
if (es_array%is_valid ()) then
call sim%generate (es_array)
else
call sim%generate ()
end if
call es_array%final ()
if (allocated (alt_env)) then
do i = 1, size (alt_env)
call alt_env(i)%local_final ()
end do
end if
end if
call sim%final ()
end subroutine cmd_simulate_execute
@ %def cmd_simulate_execute
@ Build an alternative setup: the parse tree is stored in the global
environment. We create a temporary command list to compile and execute this;
the result is an alternative local environment [[alt_env]] which we can hand
over to the [[simulate]] command.
<<Commands: procedures>>=
recursive subroutine build_alt_setup (alt_env, global, pn)
type(rt_data_t), intent(inout), target :: alt_env
type(rt_data_t), intent(inout), target :: global
type(parse_node_t), intent(in), target :: pn
type(command_list_t), allocatable :: alt_options
allocate (alt_options)
call alt_env%local_init (global)
call alt_env%activate ()
call alt_options%compile (pn, alt_env)
call alt_options%execute (alt_env)
call alt_env%deactivate (global, keep_local = .true.)
call alt_options%final ()
end subroutine build_alt_setup
@ %def build_alt_setup
@
\subsubsection{The rescan command}
This is the actual SINDARIN command.
<<Commands: types>>=
type, extends (command_t) :: cmd_rescan_t
! private
type(parse_node_t), pointer :: pn_filename => null ()
integer :: n_proc = 0
type(string_t), dimension(:), allocatable :: process_id
contains
<<Commands: cmd rescan: TBP>>
end type cmd_rescan_t
@ %def cmd_rescan_t
@ Output: we know the process IDs.
<<Commands: cmd rescan: TBP>>=
procedure :: write => cmd_rescan_write
<<Commands: procedures>>=
subroutine cmd_rescan_write (cmd, unit, indent)
class(cmd_rescan_t), intent(in) :: cmd
integer, intent(in), optional :: unit, indent
integer :: u, i
u = given_output_unit (unit); if (u < 0) return
call write_indent (u, indent)
write (u, "(1x,A)", advance="no") "rescan ("
do i = 1, cmd%n_proc
if (i > 1) write (u, "(A,1x)", advance="no") ","
write (u, "(A)", advance="no") char (cmd%process_id(i))
end do
write (u, "(A)") ")"
end subroutine cmd_rescan_write
@ %def cmd_rescan_write
@ Compile. The command takes a suffix argument, namely the file name
of requested event file.
<<Commands: cmd rescan: TBP>>=
procedure :: compile => cmd_rescan_compile
<<Commands: procedures>>=
subroutine cmd_rescan_compile (cmd, global)
class(cmd_rescan_t), intent(inout) :: cmd
type(rt_data_t), intent(inout), target :: global
type(parse_node_t), pointer :: pn_filename, pn_proclist, pn_proc
integer :: i
pn_filename => parse_node_get_sub_ptr (cmd%pn, 2)
pn_proclist => parse_node_get_next_ptr (pn_filename)
cmd%pn_opt => parse_node_get_next_ptr (pn_proclist)
call cmd%compile_options (global)
cmd%pn_filename => pn_filename
cmd%n_proc = parse_node_get_n_sub (pn_proclist)
allocate (cmd%process_id (cmd%n_proc))
pn_proc => parse_node_get_sub_ptr (pn_proclist)
do i = 1, cmd%n_proc
cmd%process_id(i) = parse_node_get_string (pn_proc)
pn_proc => parse_node_get_next_ptr (pn_proc)
end do
end subroutine cmd_rescan_compile
@ %def cmd_rescan_compile
@ Execute command: Rescan events. This is done via a [[simulation_t]]
object and its associated methods.
<<Commands: cmd rescan: TBP>>=
procedure :: execute => cmd_rescan_execute
<<Commands: procedures>>=
subroutine cmd_rescan_execute (cmd, global)
class(cmd_rescan_t), intent(inout) :: cmd
type(rt_data_t), intent(inout), target :: global
type(var_list_t), pointer :: var_list
type(rt_data_t), dimension(:), allocatable, target :: alt_env
type(string_t) :: sample, sample_suffix
logical :: exist, write_raw, update_event, update_sqme
type(simulation_t), target :: sim
type(event_sample_data_t) :: input_data, data
type(string_t) :: input_sample
integer :: n_fmt
type(string_t), dimension(:), allocatable :: sample_fmt
type(string_t) :: input_format, input_ext, input_file
type(string_t) :: lhef_extension, extension_hepmc, extension_lcio
type(event_stream_array_t) :: es_array
integer :: i, n_events
<<Commands: cmd rescan execute: extra variables>>
var_list => cmd%local%var_list
if (allocated (cmd%local%pn%alt_setup)) then
allocate (alt_env (size (cmd%local%pn%alt_setup)))
do i = 1, size (alt_env)
call build_alt_setup (alt_env(i), cmd%local, &
cmd%local%pn%alt_setup(i)%ptr)
end do
call sim%init (cmd%process_id, .false., .false., cmd%local, global, &
alt_env)
else
call sim%init (cmd%process_id, .false., .false., cmd%local, global)
end if
call sim%compute_n_events (n_events)
input_sample = eval_string (cmd%pn_filename, var_list)
input_format = var_list%get_sval (&
var_str ("$rescan_input_format"))
sample_suffix = ""
<<Commands: cmd rescan execute: extra init>>
sample = var_list%get_sval (var_str ("$sample"))
if (sample == "") then
sample = sim%get_default_sample_name () // sample_suffix
else
sample = var_list%get_sval (var_str ("$sample")) // sample_suffix
end if
write_raw = var_list%get_lval (var_str ("?write_raw"))
if (allocated (cmd%local%sample_fmt)) then
n_fmt = size (cmd%local%sample_fmt)
else
n_fmt = 0
end if
if (write_raw) then
if (sample == input_sample) then
call msg_error ("Rescan: ?write_raw = true: " &
// "suppressing raw event output (filename clashes with input)")
allocate (sample_fmt (n_fmt))
if (n_fmt > 0) sample_fmt = cmd%local%sample_fmt
else
allocate (sample_fmt (n_fmt + 1))
if (n_fmt > 0) sample_fmt(:n_fmt) = cmd%local%sample_fmt
sample_fmt(n_fmt+1) = var_str ("raw")
end if
else
allocate (sample_fmt (n_fmt))
if (n_fmt > 0) sample_fmt = cmd%local%sample_fmt
end if
update_event = &
var_list%get_lval (var_str ("?update_event"))
update_sqme = &
var_list%get_lval (var_str ("?update_sqme"))
if (update_event .or. update_sqme) then
call msg_message ("Recalculating observables")
if (update_sqme) then
call msg_message ("Recalculating squared matrix elements")
end if
end if
lhef_extension = &
var_list%get_sval (var_str ("$lhef_extension"))
extension_hepmc = &
var_list%get_sval (var_str ("$extension_hepmc"))
extension_lcio = &
var_list%get_sval (var_str ("$extension_lcio"))
select case (char (input_format))
case ("raw"); input_ext = "evx"
call cmd%local%set_log &
(var_str ("?recover_beams"), .false., is_known=.true.)
case ("lhef"); input_ext = lhef_extension
case ("hepmc"); input_ext = extension_hepmc
case ("lcio"); input_ext = extension_lcio
case default
call msg_fatal ("rescan: input sample format '" // char (input_format) &
// "' not supported")
end select
input_file = input_sample // "." // input_ext
inquire (file = char (input_file), exist = exist)
if (exist) then
input_data = sim%get_data (alt = .false.)
input_data%n_evt = n_events
data = sim%get_data ()
data%n_evt = n_events
input_data%md5sum_cfg = ""
call es_array%init (sample, &
sample_fmt, cmd%local, data, &
input = input_format, input_sample = input_sample, &
input_data = input_data, &
allow_switch = .false.)
call sim%rescan (n_events, es_array, global = cmd%local)
call es_array%final ()
else
call msg_fatal ("Rescan: event file '" &
// char (input_file) // "' not found")
end if
if (allocated (alt_env)) then
do i = 1, size (alt_env)
call alt_env(i)%local_final ()
end do
end if
call sim%final ()
end subroutine cmd_rescan_execute
@ %def cmd_rescan_execute
@ MPI: Append rank id to sample name.
<<Commands: cmd rescan execute: extra variables>>=
<<MPI: Commands: cmd rescan execute: extra variables>>=
logical :: mpi_logging
integer :: rank, n_size
<<Commands: cmd rescan execute: extra init>>=
<<MPI: Commands: cmd rescan execute: extra init>>=
call mpi_get_comm_id (n_size, rank)
if (n_size > 1) then
sample_suffix = var_str ("_") // str (rank)
end if
mpi_logging = (("vamp2" == char (var_list%get_sval (var_str ("$integration_method"))) &
& .and. (n_size > 1)) &
& .or. var_list%get_lval (var_str ("?mpi_logging")))
call mpi_set_logging (mpi_logging)
@
\subsubsection{Parameters: number of iterations}
Specify number of iterations and number of calls for one integration pass.
<<Commands: types>>=
type, extends (command_t) :: cmd_iterations_t
private
integer :: n_pass = 0
type(parse_node_p), dimension(:), allocatable :: pn_expr_n_it
type(parse_node_p), dimension(:), allocatable :: pn_expr_n_calls
type(parse_node_p), dimension(:), allocatable :: pn_sexpr_adapt
contains
<<Commands: cmd iterations: TBP>>
end type cmd_iterations_t
@ %def cmd_iterations_t
@ Output. Display the number of passes, which is known after compilation.
<<Commands: cmd iterations: TBP>>=
procedure :: write => cmd_iterations_write
<<Commands: procedures>>=
subroutine cmd_iterations_write (cmd, unit, indent)
class(cmd_iterations_t), intent(in) :: cmd
integer, intent(in), optional :: unit, indent
integer :: u
u = given_output_unit (unit); if (u < 0) return
call write_indent (u, indent)
select case (cmd%n_pass)
case (0)
write (u, "(1x,A)") "iterations: [empty]"
case (1)
write (u, "(1x,A,I0,A)") "iterations: ", cmd%n_pass, " pass"
case default
write (u, "(1x,A,I0,A)") "iterations: ", cmd%n_pass, " passes"
end select
end subroutine cmd_iterations_write
@ %def cmd_iterations_write
@ Compile. Initialize evaluation trees.
<<Commands: cmd iterations: TBP>>=
procedure :: compile => cmd_iterations_compile
<<Commands: procedures>>=
subroutine cmd_iterations_compile (cmd, global)
class(cmd_iterations_t), intent(inout) :: cmd
type(rt_data_t), intent(inout), target :: global
type(parse_node_t), pointer :: pn_arg, pn_n_it, pn_n_calls, pn_adapt
type(parse_node_t), pointer :: pn_it_spec, pn_calls_spec, pn_adapt_spec
integer :: i
pn_arg => parse_node_get_sub_ptr (cmd%pn, 3)
if (associated (pn_arg)) then
cmd%n_pass = parse_node_get_n_sub (pn_arg)
allocate (cmd%pn_expr_n_it (cmd%n_pass))
allocate (cmd%pn_expr_n_calls (cmd%n_pass))
allocate (cmd%pn_sexpr_adapt (cmd%n_pass))
pn_it_spec => parse_node_get_sub_ptr (pn_arg)
i = 1
do while (associated (pn_it_spec))
pn_n_it => parse_node_get_sub_ptr (pn_it_spec)
pn_calls_spec => parse_node_get_next_ptr (pn_n_it)
pn_n_calls => parse_node_get_sub_ptr (pn_calls_spec, 2)
pn_adapt_spec => parse_node_get_next_ptr (pn_calls_spec)
if (associated (pn_adapt_spec)) then
pn_adapt => parse_node_get_sub_ptr (pn_adapt_spec, 2)
else
pn_adapt => null ()
end if
cmd%pn_expr_n_it(i)%ptr => pn_n_it
cmd%pn_expr_n_calls(i)%ptr => pn_n_calls
cmd%pn_sexpr_adapt(i)%ptr => pn_adapt
i = i + 1
pn_it_spec => parse_node_get_next_ptr (pn_it_spec)
end do
else
allocate (cmd%pn_expr_n_it (0))
allocate (cmd%pn_expr_n_calls (0))
end if
end subroutine cmd_iterations_compile
@ %def cmd_iterations_compile
@ Execute. Evaluate the trees and transfer the results to the iteration
list in the runtime data set.
<<Commands: cmd iterations: TBP>>=
procedure :: execute => cmd_iterations_execute
<<Commands: procedures>>=
subroutine cmd_iterations_execute (cmd, global)
class(cmd_iterations_t), intent(inout) :: cmd
type(rt_data_t), intent(inout), target :: global
type(var_list_t), pointer :: var_list
integer, dimension(cmd%n_pass) :: n_it, n_calls
logical, dimension(cmd%n_pass) :: custom_adapt
type(string_t), dimension(cmd%n_pass) :: adapt_code
integer :: i
var_list => global%get_var_list_ptr ()
do i = 1, cmd%n_pass
n_it(i) = eval_int (cmd%pn_expr_n_it(i)%ptr, var_list)
n_calls(i) = &
eval_int (cmd%pn_expr_n_calls(i)%ptr, var_list)
if (associated (cmd%pn_sexpr_adapt(i)%ptr)) then
adapt_code(i) = &
eval_string (cmd%pn_sexpr_adapt(i)%ptr, &
var_list, is_known = custom_adapt(i))
else
custom_adapt(i) = .false.
end if
end do
call global%it_list%init (n_it, n_calls, custom_adapt, adapt_code)
end subroutine cmd_iterations_execute
@ %def cmd_iterations_execute
@
\subsubsection{Range expressions}
We need a special type for storing and evaluating range expressions.
<<Commands: parameters>>=
integer, parameter :: STEP_NONE = 0
integer, parameter :: STEP_ADD = 1
integer, parameter :: STEP_SUB = 2
integer, parameter :: STEP_MUL = 3
integer, parameter :: STEP_DIV = 4
integer, parameter :: STEP_COMP_ADD = 11
integer, parameter :: STEP_COMP_MUL = 13
@
There is an abstract base type and two implementations: scan over integers and
scan over reals.
<<Commands: types>>=
type, abstract :: range_t
type(parse_node_t), pointer :: pn_expr => null ()
type(parse_node_t), pointer :: pn_term => null ()
type(parse_node_t), pointer :: pn_factor => null ()
type(parse_node_t), pointer :: pn_value => null ()
type(parse_node_t), pointer :: pn_literal => null ()
type(parse_node_t), pointer :: pn_beg => null ()
type(parse_node_t), pointer :: pn_end => null ()
type(parse_node_t), pointer :: pn_step => null ()
type(eval_tree_t) :: expr_beg
type(eval_tree_t) :: expr_end
type(eval_tree_t) :: expr_step
integer :: step_mode = 0
integer :: n_step = 0
contains
<<Commands: range: TBP>>
end type range_t
@ %def range_t
@ These are the implementations:
<<Commands: types>>=
type, extends (range_t) :: range_int_t
integer :: i_beg = 0
integer :: i_end = 0
integer :: i_step = 0
contains
<<Commands: range int: TBP>>
end type range_int_t
type, extends (range_t) :: range_real_t
real(default) :: r_beg = 0
real(default) :: r_end = 0
real(default) :: r_step = 0
real(default) :: lr_beg = 0
real(default) :: lr_end = 0
real(default) :: lr_step = 0
contains
<<Commands: range real: TBP>>
end type range_real_t
@ %def range_int_t range_real_t
@ Finalize the allocated dummy node. The other nodes are just pointers.
<<Commands: range: TBP>>=
procedure :: final => range_final
<<Commands: procedures>>=
subroutine range_final (object)
class(range_t), intent(inout) :: object
if (associated (object%pn_expr)) then
call parse_node_final (object%pn_expr, recursive = .false.)
call parse_node_final (object%pn_term, recursive = .false.)
call parse_node_final (object%pn_factor, recursive = .false.)
call parse_node_final (object%pn_value, recursive = .false.)
call parse_node_final (object%pn_literal, recursive = .false.)
deallocate (object%pn_expr)
deallocate (object%pn_term)
deallocate (object%pn_factor)
deallocate (object%pn_value)
deallocate (object%pn_literal)
end if
end subroutine range_final
@ %def range_final
@ Output.
<<Commands: range: TBP>>=
procedure (range_write), deferred :: write
procedure :: base_write => range_write
<<Commands: range int: TBP>>=
procedure :: write => range_int_write
<<Commands: range real: TBP>>=
procedure :: write => range_real_write
<<Commands: procedures>>=
subroutine range_write (object, unit)
class(range_t), intent(in) :: object
integer, intent(in), optional :: unit
integer :: u
u = given_output_unit (unit)
write (u, "(1x,A)") "Range specification:"
if (associated (object%pn_expr)) then
write (u, "(1x,A)") "Dummy value:"
call parse_node_write_rec (object%pn_expr, u)
end if
if (associated (object%pn_beg)) then
write (u, "(1x,A)") "Initial value:"
call parse_node_write_rec (object%pn_beg, u)
call object%expr_beg%write (u)
if (associated (object%pn_end)) then
write (u, "(1x,A)") "Final value:"
call parse_node_write_rec (object%pn_end, u)
call object%expr_end%write (u)
if (associated (object%pn_step)) then
write (u, "(1x,A)") "Step value:"
call parse_node_write_rec (object%pn_step, u)
select case (object%step_mode)
case (STEP_ADD); write (u, "(1x,A)") "Step mode: +"
case (STEP_SUB); write (u, "(1x,A)") "Step mode: -"
case (STEP_MUL); write (u, "(1x,A)") "Step mode: *"
case (STEP_DIV); write (u, "(1x,A)") "Step mode: /"
case (STEP_COMP_ADD); write (u, "(1x,A)") "Division mode: +"
case (STEP_COMP_MUL); write (u, "(1x,A)") "Division mode: *"
end select
end if
end if
else
write (u, "(1x,A)") "Expressions: [undefined]"
end if
end subroutine range_write
subroutine range_int_write (object, unit)
class(range_int_t), intent(in) :: object
integer, intent(in), optional :: unit
integer :: u
u = given_output_unit (unit)
call object%base_write (unit)
write (u, "(1x,A)") "Range parameters:"
write (u, "(3x,A,I0)") "i_beg = ", object%i_beg
write (u, "(3x,A,I0)") "i_end = ", object%i_end
write (u, "(3x,A,I0)") "i_step = ", object%i_step
write (u, "(3x,A,I0)") "n_step = ", object%n_step
end subroutine range_int_write
subroutine range_real_write (object, unit)
class(range_real_t), intent(in) :: object
integer, intent(in), optional :: unit
integer :: u
u = given_output_unit (unit)
call object%base_write (unit)
write (u, "(1x,A)") "Range parameters:"
write (u, "(3x,A," // FMT_19 // ")") "r_beg = ", object%r_beg
write (u, "(3x,A," // FMT_19 // ")") "r_end = ", object%r_end
write (u, "(3x,A," // FMT_19 // ")") "r_step = ", object%r_end
write (u, "(3x,A,I0)") "n_step = ", object%n_step
end subroutine range_real_write
@ %def range_write
@ Initialize, given a range expression parse node. This is common to the
implementations.
<<Commands: range: TBP>>=
procedure :: init => range_init
<<Commands: procedures>>=
subroutine range_init (range, pn)
class(range_t), intent(out) :: range
type(parse_node_t), intent(in), target :: pn
type(parse_node_t), pointer :: pn_spec, pn_end, pn_step_spec, pn_op
select case (char (parse_node_get_rule_key (pn)))
case ("expr")
case ("range_expr")
range%pn_beg => parse_node_get_sub_ptr (pn)
pn_spec => parse_node_get_next_ptr (range%pn_beg)
if (associated (pn_spec)) then
pn_end => parse_node_get_sub_ptr (pn_spec, 2)
range%pn_end => pn_end
pn_step_spec => parse_node_get_next_ptr (pn_end)
if (associated (pn_step_spec)) then
pn_op => parse_node_get_sub_ptr (pn_step_spec)
range%pn_step => parse_node_get_next_ptr (pn_op)
select case (char (parse_node_get_rule_key (pn_op)))
case ("/+"); range%step_mode = STEP_ADD
case ("/-"); range%step_mode = STEP_SUB
case ("/*"); range%step_mode = STEP_MUL
case ("//"); range%step_mode = STEP_DIV
case ("/+/"); range%step_mode = STEP_COMP_ADD
case ("/*/"); range%step_mode = STEP_COMP_MUL
case default
call range%write ()
call msg_bug ("Range: step mode not implemented")
end select
else
range%step_mode = STEP_ADD
end if
else
range%step_mode = STEP_NONE
end if
call range%create_value_node ()
case default
call msg_bug ("range expression: node type '" &
// char (parse_node_get_rule_key (pn)) &
// "' not implemented")
end select
end subroutine range_init
@ %def range_init
@ This method manually creates a parse node (actually, a cascade of parse
nodes) that hold a constant value as a literal. The idea is that this node is
inserted as the right-hand side of a fake variable assignment, which is
prepended to each scan iteration. Before the variable
assignment is compiled and executed, we can manually reset the value of the
literal and thus pretend that the loop variable is assigned this value.
<<Commands: range: TBP>>=
procedure :: create_value_node => range_create_value_node
<<Commands: procedures>>=
subroutine range_create_value_node (range)
class(range_t), intent(inout) :: range
allocate (range%pn_literal)
allocate (range%pn_value)
select type (range)
type is (range_int_t)
call parse_node_create_value (range%pn_literal, &
syntax_get_rule_ptr (syntax_cmd_list, var_str ("integer_literal")),&
ival = 0)
call parse_node_create_branch (range%pn_value, &
syntax_get_rule_ptr (syntax_cmd_list, var_str ("integer_value")))
type is (range_real_t)
call parse_node_create_value (range%pn_literal, &
syntax_get_rule_ptr (syntax_cmd_list, var_str ("real_literal")),&
rval = 0._default)
call parse_node_create_branch (range%pn_value, &
syntax_get_rule_ptr (syntax_cmd_list, var_str ("real_value")))
class default
call msg_bug ("range: create value node: type not implemented")
end select
call parse_node_append_sub (range%pn_value, range%pn_literal)
call parse_node_freeze_branch (range%pn_value)
allocate (range%pn_factor)
call parse_node_create_branch (range%pn_factor, &
syntax_get_rule_ptr (syntax_cmd_list, var_str ("factor")))
call parse_node_append_sub (range%pn_factor, range%pn_value)
call parse_node_freeze_branch (range%pn_factor)
allocate (range%pn_term)
call parse_node_create_branch (range%pn_term, &
syntax_get_rule_ptr (syntax_cmd_list, var_str ("term")))
call parse_node_append_sub (range%pn_term, range%pn_factor)
call parse_node_freeze_branch (range%pn_term)
allocate (range%pn_expr)
call parse_node_create_branch (range%pn_expr, &
syntax_get_rule_ptr (syntax_cmd_list, var_str ("expr")))
call parse_node_append_sub (range%pn_expr, range%pn_term)
call parse_node_freeze_branch (range%pn_expr)
end subroutine range_create_value_node
@ %def range_create_value_node
@ Compile, given an environment.
<<Commands: range: TBP>>=
procedure :: compile => range_compile
<<Commands: procedures>>=
subroutine range_compile (range, global)
class(range_t), intent(inout) :: range
type(rt_data_t), intent(in), target :: global
type(var_list_t), pointer :: var_list
var_list => global%get_var_list_ptr ()
if (associated (range%pn_beg)) then
call range%expr_beg%init_expr (range%pn_beg, var_list)
if (associated (range%pn_end)) then
call range%expr_end%init_expr (range%pn_end, var_list)
if (associated (range%pn_step)) then
call range%expr_step%init_expr (range%pn_step, var_list)
end if
end if
end if
end subroutine range_compile
@ %def range_compile
@ Evaluate: compute the actual bounds and parameters that determine the values
that we can iterate.
This is implementation-specific.
<<Commands: range: TBP>>=
procedure (range_evaluate), deferred :: evaluate
<<Commands: interfaces>>=
abstract interface
subroutine range_evaluate (range)
import
class(range_t), intent(inout) :: range
end subroutine range_evaluate
end interface
@ %def range_evaluate
@ The version for an integer variable. If the step is subtractive, we invert
the sign and treat it as an additive step. For a multiplicative step, the
step must be greater than one, and the initial and final values must be of
same sign and strictly ordered. Analogously for a division step.
<<Commands: range int: TBP>>=
procedure :: evaluate => range_int_evaluate
<<Commands: procedures>>=
subroutine range_int_evaluate (range)
class(range_int_t), intent(inout) :: range
integer :: ival
if (associated (range%pn_beg)) then
call range%expr_beg%evaluate ()
if (range%expr_beg%is_known ()) then
range%i_beg = range%expr_beg%get_int ()
else
call range%write ()
call msg_fatal &
("Range expression: initial value evaluates to unknown")
end if
if (associated (range%pn_end)) then
call range%expr_end%evaluate ()
if (range%expr_end%is_known ()) then
range%i_end = range%expr_end%get_int ()
if (associated (range%pn_step)) then
call range%expr_step%evaluate ()
if (range%expr_step%is_known ()) then
range%i_step = range%expr_step%get_int ()
select case (range%step_mode)
case (STEP_SUB); range%i_step = - range%i_step
end select
else
call range%write ()
call msg_fatal &
("Range expression: step value evaluates to unknown")
end if
else
range%i_step = 1
end if
else
call range%write ()
call msg_fatal &
("Range expression: final value evaluates to unknown")
end if
else
range%i_end = range%i_beg
range%i_step = 1
end if
select case (range%step_mode)
case (STEP_NONE)
range%n_step = 1
case (STEP_ADD, STEP_SUB)
if (range%i_step /= 0) then
if (range%i_beg == range%i_end) then
range%n_step = 1
else if (sign (1, range%i_end - range%i_beg) &
== sign (1, range%i_step)) then
range%n_step = (range%i_end - range%i_beg) / range%i_step + 1
else
range%n_step = 0
end if
else
call msg_fatal ("range evaluation (add): step value is zero")
end if
case (STEP_MUL)
if (range%i_step > 1) then
if (range%i_beg == range%i_end) then
range%n_step = 1
else if (range%i_beg == 0) then
call msg_fatal ("range evaluation (mul): initial value is zero")
else if (sign (1, range%i_beg) == sign (1, range%i_end) &
.and. abs (range%i_beg) < abs (range%i_end)) then
range%n_step = 0
ival = range%i_beg
do while (abs (ival) <= abs (range%i_end))
range%n_step = range%n_step + 1
ival = ival * range%i_step
end do
else
range%n_step = 0
end if
else
call msg_fatal &
("range evaluation (mult): step value is one or less")
end if
case (STEP_DIV)
if (range%i_step > 1) then
if (range%i_beg == range%i_end) then
range%n_step = 1
else if (sign (1, range%i_beg) == sign (1, range%i_end) &
.and. abs (range%i_beg) > abs (range%i_end)) then
range%n_step = 0
ival = range%i_beg
do while (abs (ival) >= abs (range%i_end))
range%n_step = range%n_step + 1
if (ival == 0) exit
ival = ival / range%i_step
end do
else
range%n_step = 0
end if
else
call msg_fatal &
("range evaluation (div): step value is one or less")
end if
case (STEP_COMP_ADD)
call msg_fatal ("range evaluation: &
&step mode /+/ not allowed for integer variable")
case (STEP_COMP_MUL)
call msg_fatal ("range evaluation: &
&step mode /*/ not allowed for integer variable")
case default
call range%write ()
call msg_bug ("range evaluation: step mode not implemented")
end select
end if
end subroutine range_int_evaluate
@ %def range_int_evaluate
@ The version for a real variable.
<<Commands: range real: TBP>>=
procedure :: evaluate => range_real_evaluate
<<Commands: procedures>>=
subroutine range_real_evaluate (range)
class(range_real_t), intent(inout) :: range
if (associated (range%pn_beg)) then
call range%expr_beg%evaluate ()
if (range%expr_beg%is_known ()) then
range%r_beg = range%expr_beg%get_real ()
else
call range%write ()
call msg_fatal &
("Range expression: initial value evaluates to unknown")
end if
if (associated (range%pn_end)) then
call range%expr_end%evaluate ()
if (range%expr_end%is_known ()) then
range%r_end = range%expr_end%get_real ()
if (associated (range%pn_step)) then
if (range%expr_step%is_known ()) then
select case (range%step_mode)
case (STEP_ADD, STEP_SUB, STEP_MUL, STEP_DIV)
call range%expr_step%evaluate ()
range%r_step = range%expr_step%get_real ()
select case (range%step_mode)
case (STEP_SUB); range%r_step = - range%r_step
end select
case (STEP_COMP_ADD, STEP_COMP_MUL)
range%n_step = &
max (range%expr_step%get_int (), 0)
end select
else
call range%write ()
call msg_fatal &
("Range expression: step value evaluates to unknown")
end if
else
call range%write ()
call msg_fatal &
("Range expression (real): step value must be provided")
end if
else
call range%write ()
call msg_fatal &
("Range expression: final value evaluates to unknown")
end if
else
range%r_end = range%r_beg
range%r_step = 1
end if
select case (range%step_mode)
case (STEP_NONE)
range%n_step = 1
case (STEP_ADD, STEP_SUB)
if (range%r_step /= 0) then
if (sign (1._default, range%r_end - range%r_beg) &
== sign (1._default, range%r_step)) then
range%n_step = &
nint ((range%r_end - range%r_beg) / range%r_step + 1)
else
range%n_step = 0
end if
else
call msg_fatal ("range evaluation (add): step value is zero")
end if
case (STEP_MUL)
if (range%r_step > 1) then
if (range%r_beg == 0 .or. range%r_end == 0) then
call msg_fatal ("range evaluation (mul): bound is zero")
else if (sign (1._default, range%r_beg) &
== sign (1._default, range%r_end) &
.and. abs (range%r_beg) <= abs (range%r_end)) then
range%lr_beg = log (abs (range%r_beg))
range%lr_end = log (abs (range%r_end))
range%lr_step = log (range%r_step)
range%n_step = nint &
(abs ((range%lr_end - range%lr_beg) / range%lr_step) + 1)
else
range%n_step = 0
end if
else
call msg_fatal &
("range evaluation (mult): step value is one or less")
end if
case (STEP_DIV)
if (range%r_step > 1) then
if (range%r_beg == 0 .or. range%r_end == 0) then
call msg_fatal ("range evaluation (div): bound is zero")
else if (sign (1._default, range%r_beg) &
== sign (1._default, range%r_end) &
.and. abs (range%r_beg) >= abs (range%r_end)) then
range%lr_beg = log (abs (range%r_beg))
range%lr_end = log (abs (range%r_end))
range%lr_step = -log (range%r_step)
range%n_step = nint &
(abs ((range%lr_end - range%lr_beg) / range%lr_step) + 1)
else
range%n_step = 0
end if
else
call msg_fatal &
("range evaluation (mult): step value is one or less")
end if
case (STEP_COMP_ADD)
! Number of steps already known
case (STEP_COMP_MUL)
! Number of steps already known
if (range%r_beg == 0 .or. range%r_end == 0) then
call msg_fatal ("range evaluation (mul): bound is zero")
else if (sign (1._default, range%r_beg) &
== sign (1._default, range%r_end)) then
range%lr_beg = log (abs (range%r_beg))
range%lr_end = log (abs (range%r_end))
else
range%n_step = 0
end if
case default
call range%write ()
call msg_bug ("range evaluation: step mode not implemented")
end select
end if
end subroutine range_real_evaluate
@ %def range_real_evaluate
@ Return the number of iterations:
<<Commands: range: TBP>>=
procedure :: get_n_iterations => range_get_n_iterations
<<Commands: procedures>>=
function range_get_n_iterations (range) result (n)
class(range_t), intent(in) :: range
integer :: n
n = range%n_step
end function range_get_n_iterations
@ %def range_get_n_iterations
@ Compute the value for iteration [[i]] and store it in the embedded token.
<<Commands: range: TBP>>=
procedure (range_set_value), deferred :: set_value
<<Commands: interfaces>>=
abstract interface
subroutine range_set_value (range, i)
import
class(range_t), intent(inout) :: range
integer, intent(in) :: i
end subroutine range_set_value
end interface
@ %def range_set_value
@ In the integer case, we compute the value directly for additive step. For
multiplicative step, we perform a loop in the same way as above, where the
number of iteration was determined.
<<Commands: range int: TBP>>=
procedure :: set_value => range_int_set_value
<<Commands: procedures>>=
subroutine range_int_set_value (range, i)
class(range_int_t), intent(inout) :: range
integer, intent(in) :: i
integer :: k, ival
select case (range%step_mode)
case (STEP_NONE)
ival = range%i_beg
case (STEP_ADD, STEP_SUB)
ival = range%i_beg + (i - 1) * range%i_step
case (STEP_MUL)
ival = range%i_beg
do k = 1, i - 1
ival = ival * range%i_step
end do
case (STEP_DIV)
ival = range%i_beg
do k = 1, i - 1
ival = ival / range%i_step
end do
case default
call range%write ()
call msg_bug ("range iteration: step mode not implemented")
end select
call parse_node_set_value (range%pn_literal, ival = ival)
end subroutine range_int_set_value
@ %def range_int_set_value
@ In the integer case, we compute the value directly for additive step. For
multiplicative step, we perform a loop in the same way as above, where the
number of iteration was determined.
<<Commands: range real: TBP>>=
procedure :: set_value => range_real_set_value
<<Commands: procedures>>=
subroutine range_real_set_value (range, i)
class(range_real_t), intent(inout) :: range
integer, intent(in) :: i
real(default) :: rval, x
select case (range%step_mode)
case (STEP_NONE)
rval = range%r_beg
case (STEP_ADD, STEP_SUB, STEP_COMP_ADD)
if (range%n_step > 1) then
x = real (i - 1, default) / (range%n_step - 1)
else
x = 1._default / 2
end if
rval = x * range%r_end + (1 - x) * range%r_beg
case (STEP_MUL, STEP_DIV, STEP_COMP_MUL)
if (range%n_step > 1) then
x = real (i - 1, default) / (range%n_step - 1)
else
x = 1._default / 2
end if
rval = sign &
(exp (x * range%lr_end + (1 - x) * range%lr_beg), range%r_beg)
case default
call range%write ()
call msg_bug ("range iteration: step mode not implemented")
end select
call parse_node_set_value (range%pn_literal, rval = rval)
end subroutine range_real_set_value
@ %def range_real_set_value
@
\subsubsection{Scan over parameters and other objects}
The scan command allocates a new parse node for the variable
assignment (the lhs). The rhs of this parse node is assigned from the
available rhs expressions in the scan list, one at a time, so the
compiled parse node can be prepended to the scan body.
<<Commands: types>>=
type, extends (command_t) :: cmd_scan_t
private
type(string_t) :: name
integer :: n_values = 0
type(parse_node_p), dimension(:), allocatable :: scan_cmd
class(range_t), dimension(:), allocatable :: range
contains
<<Commands: cmd scan: TBP>>
end type cmd_scan_t
@ %def cmd_scan_t
@ Finalizer.
The auxiliary parse nodes that we have constructed have to be treated
carefully: the embedded pointers all point to persistent objects
somewhere else and should not be finalized, so we should not call the
finalizer recursively.
<<Commands: cmd scan: TBP>>=
procedure :: final => cmd_scan_final
<<Commands: procedures>>=
recursive subroutine cmd_scan_final (cmd)
class(cmd_scan_t), intent(inout) :: cmd
type(parse_node_t), pointer :: pn_var_single, pn_decl_single
type(string_t) :: key
integer :: i
if (allocated (cmd%scan_cmd)) then
do i = 1, size (cmd%scan_cmd)
pn_var_single => parse_node_get_sub_ptr (cmd%scan_cmd(i)%ptr)
key = parse_node_get_rule_key (pn_var_single)
select case (char (key))
case ("scan_string_decl", "scan_log_decl")
pn_decl_single => parse_node_get_sub_ptr (pn_var_single, 2)
call parse_node_final (pn_decl_single, recursive=.false.)
deallocate (pn_decl_single)
end select
call parse_node_final (pn_var_single, recursive=.false.)
deallocate (pn_var_single)
end do
deallocate (cmd%scan_cmd)
end if
if (allocated (cmd%range)) then
do i = 1, size (cmd%range)
call cmd%range(i)%final ()
end do
end if
end subroutine cmd_scan_final
@ %def cmd_scan_final
@ Output.
<<Commands: cmd scan: TBP>>=
procedure :: write => cmd_scan_write
<<Commands: procedures>>=
subroutine cmd_scan_write (cmd, unit, indent)
class(cmd_scan_t), intent(in) :: cmd
integer, intent(in), optional :: unit, indent
integer :: u
u = given_output_unit (unit); if (u < 0) return
call write_indent (u, indent)
write (u, "(1x,A,1x,A,1x,'(',I0,')')") "scan:", char (cmd%name), &
cmd%n_values
end subroutine cmd_scan_write
@ %def cmd_scan_write
@ Compile the scan command. We construct a new parse node that
implements the variable assignment for a single element on the rhs,
instead of the whole list that we get from the original parse tree.
By simply copying the node, we copy all pointers and inherit the
targets from the original. During execution, we should replace the
rhs by the stored rhs pointers (the list elements), one by one, then
(re)compile the redefined node.
<<Commands: cmd scan: TBP>>=
procedure :: compile => cmd_scan_compile
<<Commands: procedures>>=
recursive subroutine cmd_scan_compile (cmd, global)
class(cmd_scan_t), intent(inout) :: cmd
type(rt_data_t), intent(inout), target :: global
type(var_list_t), pointer :: var_list
type(parse_node_t), pointer :: pn_var, pn_body, pn_body_first
type(parse_node_t), pointer :: pn_decl, pn_name
type(parse_node_t), pointer :: pn_arg, pn_scan_cmd, pn_rhs
type(parse_node_t), pointer :: pn_decl_single, pn_var_single
type(syntax_rule_t), pointer :: var_rule_decl, var_rule
type(string_t) :: key
integer :: var_type
integer :: i
if (debug_on) call msg_debug (D_CORE, "cmd_scan_compile")
if (debug_active (D_CORE)) call parse_node_write_rec (cmd%pn)
pn_var => parse_node_get_sub_ptr (cmd%pn, 2)
pn_body => parse_node_get_next_ptr (pn_var)
if (associated (pn_body)) then
pn_body_first => parse_node_get_sub_ptr (pn_body)
else
pn_body_first => null ()
end if
key = parse_node_get_rule_key (pn_var)
select case (char (key))
case ("scan_num")
pn_name => parse_node_get_sub_ptr (pn_var)
cmd%name = parse_node_get_string (pn_name)
var_rule => syntax_get_rule_ptr (syntax_cmd_list, var_str ("cmd_num"))
pn_arg => parse_node_get_next_ptr (pn_name, 2)
case ("scan_int")
pn_name => parse_node_get_sub_ptr (pn_var, 2)
cmd%name = parse_node_get_string (pn_name)
var_rule => syntax_get_rule_ptr (syntax_cmd_list, var_str ("cmd_int"))
pn_arg => parse_node_get_next_ptr (pn_name, 2)
case ("scan_real")
pn_name => parse_node_get_sub_ptr (pn_var, 2)
cmd%name = parse_node_get_string (pn_name)
var_rule => syntax_get_rule_ptr (syntax_cmd_list, var_str ("cmd_real"))
pn_arg => parse_node_get_next_ptr (pn_name, 2)
case ("scan_complex")
pn_name => parse_node_get_sub_ptr (pn_var, 2)
cmd%name = parse_node_get_string (pn_name)
var_rule => syntax_get_rule_ptr (syntax_cmd_list, var_str("cmd_complex"))
pn_arg => parse_node_get_next_ptr (pn_name, 2)
case ("scan_alias")
pn_name => parse_node_get_sub_ptr (pn_var, 2)
cmd%name = parse_node_get_string (pn_name)
var_rule => syntax_get_rule_ptr (syntax_cmd_list, var_str ("cmd_alias"))
pn_arg => parse_node_get_next_ptr (pn_name, 2)
case ("scan_string_decl")
pn_decl => parse_node_get_sub_ptr (pn_var, 2)
pn_name => parse_node_get_sub_ptr (pn_decl, 2)
cmd%name = parse_node_get_string (pn_name)
var_rule_decl => syntax_get_rule_ptr (syntax_cmd_list, &
var_str ("cmd_string"))
var_rule => syntax_get_rule_ptr (syntax_cmd_list, &
var_str ("cmd_string_decl"))
pn_arg => parse_node_get_next_ptr (pn_name, 2)
case ("scan_log_decl")
pn_decl => parse_node_get_sub_ptr (pn_var, 2)
pn_name => parse_node_get_sub_ptr (pn_decl, 2)
cmd%name = parse_node_get_string (pn_name)
var_rule_decl => syntax_get_rule_ptr (syntax_cmd_list, &
var_str ("cmd_log"))
var_rule => syntax_get_rule_ptr (syntax_cmd_list, &
var_str ("cmd_log_decl"))
pn_arg => parse_node_get_next_ptr (pn_name, 2)
case ("scan_cuts")
var_rule => syntax_get_rule_ptr (syntax_cmd_list, &
var_str ("cmd_cuts"))
cmd%name = "cuts"
pn_arg => parse_node_get_sub_ptr (pn_var, 3)
case ("scan_weight")
var_rule => syntax_get_rule_ptr (syntax_cmd_list, &
var_str ("cmd_weight"))
cmd%name = "weight"
pn_arg => parse_node_get_sub_ptr (pn_var, 3)
case ("scan_scale")
var_rule => syntax_get_rule_ptr (syntax_cmd_list, &
var_str ("cmd_scale"))
cmd%name = "scale"
pn_arg => parse_node_get_sub_ptr (pn_var, 3)
case ("scan_ren_scale")
var_rule => syntax_get_rule_ptr (syntax_cmd_list, &
var_str ("cmd_ren_scale"))
cmd%name = "renormalization_scale"
pn_arg => parse_node_get_sub_ptr (pn_var, 3)
case ("scan_fac_scale")
var_rule => syntax_get_rule_ptr (syntax_cmd_list, &
var_str ("cmd_fac_scale"))
cmd%name = "factorization_scale"
pn_arg => parse_node_get_sub_ptr (pn_var, 3)
case ("scan_selection")
var_rule => syntax_get_rule_ptr (syntax_cmd_list, &
var_str ("cmd_selection"))
cmd%name = "selection"
pn_arg => parse_node_get_sub_ptr (pn_var, 3)
case ("scan_reweight")
var_rule => syntax_get_rule_ptr (syntax_cmd_list, &
var_str ("cmd_reweight"))
cmd%name = "reweight"
pn_arg => parse_node_get_sub_ptr (pn_var, 3)
case ("scan_analysis")
var_rule => syntax_get_rule_ptr (syntax_cmd_list, &
var_str ("cmd_analysis"))
cmd%name = "analysis"
pn_arg => parse_node_get_sub_ptr (pn_var, 3)
case ("scan_model")
var_rule => syntax_get_rule_ptr (syntax_cmd_list, &
var_str ("cmd_model"))
cmd%name = "model"
pn_arg => parse_node_get_sub_ptr (pn_var, 3)
case ("scan_library")
var_rule => syntax_get_rule_ptr (syntax_cmd_list, &
var_str ("cmd_library"))
cmd%name = "library"
pn_arg => parse_node_get_sub_ptr (pn_var, 3)
case default
call msg_bug ("scan: case '" // char (key) // "' not implemented")
end select
if (associated (pn_arg)) then
cmd%n_values = parse_node_get_n_sub (pn_arg)
end if
var_list => global%get_var_list_ptr ()
allocate (cmd%scan_cmd (cmd%n_values))
select case (char (key))
case ("scan_num")
var_type = &
var_list%get_type (cmd%name)
select case (var_type)
case (V_INT)
allocate (range_int_t :: cmd%range (cmd%n_values))
case (V_REAL)
allocate (range_real_t :: cmd%range (cmd%n_values))
case (V_CMPLX)
call msg_fatal ("scan over complex variable not implemented")
case (V_NONE)
call msg_fatal ("scan: variable '" // char (cmd%name) //"' undefined")
case default
call msg_bug ("scan: impossible variable type")
end select
case ("scan_int")
allocate (range_int_t :: cmd%range (cmd%n_values))
case ("scan_real")
allocate (range_real_t :: cmd%range (cmd%n_values))
case ("scan_complex")
call msg_fatal ("scan over complex variable not implemented")
end select
i = 1
if (associated (pn_arg)) then
pn_rhs => parse_node_get_sub_ptr (pn_arg)
else
pn_rhs => null ()
end if
do while (associated (pn_rhs))
allocate (pn_scan_cmd)
call parse_node_create_branch (pn_scan_cmd, &
syntax_get_rule_ptr (syntax_cmd_list, var_str ("command_list")))
allocate (pn_var_single)
pn_var_single = pn_var
call parse_node_replace_rule (pn_var_single, var_rule)
select case (char (key))
case ("scan_num", "scan_int", "scan_real", &
"scan_complex", "scan_alias", &
"scan_cuts", "scan_weight", &
"scan_scale", "scan_ren_scale", "scan_fac_scale", &
"scan_selection", "scan_reweight", "scan_analysis", &
"scan_model", "scan_library")
if (allocated (cmd%range)) then
call cmd%range(i)%init (pn_rhs)
call parse_node_replace_last_sub &
(pn_var_single, cmd%range(i)%pn_expr)
else
call parse_node_replace_last_sub (pn_var_single, pn_rhs)
end if
case ("scan_string_decl", "scan_log_decl")
allocate (pn_decl_single)
pn_decl_single = pn_decl
call parse_node_replace_rule (pn_decl_single, var_rule_decl)
call parse_node_replace_last_sub (pn_decl_single, pn_rhs)
call parse_node_freeze_branch (pn_decl_single)
call parse_node_replace_last_sub (pn_var_single, pn_decl_single)
case default
call msg_bug ("scan: case '" // char (key) &
// "' broken")
end select
call parse_node_freeze_branch (pn_var_single)
call parse_node_append_sub (pn_scan_cmd, pn_var_single)
call parse_node_append_sub (pn_scan_cmd, pn_body_first)
call parse_node_freeze_branch (pn_scan_cmd)
cmd%scan_cmd(i)%ptr => pn_scan_cmd
i = i + 1
pn_rhs => parse_node_get_next_ptr (pn_rhs)
end do
if (debug_active (D_CORE)) then
do i = 1, cmd%n_values
print *, "scan command ", i
call parse_node_write_rec (cmd%scan_cmd(i)%ptr)
if (allocated (cmd%range)) call cmd%range(i)%write ()
end do
print *, "original"
call parse_node_write_rec (cmd%pn)
end if
end subroutine cmd_scan_compile
@ %def cmd_scan_compile
@ Execute the loop for all values in the step list. We use the
parse trees with single variable assignment that we have stored, to
iteratively create a local environment, execute the stored commands, and
destroy it again. When we encounter a range object, we execute the commands
for each value that this object provides. Computing this value has the side
effect of modifying the rhs of the variable assignment that heads the local
command list, directly in the local parse tree.
<<Commands: cmd scan: TBP>>=
procedure :: execute => cmd_scan_execute
<<Commands: procedures>>=
recursive subroutine cmd_scan_execute (cmd, global)
class(cmd_scan_t), intent(inout) :: cmd
type(rt_data_t), intent(inout), target :: global
type(rt_data_t), allocatable :: local
integer :: i, j
do i = 1, cmd%n_values
if (allocated (cmd%range)) then
call cmd%range(i)%compile (global)
call cmd%range(i)%evaluate ()
do j = 1, cmd%range(i)%get_n_iterations ()
call cmd%range(i)%set_value (j)
allocate (local)
call build_alt_setup (local, global, cmd%scan_cmd(i)%ptr)
call local%local_final ()
deallocate (local)
end do
else
allocate (local)
call build_alt_setup (local, global, cmd%scan_cmd(i)%ptr)
call local%local_final ()
deallocate (local)
end if
end do
end subroutine cmd_scan_execute
@ %def cmd_scan_execute
@
\subsubsection{Conditionals}
Conditionals are implemented as a list that is compiled and evaluated
recursively; this allows for a straightforward representation of
[[else if]] constructs. A [[cmd_if_t]] object can hold either an
[[else_if]] clause which is another object of this type, or an
[[else_body]], but not both.
If- or else-bodies are no scoping units, so all data remain global and
no copy-in copy-out is needed.
<<Commands: types>>=
type, extends (command_t) :: cmd_if_t
private
type(parse_node_t), pointer :: pn_if_lexpr => null ()
type(command_list_t), pointer :: if_body => null ()
type(cmd_if_t), dimension(:), pointer :: elsif_cmd => null ()
type(command_list_t), pointer :: else_body => null ()
contains
<<Commands: cmd if: TBP>>
end type cmd_if_t
@ %def cmd_if_t
@ Finalizer. There are no local options, therefore we can simply override
the default finalizer.
<<Commands: cmd if: TBP>>=
procedure :: final => cmd_if_final
<<Commands: procedures>>=
recursive subroutine cmd_if_final (cmd)
class(cmd_if_t), intent(inout) :: cmd
integer :: i
if (associated (cmd%if_body)) then
call command_list_final (cmd%if_body)
deallocate (cmd%if_body)
end if
if (associated (cmd%elsif_cmd)) then
do i = 1, size (cmd%elsif_cmd)
call cmd_if_final (cmd%elsif_cmd(i))
end do
deallocate (cmd%elsif_cmd)
end if
if (associated (cmd%else_body)) then
call command_list_final (cmd%else_body)
deallocate (cmd%else_body)
end if
end subroutine cmd_if_final
@ %def cmd_if_final
@ Output. Recursively write the command lists.
<<Commands: cmd if: TBP>>=
procedure :: write => cmd_if_write
<<Commands: procedures>>=
subroutine cmd_if_write (cmd, unit, indent)
class(cmd_if_t), intent(in) :: cmd
integer, intent(in), optional :: unit, indent
integer :: u, ind, i
u = given_output_unit (unit); if (u < 0) return
ind = 0; if (present (indent)) ind = indent
call write_indent (u, indent)
write (u, "(A)") "if <expr> then"
if (associated (cmd%if_body)) then
call cmd%if_body%write (unit, ind + 1)
end if
if (associated (cmd%elsif_cmd)) then
do i = 1, size (cmd%elsif_cmd)
call write_indent (u, indent)
write (u, "(A)") "elsif <expr> then"
if (associated (cmd%elsif_cmd(i)%if_body)) then
call cmd%elsif_cmd(i)%if_body%write (unit, ind + 1)
end if
end do
end if
if (associated (cmd%else_body)) then
call write_indent (u, indent)
write (u, "(A)") "else"
call cmd%else_body%write (unit, ind + 1)
end if
end subroutine cmd_if_write
@ %def cmd_if_write
@ Compile the conditional.
<<Commands: cmd if: TBP>>=
procedure :: compile => cmd_if_compile
<<Commands: procedures>>=
recursive subroutine cmd_if_compile (cmd, global)
class(cmd_if_t), intent(inout) :: cmd
type(rt_data_t), intent(inout), target :: global
type(parse_node_t), pointer :: pn_lexpr, pn_body
type(parse_node_t), pointer :: pn_elsif_clauses, pn_cmd_elsif
type(parse_node_t), pointer :: pn_else_clause, pn_cmd_else
integer :: i, n_elsif
pn_lexpr => parse_node_get_sub_ptr (cmd%pn, 2)
cmd%pn_if_lexpr => pn_lexpr
pn_body => parse_node_get_next_ptr (pn_lexpr, 2)
select case (char (parse_node_get_rule_key (pn_body)))
case ("command_list")
allocate (cmd%if_body)
call cmd%if_body%compile (pn_body, global)
pn_elsif_clauses => parse_node_get_next_ptr (pn_body)
case default
pn_elsif_clauses => pn_body
end select
select case (char (parse_node_get_rule_key (pn_elsif_clauses)))
case ("elsif_clauses")
n_elsif = parse_node_get_n_sub (pn_elsif_clauses)
allocate (cmd%elsif_cmd (n_elsif))
pn_cmd_elsif => parse_node_get_sub_ptr (pn_elsif_clauses)
do i = 1, n_elsif
pn_lexpr => parse_node_get_sub_ptr (pn_cmd_elsif, 2)
cmd%elsif_cmd(i)%pn_if_lexpr => pn_lexpr
pn_body => parse_node_get_next_ptr (pn_lexpr, 2)
if (associated (pn_body)) then
allocate (cmd%elsif_cmd(i)%if_body)
call cmd%elsif_cmd(i)%if_body%compile (pn_body, global)
end if
pn_cmd_elsif => parse_node_get_next_ptr (pn_cmd_elsif)
end do
pn_else_clause => parse_node_get_next_ptr (pn_elsif_clauses)
case default
pn_else_clause => pn_elsif_clauses
end select
select case (char (parse_node_get_rule_key (pn_else_clause)))
case ("else_clause")
pn_cmd_else => parse_node_get_sub_ptr (pn_else_clause)
pn_body => parse_node_get_sub_ptr (pn_cmd_else, 2)
if (associated (pn_body)) then
allocate (cmd%else_body)
call cmd%else_body%compile (pn_body, global)
end if
end select
end subroutine cmd_if_compile
@ %def global
@ (Recursively) execute the condition. Context remains global in all cases.
<<Commands: cmd if: TBP>>=
procedure :: execute => cmd_if_execute
<<Commands: procedures>>=
recursive subroutine cmd_if_execute (cmd, global)
class(cmd_if_t), intent(inout) :: cmd
type(rt_data_t), intent(inout), target :: global
type(var_list_t), pointer :: var_list
logical :: lval, is_known
integer :: i
var_list => global%get_var_list_ptr ()
lval = eval_log (cmd%pn_if_lexpr, var_list, is_known=is_known)
if (is_known) then
if (lval) then
if (associated (cmd%if_body)) then
call cmd%if_body%execute (global)
end if
return
end if
else
call error_undecided ()
return
end if
if (associated (cmd%elsif_cmd)) then
SCAN_ELSIF: do i = 1, size (cmd%elsif_cmd)
lval = eval_log (cmd%elsif_cmd(i)%pn_if_lexpr, var_list, &
is_known=is_known)
if (is_known) then
if (lval) then
if (associated (cmd%elsif_cmd(i)%if_body)) then
call cmd%elsif_cmd(i)%if_body%execute (global)
end if
return
end if
else
call error_undecided ()
return
end if
end do SCAN_ELSIF
end if
if (associated (cmd%else_body)) then
call cmd%else_body%execute (global)
end if
contains
subroutine error_undecided ()
call msg_error ("Undefined result of cmditional expression: " &
// "neither branch will be executed")
end subroutine error_undecided
end subroutine cmd_if_execute
@ %def cmd_if_execute
@
\subsubsection{Include another command-list file}
The include command allocates a local parse tree. This must not be
deleted before the command object itself is deleted, since pointers
may point to subobjects of it.
<<Commands: types>>=
type, extends (command_t) :: cmd_include_t
private
type(string_t) :: file
type(command_list_t), pointer :: command_list => null ()
type(parse_tree_t) :: parse_tree
contains
<<Commands: cmd include: TBP>>
end type cmd_include_t
@ %def cmd_include_t
@ Finalizer: delete the command list. No options, so we can simply override
the default finalizer.
<<Commands: cmd include: TBP>>=
procedure :: final => cmd_include_final
<<Commands: procedures>>=
subroutine cmd_include_final (cmd)
class(cmd_include_t), intent(inout) :: cmd
call parse_tree_final (cmd%parse_tree)
if (associated (cmd%command_list)) then
call cmd%command_list%final ()
deallocate (cmd%command_list)
end if
end subroutine cmd_include_final
@ %def cmd_include_final
@ Write: display the command list as-is, if allocated.
<<Commands: cmd include: TBP>>=
procedure :: write => cmd_include_write
<<Commands: procedures>>=
subroutine cmd_include_write (cmd, unit, indent)
class(cmd_include_t), intent(in) :: cmd
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, indent)
write (u, "(A,A,A,A)") "include ", '"', char (cmd%file), '"'
if (associated (cmd%command_list)) then
call cmd%command_list%write (u, ind + 1)
end if
end subroutine cmd_include_write
@ %def cmd_include_write
@ Compile file contents: First parse the file, then immediately
compile its contents. Use the global data set.
<<Commands: cmd include: TBP>>=
procedure :: compile => cmd_include_compile
<<Commands: procedures>>=
subroutine cmd_include_compile (cmd, global)
class(cmd_include_t), intent(inout) :: cmd
type(rt_data_t), intent(inout), target :: global
type(parse_node_t), pointer :: pn_arg, pn_file
type(string_t) :: file
logical :: exist
integer :: u
type(stream_t), target :: stream
type(lexer_t) :: lexer
pn_arg => parse_node_get_sub_ptr (cmd%pn, 2)
pn_file => parse_node_get_sub_ptr (pn_arg)
file = parse_node_get_string (pn_file)
inquire (file=char(file), exist=exist)
if (exist) then
cmd%file = file
else
cmd%file = global%os_data%whizard_cutspath // "/" // file
inquire (file=char(cmd%file), exist=exist)
if (.not. exist) then
call msg_error ("Include file '" // char (file) // "' not found")
return
end if
end if
u = free_unit ()
call lexer_init_cmd_list (lexer, global%lexer)
call stream_init (stream, char (cmd%file))
call lexer_assign_stream (lexer, stream)
call parse_tree_init (cmd%parse_tree, syntax_cmd_list, lexer)
call stream_final (stream)
call lexer_final (lexer)
close (u)
allocate (cmd%command_list)
call cmd%command_list%compile (cmd%parse_tree%get_root_ptr (), &
global)
end subroutine cmd_include_compile
@ %def cmd_include_compile
@ Execute file contents in the global context.
<<Commands: cmd include: TBP>>=
procedure :: execute => cmd_include_execute
<<Commands: procedures>>=
subroutine cmd_include_execute (cmd, global)
class(cmd_include_t), intent(inout) :: cmd
type(rt_data_t), intent(inout), target :: global
if (associated (cmd%command_list)) then
call msg_message &
("Including Sindarin from '" // char (cmd%file) // "'")
call cmd%command_list%execute (global)
call msg_message &
("End of included '" // char (cmd%file) // "'")
end if
end subroutine cmd_include_execute
@ %def cmd_include_execute
@
\subsubsection{Export values}
This command exports the current values of variables or other objects to the
surrounding scope. By default, a scope enclosed by braces keeps all objects
local to it. The [[export]] command exports the values that are generated
within the scope to the corresponding object in the outer scope.
The allowed set of exportable objects is, in principle, the same as the set of
objects that the [[show]] command supports. This includes some convenience
abbreviations.
TODO: The initial implementation inherits syntax from [[show]], but supports
only the [[results]] pseudo-object. The results (i.e., the process stack) is
appended to the outer process stack instead of being discarded. The behavior
of the [[export]] command for other object kinds is to be defined on a
case-by-case basis. It may involve replacing the outer value or, instead,
doing some sort of appending or reduction.
<<Commands: types>>=
type, extends (command_t) :: cmd_export_t
private
type(string_t), dimension(:), allocatable :: name
contains
<<Commands: cmd export: TBP>>
end type cmd_export_t
@ %def cmd_export_t
@ Output: list the object names, not values.
<<Commands: cmd export: TBP>>=
procedure :: write => cmd_export_write
<<Commands: procedures>>=
subroutine cmd_export_write (cmd, unit, indent)
class(cmd_export_t), intent(in) :: cmd
integer, intent(in), optional :: unit, indent
integer :: u, i
u = given_output_unit (unit); if (u < 0) return
call write_indent (u, indent)
write (u, "(1x,A)", advance="no") "export: "
if (allocated (cmd%name)) then
do i = 1, size (cmd%name)
write (u, "(1x,A)", advance="no") char (cmd%name(i))
end do
write (u, *)
else
write (u, "(5x,A)") "[undefined]"
end if
end subroutine cmd_export_write
@ %def cmd_export_write
@ Compile. Allocate an array which is filled with the names of the
variables to export.
<<Commands: cmd export: TBP>>=
procedure :: compile => cmd_export_compile
<<Commands: procedures>>=
subroutine cmd_export_compile (cmd, global)
class(cmd_export_t), intent(inout) :: cmd
type(rt_data_t), intent(inout), target :: global
type(parse_node_t), pointer :: pn_arg, pn_var, pn_prefix, pn_name
type(string_t) :: key
integer :: i, n_args
pn_arg => parse_node_get_sub_ptr (cmd%pn, 2)
if (associated (pn_arg)) then
select case (char (parse_node_get_rule_key (pn_arg)))
case ("show_arg")
cmd%pn_opt => parse_node_get_next_ptr (pn_arg)
case default
cmd%pn_opt => pn_arg
pn_arg => null ()
end select
end if
call cmd%compile_options (global)
if (associated (pn_arg)) then
n_args = parse_node_get_n_sub (pn_arg)
allocate (cmd%name (n_args))
pn_var => parse_node_get_sub_ptr (pn_arg)
i = 0
do while (associated (pn_var))
i = i + 1
select case (char (parse_node_get_rule_key (pn_var)))
case ("model", "library", "beams", "iterations", &
"cuts", "weight", "int", "real", "complex", &
"scale", "factorization_scale", "renormalization_scale", &
"selection", "reweight", "analysis", "pdg", &
"stable", "unstable", "polarized", "unpolarized", &
"results", "expect", "intrinsic", "string", "logical")
cmd%name(i) = parse_node_get_key (pn_var)
case ("result_var")
pn_prefix => parse_node_get_sub_ptr (pn_var)
pn_name => parse_node_get_next_ptr (pn_prefix)
if (associated (pn_name)) then
cmd%name(i) = parse_node_get_key (pn_prefix) &
// "(" // parse_node_get_string (pn_name) // ")"
else
cmd%name(i) = parse_node_get_key (pn_prefix)
end if
case ("log_var", "string_var", "alias_var")
pn_prefix => parse_node_get_sub_ptr (pn_var)
pn_name => parse_node_get_next_ptr (pn_prefix)
key = parse_node_get_key (pn_prefix)
if (associated (pn_name)) then
select case (char (parse_node_get_rule_key (pn_name)))
case ("var_name")
select case (char (key))
case ("?", "$") ! $ sign
cmd%name(i) = key // parse_node_get_string (pn_name)
case ("alias")
cmd%name(i) = parse_node_get_string (pn_name)
end select
case default
call parse_node_mismatch &
("var_name", pn_name)
end select
else
cmd%name(i) = key
end if
case default
cmd%name(i) = parse_node_get_string (pn_var)
end select
!!! restriction imposed by current lack of implementation
select case (char (parse_node_get_rule_key (pn_var)))
case ("results")
case default
call msg_fatal ("export: object (type) '" &
// char (parse_node_get_rule_key (pn_var)) &
// "' not supported yet")
end select
pn_var => parse_node_get_next_ptr (pn_var)
end do
else
allocate (cmd%name (0))
end if
end subroutine cmd_export_compile
@ %def cmd_export_compile
@ Execute. Scan the list of objects to export.
<<Commands: cmd export: TBP>>=
procedure :: execute => cmd_export_execute
<<Commands: procedures>>=
subroutine cmd_export_execute (cmd, global)
class(cmd_export_t), intent(inout) :: cmd
type(rt_data_t), intent(inout), target :: global
call global%append_exports (cmd%name)
end subroutine cmd_export_execute
@ %def cmd_export_execute
@
\subsubsection{Quit command execution}
The code is the return code of the whole program if it is terminated
by this command.
<<Commands: types>>=
type, extends (command_t) :: cmd_quit_t
private
logical :: has_code = .false.
type(parse_node_t), pointer :: pn_code_expr => null ()
contains
<<Commands: cmd quit: TBP>>
end type cmd_quit_t
@ %def cmd_quit_t
@ Output.
<<Commands: cmd quit: TBP>>=
procedure :: write => cmd_quit_write
<<Commands: procedures>>=
subroutine cmd_quit_write (cmd, unit, indent)
class(cmd_quit_t), intent(in) :: cmd
integer, intent(in), optional :: unit, indent
integer :: u
u = given_output_unit (unit); if (u < 0) return
call write_indent (u, indent)
write (u, "(1x,A,L1)") "quit: has_code = ", cmd%has_code
end subroutine cmd_quit_write
@ %def cmd_quit_write
@ Compile: allocate a [[quit]] object which serves as a placeholder.
<<Commands: cmd quit: TBP>>=
procedure :: compile => cmd_quit_compile
<<Commands: procedures>>=
subroutine cmd_quit_compile (cmd, global)
class(cmd_quit_t), intent(inout) :: cmd
type(rt_data_t), intent(inout), target :: global
type(parse_node_t), pointer :: pn_arg
pn_arg => parse_node_get_sub_ptr (cmd%pn, 2)
if (associated (pn_arg)) then
cmd%pn_code_expr => parse_node_get_sub_ptr (pn_arg)
cmd%has_code = .true.
end if
end subroutine cmd_quit_compile
@ %def cmd_quit_compile
@ Execute: The quit command does not execute anything, it just stops
command execution. This is achieved by setting quit flag and quit
code in the global variable list. However, the return code, if
present, is an expression which has to be evaluated.
<<Commands: cmd quit: TBP>>=
procedure :: execute => cmd_quit_execute
<<Commands: procedures>>=
subroutine cmd_quit_execute (cmd, global)
class(cmd_quit_t), intent(inout) :: cmd
type(rt_data_t), intent(inout), target :: global
type(var_list_t), pointer :: var_list
logical :: is_known
var_list => global%get_var_list_ptr ()
if (cmd%has_code) then
global%quit_code = eval_int (cmd%pn_code_expr, var_list, &
is_known=is_known)
if (.not. is_known) then
call msg_error ("Undefined return code of quit/exit command")
end if
end if
global%quit = .true.
end subroutine cmd_quit_execute
@ %def cmd_quit_execute
@
\subsection{The command list}
The command list holds a list of commands and relevant global data.
<<Commands: public>>=
public :: command_list_t
<<Commands: types>>=
type :: command_list_t
! not private anymore as required by the whizard-c-interface
class(command_t), pointer :: first => null ()
class(command_t), pointer :: last => null ()
contains
<<Commands: command list: TBP>>
end type command_list_t
@ %def command_list_t
@ Output.
<<Commands: command list: TBP>>=
procedure :: write => command_list_write
<<Commands: procedures>>=
recursive subroutine command_list_write (cmd_list, unit, indent)
class(command_list_t), intent(in) :: cmd_list
integer, intent(in), optional :: unit, indent
class(command_t), pointer :: cmd
cmd => cmd_list%first
do while (associated (cmd))
call cmd%write (unit, indent)
cmd => cmd%next
end do
end subroutine command_list_write
@ %def command_list_write
@ Append a new command to the list and free the original pointer.
<<Commands: command list: TBP>>=
procedure :: append => command_list_append
<<Commands: procedures>>=
subroutine command_list_append (cmd_list, command)
class(command_list_t), intent(inout) :: cmd_list
class(command_t), intent(inout), pointer :: command
if (associated (cmd_list%last)) then
cmd_list%last%next => command
else
cmd_list%first => command
end if
cmd_list%last => command
command => null ()
end subroutine command_list_append
@ %def command_list_append
@ Finalize.
<<Commands: command list: TBP>>=
procedure :: final => command_list_final
<<Commands: procedures>>=
recursive subroutine command_list_final (cmd_list)
class(command_list_t), intent(inout) :: cmd_list
class(command_t), pointer :: command
do while (associated (cmd_list%first))
command => cmd_list%first
cmd_list%first => cmd_list%first%next
call command%final ()
deallocate (command)
end do
cmd_list%last => null ()
end subroutine command_list_final
@ %def command_list_final
@
\subsection{Compiling the parse tree}
Transform a parse tree into a command list. Initialization is assumed
to be done.
After each command, we set a breakpoint.
<<Commands: command list: TBP>>=
procedure :: compile => command_list_compile
<<Commands: procedures>>=
recursive subroutine command_list_compile (cmd_list, pn, global)
class(command_list_t), intent(inout), target :: cmd_list
type(parse_node_t), intent(in), target :: pn
type(rt_data_t), intent(inout), target :: global
type(parse_node_t), pointer :: pn_cmd
class(command_t), pointer :: command
integer :: i
pn_cmd => parse_node_get_sub_ptr (pn)
do i = 1, parse_node_get_n_sub (pn)
call dispatch_command (command, pn_cmd)
call command%compile (global)
call cmd_list%append (command)
call terminate_now_if_signal ()
pn_cmd => parse_node_get_next_ptr (pn_cmd)
end do
end subroutine command_list_compile
@ %def command_list_compile
@
\subsection{Executing the command list}
Before executing a command we should execute its options (if any). After
that, reset the options, i.e., remove temporary effects from the global
state.
Also here, after each command we set a breakpoint.
<<Commands: command list: TBP>>=
procedure :: execute => command_list_execute
<<Commands: procedures>>=
recursive subroutine command_list_execute (cmd_list, global)
class(command_list_t), intent(in) :: cmd_list
type(rt_data_t), intent(inout), target :: global
class(command_t), pointer :: command
command => cmd_list%first
COMMAND_COND: do while (associated (command))
call command%execute_options (global)
call command%execute (global)
call command%reset_options (global)
call terminate_now_if_signal ()
if (global%quit) exit COMMAND_COND
command => command%next
end do COMMAND_COND
end subroutine command_list_execute
@ %def command_list_execute
@
\subsection{Command list syntax}
<<Commands: public>>=
public :: syntax_cmd_list
<<Commands: variables>>=
type(syntax_t), target, save :: syntax_cmd_list
@ %def syntax_cmd_list
<<Commands: public>>=
public :: syntax_cmd_list_init
<<Commands: procedures>>=
subroutine syntax_cmd_list_init ()
type(ifile_t) :: ifile
call define_cmd_list_syntax (ifile)
call syntax_init (syntax_cmd_list, ifile)
call ifile_final (ifile)
end subroutine syntax_cmd_list_init
@ %def syntax_cmd_list_init
<<Commands: public>>=
public :: syntax_cmd_list_final
<<Commands: procedures>>=
subroutine syntax_cmd_list_final ()
call syntax_final (syntax_cmd_list)
end subroutine syntax_cmd_list_final
@ %def syntax_cmd_list_final
<<Commands: public>>=
public :: syntax_cmd_list_write
<<Commands: procedures>>=
subroutine syntax_cmd_list_write (unit)
integer, intent(in), optional :: unit
call syntax_write (syntax_cmd_list, unit)
end subroutine syntax_cmd_list_write
@ %def syntax_cmd_list_write
<<Commands: procedures>>=
subroutine define_cmd_list_syntax (ifile)
type(ifile_t), intent(inout) :: ifile
call ifile_append (ifile, "SEQ command_list = command*")
call ifile_append (ifile, "ALT command = " &
// "cmd_model | cmd_library | cmd_iterations | cmd_sample_format | " &
// "cmd_var | cmd_slha | " &
// "cmd_show | cmd_clear | " &
// "cmd_expect | " &
// "cmd_cuts | cmd_scale | cmd_fac_scale | cmd_ren_scale | " &
// "cmd_weight | cmd_selection | cmd_reweight | " &
// "cmd_beams | cmd_beams_pol_density | cmd_beams_pol_fraction | " &
// "cmd_beams_momentum | cmd_beams_theta | cmd_beams_phi | " &
// "cmd_integrate | " &
// "cmd_observable | cmd_histogram | cmd_plot | cmd_graph | " &
// "cmd_record | " &
// "cmd_analysis | cmd_alt_setup | " &
// "cmd_unstable | cmd_stable | cmd_simulate | cmd_rescan | " &
// "cmd_process | cmd_compile | cmd_exec | " &
// "cmd_scan | cmd_if | cmd_include | cmd_quit | " &
// "cmd_export | " &
// "cmd_polarized | cmd_unpolarized | " &
// "cmd_open_out | cmd_close_out | cmd_printf | " &
// "cmd_write_analysis | cmd_compile_analysis | cmd_nlo | cmd_components")
call ifile_append (ifile, "GRO options = '{' local_command_list '}'")
call ifile_append (ifile, "SEQ local_command_list = local_command*")
call ifile_append (ifile, "ALT local_command = " &
// "cmd_model | cmd_library | cmd_iterations | cmd_sample_format | " &
// "cmd_var | cmd_slha | " &
// "cmd_show | " &
// "cmd_expect | " &
// "cmd_cuts | cmd_scale | cmd_fac_scale | cmd_ren_scale | " &
// "cmd_weight | cmd_selection | cmd_reweight | " &
// "cmd_beams | cmd_beams_pol_density | cmd_beams_pol_fraction | " &
// "cmd_beams_momentum | cmd_beams_theta | cmd_beams_phi | " &
// "cmd_observable | cmd_histogram | cmd_plot | cmd_graph | " &
// "cmd_clear | cmd_record | " &
// "cmd_analysis | cmd_alt_setup | " &
// "cmd_open_out | cmd_close_out | cmd_printf | " &
// "cmd_write_analysis | cmd_compile_analysis | cmd_nlo | cmd_components")
call ifile_append (ifile, "SEQ cmd_model = model '=' model_name model_arg?")
call ifile_append (ifile, "KEY model")
call ifile_append (ifile, "ALT model_name = model_id | string_literal")
call ifile_append (ifile, "IDE model_id")
call ifile_append (ifile, "ARG model_arg = ( model_scheme? )")
call ifile_append (ifile, "ALT model_scheme = " &
// "ufo_spec | scheme_id | string_literal")
call ifile_append (ifile, "SEQ ufo_spec = ufo ufo_arg?")
call ifile_append (ifile, "KEY ufo")
call ifile_append (ifile, "ARG ufo_arg = ( string_literal )")
call ifile_append (ifile, "IDE scheme_id")
call ifile_append (ifile, "SEQ cmd_library = library '=' lib_name")
call ifile_append (ifile, "KEY library")
call ifile_append (ifile, "ALT lib_name = lib_id | string_literal")
call ifile_append (ifile, "IDE lib_id")
call ifile_append (ifile, "ALT cmd_var = " &
// "cmd_log_decl | cmd_log | " &
// "cmd_int | cmd_real | cmd_complex | cmd_num | " &
// "cmd_string_decl | cmd_string | cmd_alias | " &
// "cmd_result")
call ifile_append (ifile, "SEQ cmd_log_decl = logical cmd_log")
call ifile_append (ifile, "SEQ cmd_log = '?' var_name '=' lexpr")
call ifile_append (ifile, "SEQ cmd_int = int var_name '=' expr")
call ifile_append (ifile, "SEQ cmd_real = real var_name '=' expr")
call ifile_append (ifile, "SEQ cmd_complex = complex var_name '=' expr")
call ifile_append (ifile, "SEQ cmd_num = var_name '=' expr")
call ifile_append (ifile, "SEQ cmd_string_decl = string cmd_string")
call ifile_append (ifile, "SEQ cmd_string = " &
// "'$' var_name '=' sexpr") ! $
call ifile_append (ifile, "SEQ cmd_alias = alias var_name '=' cexpr")
call ifile_append (ifile, "SEQ cmd_result = result '=' expr")
call ifile_append (ifile, "SEQ cmd_slha = slha_action slha_arg options?")
call ifile_append (ifile, "ALT slha_action = " &
// "read_slha | write_slha")
call ifile_append (ifile, "KEY read_slha")
call ifile_append (ifile, "KEY write_slha")
call ifile_append (ifile, "ARG slha_arg = ( string_literal )")
call ifile_append (ifile, "SEQ cmd_show = show show_arg options?")
call ifile_append (ifile, "KEY show")
call ifile_append (ifile, "ARG show_arg = ( showable* )")
call ifile_append (ifile, "ALT showable = " &
// "model | library | beams | iterations | " &
// "cuts | weight | logical | string | pdg | " &
// "scale | factorization_scale | renormalization_scale | " &
// "selection | reweight | analysis | " &
// "stable | unstable | polarized | unpolarized | " &
// "expect | intrinsic | int | real | complex | " &
// "alias_var | string | results | result_var | " &
// "log_var | string_var | var_name")
call ifile_append (ifile, "KEY results")
call ifile_append (ifile, "KEY intrinsic")
call ifile_append (ifile, "SEQ alias_var = alias var_name")
call ifile_append (ifile, "SEQ result_var = result_key result_arg?")
call ifile_append (ifile, "SEQ log_var = '?' var_name")
call ifile_append (ifile, "SEQ string_var = '$' var_name") ! $
call ifile_append (ifile, "SEQ cmd_clear = clear clear_arg options?")
call ifile_append (ifile, "KEY clear")
call ifile_append (ifile, "ARG clear_arg = ( clearable* )")
call ifile_append (ifile, "ALT clearable = " &
// "beams | iterations | " &
// "cuts | weight | " &
// "scale | factorization_scale | renormalization_scale | " &
// "selection | reweight | analysis | " &
// "unstable | polarized | " &
// "expect | " &
// "log_var | string_var | var_name")
call ifile_append (ifile, "SEQ cmd_expect = expect expect_arg options?")
call ifile_append (ifile, "KEY expect")
call ifile_append (ifile, "ARG expect_arg = ( lexpr )")
call ifile_append (ifile, "SEQ cmd_cuts = cuts '=' lexpr")
call ifile_append (ifile, "SEQ cmd_scale = scale '=' expr")
call ifile_append (ifile, "SEQ cmd_fac_scale = " &
// "factorization_scale '=' expr")
call ifile_append (ifile, "SEQ cmd_ren_scale = " &
// "renormalization_scale '=' expr")
call ifile_append (ifile, "SEQ cmd_weight = weight '=' expr")
call ifile_append (ifile, "SEQ cmd_selection = selection '=' lexpr")
call ifile_append (ifile, "SEQ cmd_reweight = reweight '=' expr")
call ifile_append (ifile, "KEY cuts")
call ifile_append (ifile, "KEY scale")
call ifile_append (ifile, "KEY factorization_scale")
call ifile_append (ifile, "KEY renormalization_scale")
call ifile_append (ifile, "KEY weight")
call ifile_append (ifile, "KEY selection")
call ifile_append (ifile, "KEY reweight")
call ifile_append (ifile, "SEQ cmd_process = process process_id '=' " &
// "process_prt '=>' prt_state_list options?")
call ifile_append (ifile, "KEY process")
call ifile_append (ifile, "KEY '=>'")
call ifile_append (ifile, "LIS process_prt = cexpr+")
call ifile_append (ifile, "LIS prt_state_list = prt_state_sum+")
call ifile_append (ifile, "SEQ prt_state_sum = " &
// "prt_state prt_state_addition*")
call ifile_append (ifile, "SEQ prt_state_addition = '+' prt_state")
call ifile_append (ifile, "ALT prt_state = grouped_prt_state_list | cexpr")
call ifile_append (ifile, "GRO grouped_prt_state_list = " &
// "( prt_state_list )")
call ifile_append (ifile, "SEQ cmd_compile = compile_cmd options?")
call ifile_append (ifile, "SEQ compile_cmd = compile_clause compile_arg?")
call ifile_append (ifile, "SEQ compile_clause = compile exec_name_spec?")
call ifile_append (ifile, "KEY compile")
call ifile_append (ifile, "SEQ exec_name_spec = as exec_name")
call ifile_append (ifile, "KEY as")
call ifile_append (ifile, "ALT exec_name = exec_id | string_literal")
call ifile_append (ifile, "IDE exec_id")
call ifile_append (ifile, "ARG compile_arg = ( lib_name* )")
call ifile_append (ifile, "SEQ cmd_exec = exec exec_arg")
call ifile_append (ifile, "KEY exec")
call ifile_append (ifile, "ARG exec_arg = ( sexpr )")
call ifile_append (ifile, "SEQ cmd_beams = beams '=' beam_def")
call ifile_append (ifile, "KEY beams")
call ifile_append (ifile, "SEQ beam_def = beam_spec strfun_seq*")
call ifile_append (ifile, "SEQ beam_spec = beam_list")
call ifile_append (ifile, "LIS beam_list = cexpr, cexpr?")
call ifile_append (ifile, "SEQ cmd_beams_pol_density = " &
// "beams_pol_density '=' beams_pol_spec")
call ifile_append (ifile, "KEY beams_pol_density")
call ifile_append (ifile, "LIS beams_pol_spec = smatrix, smatrix?")
call ifile_append (ifile, "SEQ smatrix = '@' smatrix_arg")
! call ifile_append (ifile, "KEY '@'") !!! Key already exists
call ifile_append (ifile, "ARG smatrix_arg = ( sentry* )")
call ifile_append (ifile, "SEQ sentry = expr extra_sentry*")
call ifile_append (ifile, "SEQ extra_sentry = ':' expr")
call ifile_append (ifile, "SEQ cmd_beams_pol_fraction = " &
// "beams_pol_fraction '=' beams_par_spec")
call ifile_append (ifile, "KEY beams_pol_fraction")
call ifile_append (ifile, "SEQ cmd_beams_momentum = " &
// "beams_momentum '=' beams_par_spec")
call ifile_append (ifile, "KEY beams_momentum")
call ifile_append (ifile, "SEQ cmd_beams_theta = " &
// "beams_theta '=' beams_par_spec")
call ifile_append (ifile, "KEY beams_theta")
call ifile_append (ifile, "SEQ cmd_beams_phi = " &
// "beams_phi '=' beams_par_spec")
call ifile_append (ifile, "KEY beams_phi")
call ifile_append (ifile, "LIS beams_par_spec = expr, expr?")
call ifile_append (ifile, "SEQ strfun_seq = '=>' strfun_pair")
call ifile_append (ifile, "LIS strfun_pair = strfun_def, strfun_def?")
call ifile_append (ifile, "SEQ strfun_def = strfun_id")
call ifile_append (ifile, "ALT strfun_id = " &
// "none | lhapdf | lhapdf_photon | pdf_builtin | pdf_builtin_photon | " &
// "isr | epa | ewa | circe1 | circe2 | energy_scan | " &
// "gaussian | beam_events")
call ifile_append (ifile, "KEY none")
call ifile_append (ifile, "KEY lhapdf")
call ifile_append (ifile, "KEY lhapdf_photon")
call ifile_append (ifile, "KEY pdf_builtin")
call ifile_append (ifile, "KEY pdf_builtin_photon")
call ifile_append (ifile, "KEY isr")
call ifile_append (ifile, "KEY epa")
call ifile_append (ifile, "KEY ewa")
call ifile_append (ifile, "KEY circe1")
call ifile_append (ifile, "KEY circe2")
call ifile_append (ifile, "KEY energy_scan")
call ifile_append (ifile, "KEY gaussian")
call ifile_append (ifile, "KEY beam_events")
call ifile_append (ifile, "SEQ cmd_integrate = " &
// "integrate proc_arg options?")
call ifile_append (ifile, "KEY integrate")
call ifile_append (ifile, "ARG proc_arg = ( proc_id* )")
call ifile_append (ifile, "IDE proc_id")
call ifile_append (ifile, "SEQ cmd_iterations = " &
// "iterations '=' iterations_list")
call ifile_append (ifile, "KEY iterations")
call ifile_append (ifile, "LIS iterations_list = iterations_spec+")
call ifile_append (ifile, "ALT iterations_spec = it_spec")
call ifile_append (ifile, "SEQ it_spec = expr calls_spec adapt_spec?")
call ifile_append (ifile, "SEQ calls_spec = ':' expr")
call ifile_append (ifile, "SEQ adapt_spec = ':' sexpr")
call ifile_append (ifile, "SEQ cmd_components = " &
// "active '=' component_list")
call ifile_append (ifile, "KEY active")
call ifile_append (ifile, "LIS component_list = sexpr+")
call ifile_append (ifile, "SEQ cmd_sample_format = " &
// "sample_format '=' event_format_list")
call ifile_append (ifile, "KEY sample_format")
call ifile_append (ifile, "LIS event_format_list = event_format+")
call ifile_append (ifile, "IDE event_format")
call ifile_append (ifile, "SEQ cmd_observable = " &
// "observable analysis_tag options?")
call ifile_append (ifile, "KEY observable")
call ifile_append (ifile, "SEQ cmd_histogram = " &
// "histogram analysis_tag histogram_arg " &
// "options?")
call ifile_append (ifile, "KEY histogram")
call ifile_append (ifile, "ARG histogram_arg = (expr, expr, expr?)")
call ifile_append (ifile, "SEQ cmd_plot = plot analysis_tag options?")
call ifile_append (ifile, "KEY plot")
call ifile_append (ifile, "SEQ cmd_graph = graph graph_term '=' graph_def")
call ifile_append (ifile, "KEY graph")
call ifile_append (ifile, "SEQ graph_term = analysis_tag options?")
call ifile_append (ifile, "SEQ graph_def = graph_term graph_append*")
call ifile_append (ifile, "SEQ graph_append = '&' graph_term")
call ifile_append (ifile, "SEQ cmd_analysis = analysis '=' lexpr")
call ifile_append (ifile, "KEY analysis")
call ifile_append (ifile, "SEQ cmd_alt_setup = " &
// "alt_setup '=' option_list_expr")
call ifile_append (ifile, "KEY alt_setup")
call ifile_append (ifile, "ALT option_list_expr = " &
// "grouped_option_list | option_list")
call ifile_append (ifile, "GRO grouped_option_list = ( option_list_expr )")
call ifile_append (ifile, "LIS option_list = options+")
call ifile_append (ifile, "SEQ cmd_open_out = open_out open_arg options?")
call ifile_append (ifile, "SEQ cmd_close_out = close_out open_arg options?")
call ifile_append (ifile, "KEY open_out")
call ifile_append (ifile, "KEY close_out")
call ifile_append (ifile, "ARG open_arg = (sexpr)")
call ifile_append (ifile, "SEQ cmd_printf = printf_cmd options?")
call ifile_append (ifile, "SEQ printf_cmd = printf_clause sprintf_args?")
call ifile_append (ifile, "SEQ printf_clause = printf sexpr")
call ifile_append (ifile, "KEY printf")
call ifile_append (ifile, "SEQ cmd_record = record_cmd")
call ifile_append (ifile, "SEQ cmd_unstable = " &
// "unstable cexpr unstable_arg options?")
call ifile_append (ifile, "KEY unstable")
call ifile_append (ifile, "ARG unstable_arg = ( proc_id* )")
call ifile_append (ifile, "SEQ cmd_stable = stable stable_list options?")
call ifile_append (ifile, "KEY stable")
call ifile_append (ifile, "LIS stable_list = cexpr+")
call ifile_append (ifile, "KEY polarized")
call ifile_append (ifile, "SEQ cmd_polarized = polarized polarized_list options?")
call ifile_append (ifile, "LIS polarized_list = cexpr+")
call ifile_append (ifile, "KEY unpolarized")
call ifile_append (ifile, "SEQ cmd_unpolarized = unpolarized unpolarized_list options?")
call ifile_append (ifile, "LIS unpolarized_list = cexpr+")
call ifile_append (ifile, "SEQ cmd_simulate = " &
// "simulate proc_arg options?")
call ifile_append (ifile, "KEY simulate")
call ifile_append (ifile, "SEQ cmd_rescan = " &
// "rescan sexpr proc_arg options?")
call ifile_append (ifile, "KEY rescan")
call ifile_append (ifile, "SEQ cmd_scan = scan scan_var scan_body?")
call ifile_append (ifile, "KEY scan")
call ifile_append (ifile, "ALT scan_var = " &
// "scan_log_decl | scan_log | " &
// "scan_int | scan_real | scan_complex | scan_num | " &
// "scan_string_decl | scan_string | scan_alias | " &
// "scan_cuts | scan_weight | " &
// "scan_scale | scan_ren_scale | scan_fac_scale | " &
// "scan_selection | scan_reweight | scan_analysis | " &
// "scan_model | scan_library")
call ifile_append (ifile, "SEQ scan_log_decl = logical scan_log")
call ifile_append (ifile, "SEQ scan_log = '?' var_name '=' scan_log_arg")
call ifile_append (ifile, "ARG scan_log_arg = ( lexpr* )")
call ifile_append (ifile, "SEQ scan_int = int var_name '=' scan_num_arg")
call ifile_append (ifile, "SEQ scan_real = real var_name '=' scan_num_arg")
call ifile_append (ifile, "SEQ scan_complex = " &
// "complex var_name '=' scan_num_arg")
call ifile_append (ifile, "SEQ scan_num = var_name '=' scan_num_arg")
call ifile_append (ifile, "ARG scan_num_arg = ( range* )")
call ifile_append (ifile, "ALT range = grouped_range | range_expr")
call ifile_append (ifile, "GRO grouped_range = ( range_expr )")
call ifile_append (ifile, "SEQ range_expr = expr range_spec?")
call ifile_append (ifile, "SEQ range_spec = '=>' expr step_spec?")
call ifile_append (ifile, "SEQ step_spec = step_op expr")
call ifile_append (ifile, "ALT step_op = " &
// "'/+' | '/-' | '/*' | '//' | '/+/' | '/*/'")
call ifile_append (ifile, "KEY '/+'")
call ifile_append (ifile, "KEY '/-'")
call ifile_append (ifile, "KEY '/*'")
call ifile_append (ifile, "KEY '//'")
call ifile_append (ifile, "KEY '/+/'")
call ifile_append (ifile, "KEY '/*/'")
call ifile_append (ifile, "SEQ scan_string_decl = string scan_string")
call ifile_append (ifile, "SEQ scan_string = " &
// "'$' var_name '=' scan_string_arg")
call ifile_append (ifile, "ARG scan_string_arg = ( sexpr* )")
call ifile_append (ifile, "SEQ scan_alias = " &
// "alias var_name '=' scan_alias_arg")
call ifile_append (ifile, "ARG scan_alias_arg = ( cexpr* )")
call ifile_append (ifile, "SEQ scan_cuts = cuts '=' scan_lexpr_arg")
call ifile_append (ifile, "ARG scan_lexpr_arg = ( lexpr* )")
call ifile_append (ifile, "SEQ scan_scale = scale '=' scan_expr_arg")
call ifile_append (ifile, "ARG scan_expr_arg = ( expr* )")
call ifile_append (ifile, "SEQ scan_fac_scale = " &
// "factorization_scale '=' scan_expr_arg")
call ifile_append (ifile, "SEQ scan_ren_scale = " &
// "renormalization_scale '=' scan_expr_arg")
call ifile_append (ifile, "SEQ scan_weight = weight '=' scan_expr_arg")
call ifile_append (ifile, "SEQ scan_selection = selection '=' scan_lexpr_arg")
call ifile_append (ifile, "SEQ scan_reweight = reweight '=' scan_expr_arg")
call ifile_append (ifile, "SEQ scan_analysis = analysis '=' scan_lexpr_arg")
call ifile_append (ifile, "SEQ scan_model = model '=' scan_model_arg")
call ifile_append (ifile, "ARG scan_model_arg = ( model_name* )")
call ifile_append (ifile, "SEQ scan_library = library '=' scan_library_arg")
call ifile_append (ifile, "ARG scan_library_arg = ( lib_name* )")
call ifile_append (ifile, "GRO scan_body = '{' command_list '}'")
call ifile_append (ifile, "SEQ cmd_if = " &
// "if lexpr then command_list elsif_clauses else_clause endif")
call ifile_append (ifile, "SEQ elsif_clauses = cmd_elsif*")
call ifile_append (ifile, "SEQ cmd_elsif = elsif lexpr then command_list")
call ifile_append (ifile, "SEQ else_clause = cmd_else?")
call ifile_append (ifile, "SEQ cmd_else = else command_list")
call ifile_append (ifile, "SEQ cmd_include = include include_arg")
call ifile_append (ifile, "KEY include")
call ifile_append (ifile, "ARG include_arg = ( string_literal )")
call ifile_append (ifile, "SEQ cmd_quit = quit_cmd quit_arg?")
call ifile_append (ifile, "ALT quit_cmd = quit | exit")
call ifile_append (ifile, "KEY quit")
call ifile_append (ifile, "KEY exit")
call ifile_append (ifile, "ARG quit_arg = ( expr )")
call ifile_append (ifile, "SEQ cmd_export = export show_arg options?")
call ifile_append (ifile, "KEY export")
call ifile_append (ifile, "SEQ cmd_write_analysis = " &
// "write_analysis_clause options?")
call ifile_append (ifile, "SEQ cmd_compile_analysis = " &
// "compile_analysis_clause options?")
call ifile_append (ifile, "SEQ write_analysis_clause = " &
// "write_analysis write_analysis_arg?")
call ifile_append (ifile, "SEQ compile_analysis_clause = " &
// "compile_analysis write_analysis_arg?")
call ifile_append (ifile, "KEY write_analysis")
call ifile_append (ifile, "KEY compile_analysis")
call ifile_append (ifile, "ARG write_analysis_arg = ( analysis_tag* )")
call ifile_append (ifile, "SEQ cmd_nlo = " &
// "nlo_calculation '=' nlo_calculation_list")
call ifile_append (ifile, "KEY nlo_calculation")
call ifile_append (ifile, "LIS nlo_calculation_list = nlo_comp+")
call ifile_append (ifile, "ALT nlo_comp = " // &
"full | born | real | virtual | dglap | subtraction | " // &
"mismatch | GKS")
call ifile_append (ifile, "KEY full")
call ifile_append (ifile, "KEY born")
call ifile_append (ifile, "KEY virtual")
call ifile_append (ifile, "KEY dglap")
call ifile_append (ifile, "KEY subtraction")
call ifile_append (ifile, "KEY mismatch")
call ifile_append (ifile, "KEY GKS")
call define_expr_syntax (ifile, particles=.true., analysis=.true.)
end subroutine define_cmd_list_syntax
@ %def define_cmd_list_syntax
<<Commands: public>>=
public :: lexer_init_cmd_list
<<Commands: procedures>>=
subroutine lexer_init_cmd_list (lexer, parent_lexer)
type(lexer_t), intent(out) :: lexer
type(lexer_t), intent(in), optional, target :: parent_lexer
call lexer_init (lexer, &
comment_chars = "#!", &
quote_chars = '"', &
quote_match = '"', &
single_chars = "()[]{},;:&%?$@", &
special_class = [ "+-*/^", "<>=~ " ] , &
keyword_list = syntax_get_keyword_list_ptr (syntax_cmd_list), &
parent = parent_lexer)
end subroutine lexer_init_cmd_list
@ %def lexer_init_cmd_list
@
\subsection{Unit Tests}
Test module, followed by the corresponding implementation module.
<<[[commands_ut.f90]]>>=
<<File header>>
module commands_ut
use unit_tests
use system_dependencies, only: MPOST_AVAILABLE
use commands_uti
<<Standard module head>>
<<Commands: public test>>
contains
<<Commands: test driver>>
end module commands_ut
@ %def commands_ut
@
<<[[commands_uti.f90]]>>=
<<File header>>
module commands_uti
<<Use kinds>>
use kinds, only: i64
<<Use strings>>
use io_units
use ifiles
use parser
use interactions, only: reset_interaction_counter
use prclib_stacks
use analysis
use variables, only: var_list_t
use models
use slha_interface
use rt_data
use event_base, only: generic_event_t, event_callback_t
use commands
<<Standard module head>>
<<Commands: test declarations>>
<<Commands: test auxiliary types>>
contains
<<Commands: tests>>
<<Commands: test auxiliary>>
end module commands_uti
@ %def commands_uti
@ API: driver for the unit tests below.
<<Commands: public test>>=
public :: commands_test
<<Commands: test driver>>=
subroutine commands_test (u, results)
integer, intent(in) :: u
type(test_results_t), intent(inout) :: results
<<Commands: execute tests>>
end subroutine commands_test
@ %def commands_test
@
\subsubsection{Prepare Sindarin code}
This routine parses an internal file, prints the parse tree, and
returns a parse node to the root. We use the routine in the tests
below.
<<Commands: public test auxiliary>>=
public :: parse_ifile
<<Commands: test auxiliary>>=
subroutine parse_ifile (ifile, pn_root, u)
use ifiles
use lexers
use parser
use commands
type(ifile_t), intent(in) :: ifile
type(parse_node_t), pointer, intent(out) :: pn_root
integer, intent(in), optional :: u
type(stream_t), target :: stream
type(lexer_t), target :: lexer
type(parse_tree_t) :: parse_tree
call lexer_init_cmd_list (lexer)
call stream_init (stream, ifile)
call lexer_assign_stream (lexer, stream)
call parse_tree_init (parse_tree, syntax_cmd_list, lexer)
if (present (u)) call parse_tree_write (parse_tree, u)
pn_root => parse_tree%get_root_ptr ()
call stream_final (stream)
call lexer_final (lexer)
end subroutine parse_ifile
@ %def parse_ifile
@
\subsubsection{Empty command list}
Compile and execute an empty command list. Should do nothing but
test the integrity of the workflow.
<<Commands: execute tests>>=
call test (commands_1, "commands_1", &
"empty command list", &
u, results)
<<Commands: test declarations>>=
public :: commands_1
<<Commands: tests>>=
subroutine commands_1 (u)
integer, intent(in) :: u
type(ifile_t) :: ifile
type(command_list_t), target :: command_list
type(rt_data_t), target :: global
type(parse_node_t), pointer :: pn_root
write (u, "(A)") "* Test output: commands_1"
write (u, "(A)") "* Purpose: compile and execute empty command list"
write (u, "(A)")
write (u, "(A)") "* Initialization"
write (u, "(A)")
call syntax_cmd_list_init ()
call global%global_init ()
write (u, "(A)") "* Parse empty file"
write (u, "(A)")
call parse_ifile (ifile, pn_root, u)
write (u, "(A)")
write (u, "(A)") "* Compile command list"
if (associated (pn_root)) then
call command_list%compile (pn_root, global)
end if
write (u, "(A)")
write (u, "(A)") "* Execute command list"
call global%activate ()
call command_list%execute (global)
call global%deactivate ()
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call ifile_final (ifile)
call command_list%final ()
call syntax_cmd_list_final ()
call global%final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: commands_1"
end subroutine commands_1
@ %def commands_1
@
\subsubsection{Read model}
Execute a [[model]] assignment.
<<Commands: execute tests>>=
call test (commands_2, "commands_2", &
"model", &
u, results)
<<Commands: test declarations>>=
public :: commands_2
<<Commands: tests>>=
subroutine commands_2 (u)
integer, intent(in) :: u
type(ifile_t) :: ifile
type(command_list_t), target :: command_list
type(rt_data_t), target :: global
type(parse_node_t), pointer :: pn_root
write (u, "(A)") "* Test output: commands_2"
write (u, "(A)") "* Purpose: set model"
write (u, "(A)")
write (u, "(A)") "* Initialization"
write (u, "(A)")
call syntax_cmd_list_init ()
call syntax_model_file_init ()
call global%global_init ()
write (u, "(A)") "* Input file"
write (u, "(A)")
call ifile_append (ifile, 'model = "Test"')
call ifile_write (ifile, u)
write (u, "(A)") "* Parse file"
write (u, "(A)")
call parse_ifile (ifile, pn_root, u)
write (u, "(A)")
write (u, "(A)") "* Compile command list"
write (u, "(A)")
call command_list%compile (pn_root, global)
call command_list%write (u)
write (u, "(A)")
write (u, "(A)") "* Execute command list"
write (u, "(A)")
call command_list%execute (global)
write (u, "(A)") "* Cleanup"
call ifile_final (ifile)
call command_list%final ()
call global%final ()
call syntax_cmd_list_final ()
call syntax_model_file_final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: commands_2"
end subroutine commands_2
@ %def commands_2
@
\subsubsection{Declare Process}
Read a model, then declare a process. The process library is allocated
explicitly. For the process definition, We take the default ([[omega]])
method. Since we do not compile, \oMega\ is not actually called.
<<Commands: execute tests>>=
call test (commands_3, "commands_3", &
"process declaration", &
u, results)
<<Commands: test declarations>>=
public :: commands_3
<<Commands: tests>>=
subroutine commands_3 (u)
integer, intent(in) :: u
type(ifile_t) :: ifile
type(command_list_t), target :: command_list
type(rt_data_t), target :: global
type(parse_node_t), pointer :: pn_root
type(prclib_entry_t), pointer :: lib
write (u, "(A)") "* Test output: commands_3"
write (u, "(A)") "* Purpose: define process"
write (u, "(A)")
write (u, "(A)") "* Initialization"
write (u, "(A)")
call syntax_cmd_list_init ()
call syntax_model_file_init ()
call global%global_init ()
call global%var_list%set_log (var_str ("?omega_openmp"), &
.false., is_known = .true.)
allocate (lib)
call lib%init (var_str ("lib_cmd3"))
call global%add_prclib (lib)
write (u, "(A)") "* Input file"
write (u, "(A)")
call ifile_append (ifile, 'model = "Test"')
call ifile_append (ifile, 'process t3 = s, s => s, s')
call ifile_write (ifile, u)
write (u, "(A)")
write (u, "(A)") "* Parse file"
write (u, "(A)")
call parse_ifile (ifile, pn_root, u)
write (u, "(A)")
write (u, "(A)") "* Compile command list"
write (u, "(A)")
call command_list%compile (pn_root, global)
call command_list%write (u)
write (u, "(A)")
write (u, "(A)") "* Execute command list"
write (u, "(A)")
call command_list%execute (global)
call global%prclib_stack%write (u)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call ifile_final (ifile)
call command_list%final ()
call global%final ()
call syntax_cmd_list_final ()
call syntax_model_file_final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: commands_3"
end subroutine commands_3
@ %def commands_3
@
\subsubsection{Compile Process}
Read a model, then declare a process and compile the library. The process
library is allocated explicitly. For the process definition, We take the
default ([[unit_test]]) method. There is no external code, so compilation of
the library is merely a formal status change.
<<Commands: execute tests>>=
call test (commands_4, "commands_4", &
"compilation", &
u, results)
<<Commands: test declarations>>=
public :: commands_4
<<Commands: tests>>=
subroutine commands_4 (u)
integer, intent(in) :: u
type(ifile_t) :: ifile
type(command_list_t), target :: command_list
type(rt_data_t), target :: global
type(parse_node_t), pointer :: pn_root
type(prclib_entry_t), pointer :: lib
write (u, "(A)") "* Test output: commands_4"
write (u, "(A)") "* Purpose: define process and compile library"
write (u, "(A)")
write (u, "(A)") "* Initialization"
write (u, "(A)")
call syntax_cmd_list_init ()
call syntax_model_file_init ()
call global%global_init ()
call global%var_list%set_string (var_str ("$method"), &
var_str ("unit_test"), is_known=.true.)
allocate (lib)
call lib%init (var_str ("lib_cmd4"))
call global%add_prclib (lib)
write (u, "(A)") "* Input file"
write (u, "(A)")
call ifile_append (ifile, 'model = "Test"')
call ifile_append (ifile, 'process t4 = s, s => s, s')
call ifile_append (ifile, 'compile ("lib_cmd4")')
call ifile_write (ifile, u)
write (u, "(A)")
write (u, "(A)") "* Parse file"
write (u, "(A)")
call parse_ifile (ifile, pn_root, u)
write (u, "(A)")
write (u, "(A)") "* Compile command list"
write (u, "(A)")
call command_list%compile (pn_root, global)
call command_list%write (u)
write (u, "(A)")
write (u, "(A)") "* Execute command list"
write (u, "(A)")
call command_list%execute (global)
call global%prclib_stack%write (u)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call ifile_final (ifile)
call command_list%final ()
call global%final ()
call syntax_cmd_list_final ()
call syntax_model_file_final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: commands_4"
end subroutine commands_4
@ %def commands_4
@
\subsubsection{Integrate Process}
Read a model, then declare a process, compile the library, and
integrate over phase space. We take the
default ([[unit_test]]) method and use the simplest methods of
phase-space parameterization and integration.
<<Commands: execute tests>>=
call test (commands_5, "commands_5", &
"integration", &
u, results)
<<Commands: test declarations>>=
public :: commands_5
<<Commands: tests>>=
subroutine commands_5 (u)
integer, intent(in) :: u
type(ifile_t) :: ifile
type(command_list_t), target :: command_list
type(rt_data_t), target :: global
type(parse_node_t), pointer :: pn_root
type(prclib_entry_t), pointer :: lib
write (u, "(A)") "* Test output: commands_5"
write (u, "(A)") "* Purpose: define process, iterations, and integrate"
write (u, "(A)")
write (u, "(A)") "* Initialization"
write (u, "(A)")
call syntax_cmd_list_init ()
call syntax_model_file_init ()
call global%global_init ()
call global%var_list%set_string (var_str ("$method"), &
var_str ("unit_test"), is_known=.true.)
call global%var_list%set_string (var_str ("$phs_method"), &
var_str ("single"), is_known=.true.)
call global%var_list%set_string (var_str ("$integration_method"),&
var_str ("midpoint"), is_known=.true.)
call global%var_list%set_log (var_str ("?vis_history"),&
.false., is_known=.true.)
call global%var_list%set_log (var_str ("?integration_timer"),&
.false., is_known = .true.)
call global%var_list%set_real (var_str ("sqrts"), &
1000._default, is_known=.true.)
call global%var_list%set_int (var_str ("seed"), 0, is_known=.true.)
allocate (lib)
call lib%init (var_str ("lib_cmd5"))
call global%add_prclib (lib)
write (u, "(A)") "* Input file"
write (u, "(A)")
call ifile_append (ifile, 'model = "Test"')
call ifile_append (ifile, 'process t5 = s, s => s, s')
call ifile_append (ifile, 'compile')
call ifile_append (ifile, 'iterations = 1:1000')
call ifile_append (ifile, 'integrate (t5)')
call ifile_write (ifile, u)
write (u, "(A)")
write (u, "(A)") "* Parse file"
write (u, "(A)")
call parse_ifile (ifile, pn_root, u)
write (u, "(A)")
write (u, "(A)") "* Compile command list"
write (u, "(A)")
call command_list%compile (pn_root, global)
call command_list%write (u)
write (u, "(A)")
write (u, "(A)") "* Execute command list"
write (u, "(A)")
call reset_interaction_counter ()
call command_list%execute (global)
call global%it_list%write (u)
write (u, "(A)")
call global%process_stack%write (u)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call ifile_final (ifile)
call command_list%final ()
call global%final ()
call syntax_cmd_list_final ()
call syntax_model_file_final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: commands_5"
end subroutine commands_5
@ %def commands_5
@
\subsubsection{Variables}
Set intrinsic and user-defined variables.
<<Commands: execute tests>>=
call test (commands_6, "commands_6", &
"variables", &
u, results)
<<Commands: test declarations>>=
public :: commands_6
<<Commands: tests>>=
subroutine commands_6 (u)
integer, intent(in) :: u
type(ifile_t) :: ifile
type(command_list_t), target :: command_list
type(rt_data_t), target :: global
type(parse_node_t), pointer :: pn_root
write (u, "(A)") "* Test output: commands_6"
write (u, "(A)") "* Purpose: define and set variables"
write (u, "(A)")
write (u, "(A)") "* Initialization"
write (u, "(A)")
call syntax_cmd_list_init ()
call global%global_init ()
call global%write_vars (u, [ &
var_str ("$run_id"), &
var_str ("?unweighted"), &
var_str ("sqrts")])
write (u, "(A)")
write (u, "(A)") "* Input file"
write (u, "(A)")
call ifile_append (ifile, '$run_id = "run1"')
call ifile_append (ifile, '?unweighted = false')
call ifile_append (ifile, 'sqrts = 1000')
call ifile_append (ifile, 'int j = 10')
call ifile_append (ifile, 'real x = 1000.')
call ifile_append (ifile, 'complex z = 5')
call ifile_append (ifile, 'string $text = "abcd"')
call ifile_append (ifile, 'logical ?flag = true')
call ifile_write (ifile, u)
write (u, "(A)")
write (u, "(A)") "* Parse file"
write (u, "(A)")
call parse_ifile (ifile, pn_root, u)
write (u, "(A)")
write (u, "(A)") "* Compile command list"
write (u, "(A)")
call command_list%compile (pn_root, global)
call command_list%write (u)
write (u, "(A)")
write (u, "(A)") "* Execute command list"
write (u, "(A)")
call command_list%execute (global)
call global%write_vars (u, [ &
var_str ("$run_id"), &
var_str ("?unweighted"), &
var_str ("sqrts"), &
var_str ("j"), &
var_str ("x"), &
var_str ("z"), &
var_str ("$text"), &
var_str ("?flag")])
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call ifile_final (ifile)
call command_list%final ()
call syntax_cmd_list_final ()
call global%final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: commands_6"
end subroutine commands_6
@ %def commands_6
@
\subsubsection{Process library}
Open process libraries explicitly.
<<Commands: execute tests>>=
call test (commands_7, "commands_7", &
"process library", &
u, results)
<<Commands: test declarations>>=
public :: commands_7
<<Commands: tests>>=
subroutine commands_7 (u)
integer, intent(in) :: u
type(ifile_t) :: ifile
type(command_list_t), target :: command_list
type(rt_data_t), target :: global
type(parse_node_t), pointer :: pn_root
write (u, "(A)") "* Test output: commands_7"
write (u, "(A)") "* Purpose: declare process libraries"
write (u, "(A)")
write (u, "(A)") "* Initialization"
write (u, "(A)")
call syntax_cmd_list_init ()
call global%global_init ()
call global%var_list%set_log (var_str ("?omega_openmp"), &
.false., is_known = .true.)
global%os_data%fc = "Fortran-compiler"
global%os_data%fcflags = "Fortran-flags"
global%os_data%fclibs = "Fortran-libs"
write (u, "(A)")
write (u, "(A)") "* Input file"
write (u, "(A)")
call ifile_append (ifile, 'library = "lib_cmd7_1"')
call ifile_append (ifile, 'library = "lib_cmd7_2"')
call ifile_append (ifile, 'library = "lib_cmd7_1"')
call ifile_write (ifile, u)
write (u, "(A)")
write (u, "(A)") "* Parse file"
write (u, "(A)")
call parse_ifile (ifile, pn_root, u)
write (u, "(A)")
write (u, "(A)") "* Compile command list"
write (u, "(A)")
call command_list%compile (pn_root, global)
call command_list%write (u)
write (u, "(A)")
write (u, "(A)") "* Execute command list"
write (u, "(A)")
call command_list%execute (global)
call global%write_libraries (u)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call ifile_final (ifile)
call command_list%final ()
call syntax_cmd_list_final ()
call global%final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: commands_7"
end subroutine commands_7
@ %def commands_7
@
\subsubsection{Generate events}
Read a model, then declare a process, compile the library, and
generate weighted events. We take the
default ([[unit_test]]) method and use the simplest methods of
phase-space parameterization and integration.
<<Commands: execute tests>>=
call test (commands_8, "commands_8", &
"event generation", &
u, results)
<<Commands: test declarations>>=
public :: commands_8
<<Commands: tests>>=
subroutine commands_8 (u)
integer, intent(in) :: u
type(ifile_t) :: ifile
type(command_list_t), target :: command_list
type(rt_data_t), target :: global
type(parse_node_t), pointer :: pn_root
type(prclib_entry_t), pointer :: lib
write (u, "(A)") "* Test output: commands_8"
write (u, "(A)") "* Purpose: define process, integrate, generate events"
write (u, "(A)")
write (u, "(A)") "* Initialization"
write (u, "(A)")
call syntax_cmd_list_init ()
call syntax_model_file_init ()
call global%global_init ()
call global%init_fallback_model &
(var_str ("SM_hadrons"), var_str ("SM_hadrons.mdl"))
call global%var_list%set_string (var_str ("$method"), &
var_str ("unit_test"), is_known=.true.)
call global%var_list%set_string (var_str ("$phs_method"), &
var_str ("single"), is_known=.true.)
call global%var_list%set_string (var_str ("$integration_method"),&
var_str ("midpoint"), is_known=.true.)
call global%var_list%set_log (var_str ("?vis_history"),&
.false., is_known=.true.)
call global%var_list%set_log (var_str ("?integration_timer"),&
.false., is_known = .true.)
call global%var_list%set_real (var_str ("sqrts"), &
1000._default, is_known=.true.)
allocate (lib)
call lib%init (var_str ("lib_cmd8"))
call global%add_prclib (lib)
write (u, "(A)") "* Input file"
write (u, "(A)")
call ifile_append (ifile, 'model = "Test"')
call ifile_append (ifile, 'process commands_8_p = s, s => s, s')
call ifile_append (ifile, 'compile')
call ifile_append (ifile, 'iterations = 1:1000')
call ifile_append (ifile, 'integrate (commands_8_p)')
call ifile_append (ifile, '?unweighted = false')
call ifile_append (ifile, 'n_events = 3')
call ifile_append (ifile, '?read_raw = false')
call ifile_append (ifile, 'simulate (commands_8_p)')
call ifile_write (ifile, u)
write (u, "(A)")
write (u, "(A)") "* Parse file"
write (u, "(A)")
call parse_ifile (ifile, pn_root, u)
write (u, "(A)")
write (u, "(A)") "* Compile command list"
write (u, "(A)")
call command_list%compile (pn_root, global)
call command_list%write (u)
write (u, "(A)")
write (u, "(A)") "* Execute command list"
call command_list%execute (global)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call ifile_final (ifile)
call command_list%final ()
call global%final ()
call syntax_cmd_list_final ()
call syntax_model_file_final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: commands_8"
end subroutine commands_8
@ %def commands_8
@
\subsubsection{Define cuts}
Declare a cut expression.
<<Commands: execute tests>>=
call test (commands_9, "commands_9", &
"cuts", &
u, results)
<<Commands: test declarations>>=
public :: commands_9
<<Commands: tests>>=
subroutine commands_9 (u)
integer, intent(in) :: u
type(ifile_t) :: ifile
type(command_list_t), target :: command_list
type(rt_data_t), target :: global
type(parse_node_t), pointer :: pn_root
type(string_t), dimension(0) :: no_vars
write (u, "(A)") "* Test output: commands_9"
write (u, "(A)") "* Purpose: define cuts"
write (u, "(A)")
write (u, "(A)") "* Initialization"
write (u, "(A)")
call syntax_cmd_list_init ()
call global%global_init ()
write (u, "(A)") "* Input file"
write (u, "(A)")
call ifile_append (ifile, 'cuts = all Pt > 0 [particle]')
call ifile_write (ifile, u)
write (u, "(A)")
write (u, "(A)") "* Parse file"
write (u, "(A)")
call parse_ifile (ifile, pn_root, u)
write (u, "(A)")
write (u, "(A)") "* Compile command list"
write (u, "(A)")
call command_list%compile (pn_root, global)
call command_list%write (u)
write (u, "(A)")
write (u, "(A)") "* Execute command list"
write (u, "(A)")
call command_list%execute (global)
call global%write (u, vars = no_vars)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call ifile_final (ifile)
call command_list%final ()
call global%final ()
call syntax_cmd_list_final ()
call syntax_model_file_final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: commands_9"
end subroutine commands_9
@ %def commands_9
@
\subsubsection{Beams}
Define beam setup.
<<Commands: execute tests>>=
call test (commands_10, "commands_10", &
"beams", &
u, results)
<<Commands: test declarations>>=
public :: commands_10
<<Commands: tests>>=
subroutine commands_10 (u)
integer, intent(in) :: u
type(ifile_t) :: ifile
type(command_list_t), target :: command_list
type(rt_data_t), target :: global
type(parse_node_t), pointer :: pn_root
write (u, "(A)") "* Test output: commands_10"
write (u, "(A)") "* Purpose: define beams"
write (u, "(A)")
write (u, "(A)") "* Initialization"
write (u, "(A)")
call syntax_cmd_list_init ()
call syntax_model_file_init ()
call global%global_init ()
write (u, "(A)") "* Input file"
write (u, "(A)")
call ifile_append (ifile, 'model = QCD')
call ifile_append (ifile, 'sqrts = 1000')
call ifile_append (ifile, 'beams = p, p')
call ifile_write (ifile, u)
write (u, "(A)")
write (u, "(A)") "* Parse file"
write (u, "(A)")
call parse_ifile (ifile, pn_root, u)
write (u, "(A)")
write (u, "(A)") "* Compile command list"
write (u, "(A)")
call command_list%compile (pn_root, global)
call command_list%write (u)
write (u, "(A)")
write (u, "(A)") "* Execute command list"
write (u, "(A)")
call command_list%execute (global)
call global%write_beams (u)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call ifile_final (ifile)
call command_list%final ()
call global%final ()
call syntax_cmd_list_final ()
call syntax_model_file_final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: commands_10"
end subroutine commands_10
@ %def commands_10
@
\subsubsection{Structure functions}
Define beam setup with structure functions
<<Commands: execute tests>>=
call test (commands_11, "commands_11", &
"structure functions", &
u, results)
<<Commands: test declarations>>=
public :: commands_11
<<Commands: tests>>=
subroutine commands_11 (u)
integer, intent(in) :: u
type(ifile_t) :: ifile
type(command_list_t), target :: command_list
type(rt_data_t), target :: global
type(parse_node_t), pointer :: pn_root
write (u, "(A)") "* Test output: commands_11"
write (u, "(A)") "* Purpose: define beams with structure functions"
write (u, "(A)")
write (u, "(A)") "* Initialization"
write (u, "(A)")
call syntax_cmd_list_init ()
call syntax_model_file_init ()
call global%global_init ()
write (u, "(A)") "* Input file"
write (u, "(A)")
call ifile_append (ifile, 'model = QCD')
call ifile_append (ifile, 'sqrts = 1100')
call ifile_append (ifile, 'beams = p, p => lhapdf => pdf_builtin, isr')
call ifile_write (ifile, u)
write (u, "(A)")
write (u, "(A)") "* Parse file"
write (u, "(A)")
call parse_ifile (ifile, pn_root, u)
write (u, "(A)")
write (u, "(A)") "* Compile command list"
write (u, "(A)")
call command_list%compile (pn_root, global)
call command_list%write (u)
write (u, "(A)")
write (u, "(A)") "* Execute command list"
write (u, "(A)")
call command_list%execute (global)
call global%write_beams (u)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call ifile_final (ifile)
call command_list%final ()
call global%final ()
call syntax_cmd_list_final ()
call syntax_model_file_final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: commands_11"
end subroutine commands_11
@ %def commands_11
@
\subsubsection{Rescan events}
Read a model, then declare a process, compile the library, and
generate weighted events. We take the
default ([[unit_test]]) method and use the simplest methods of
phase-space parameterization and integration. Then, rescan the
generated event sample.
<<Commands: execute tests>>=
call test (commands_12, "commands_12", &
"event rescanning", &
u, results)
<<Commands: test declarations>>=
public :: commands_12
<<Commands: tests>>=
subroutine commands_12 (u)
integer, intent(in) :: u
type(ifile_t) :: ifile
type(command_list_t), target :: command_list
type(rt_data_t), target :: global
type(parse_node_t), pointer :: pn_root
type(prclib_entry_t), pointer :: lib
write (u, "(A)") "* Test output: commands_12"
write (u, "(A)") "* Purpose: generate events and rescan"
write (u, "(A)")
write (u, "(A)") "* Initialization"
write (u, "(A)")
call syntax_cmd_list_init ()
call syntax_model_file_init ()
call global%global_init ()
call global%var_list%append_log (&
var_str ("?rebuild_phase_space"), .false., &
intrinsic=.true.)
call global%var_list%append_log (&
var_str ("?rebuild_grids"), .false., &
intrinsic=.true.)
call global%init_fallback_model &
(var_str ("SM_hadrons"), var_str ("SM_hadrons.mdl"))
call global%var_list%set_string (var_str ("$method"), &
var_str ("unit_test"), is_known=.true.)
call global%var_list%set_string (var_str ("$phs_method"), &
var_str ("single"), is_known=.true.)
call global%var_list%set_string (var_str ("$integration_method"),&
var_str ("midpoint"), is_known=.true.)
call global%var_list%set_log (var_str ("?vis_history"),&
.false., is_known=.true.)
call global%var_list%set_log (var_str ("?integration_timer"),&
.false., is_known = .true.)
call global%var_list%set_real (var_str ("sqrts"), &
1000._default, is_known=.true.)
allocate (lib)
call lib%init (var_str ("lib_cmd12"))
call global%add_prclib (lib)
write (u, "(A)") "* Input file"
write (u, "(A)")
call ifile_append (ifile, 'model = "Test"')
call ifile_append (ifile, 'process commands_12_p = s, s => s, s')
call ifile_append (ifile, 'compile')
call ifile_append (ifile, 'iterations = 1:1000')
call ifile_append (ifile, 'integrate (commands_12_p)')
call ifile_append (ifile, '?unweighted = false')
call ifile_append (ifile, 'n_events = 3')
call ifile_append (ifile, '?read_raw = false')
call ifile_append (ifile, 'simulate (commands_12_p)')
call ifile_append (ifile, '?write_raw = false')
call ifile_append (ifile, 'rescan "commands_12_p" (commands_12_p)')
call ifile_write (ifile, u)
write (u, "(A)")
write (u, "(A)") "* Parse file"
write (u, "(A)")
call parse_ifile (ifile, pn_root, u)
write (u, "(A)")
write (u, "(A)") "* Compile command list"
write (u, "(A)")
call command_list%compile (pn_root, global)
call command_list%write (u)
write (u, "(A)")
write (u, "(A)") "* Execute command list"
call command_list%execute (global)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call ifile_final (ifile)
call command_list%final ()
call global%final ()
call syntax_cmd_list_final ()
call syntax_model_file_final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: commands_12"
end subroutine commands_12
@ %def commands_12
@
\subsubsection{Event Files}
Set output formats for event files.
<<Commands: execute tests>>=
call test (commands_13, "commands_13", &
"event output formats", &
u, results)
<<Commands: test declarations>>=
public :: commands_13
<<Commands: tests>>=
subroutine commands_13 (u)
integer, intent(in) :: u
type(ifile_t) :: ifile
type(command_list_t), target :: command_list
type(rt_data_t), target :: global
type(parse_node_t), pointer :: pn_root
type(prclib_entry_t), pointer :: lib
logical :: exist
write (u, "(A)") "* Test output: commands_13"
write (u, "(A)") "* Purpose: generate events and rescan"
write (u, "(A)")
write (u, "(A)") "* Initialization"
write (u, "(A)")
call syntax_cmd_list_init ()
call syntax_model_file_init ()
call global%global_init ()
call global%init_fallback_model &
(var_str ("SM_hadrons"), var_str ("SM_hadrons.mdl"))
call global%var_list%set_string (var_str ("$method"), &
var_str ("unit_test"), is_known=.true.)
call global%var_list%set_string (var_str ("$phs_method"), &
var_str ("single"), is_known=.true.)
call global%var_list%set_string (var_str ("$integration_method"),&
var_str ("midpoint"), is_known=.true.)
call global%var_list%set_real (var_str ("sqrts"), &
1000._default, is_known=.true.)
call global%var_list%set_log (var_str ("?vis_history"),&
.false., is_known=.true.)
call global%var_list%set_log (var_str ("?integration_timer"),&
.false., is_known = .true.)
allocate (lib)
call lib%init (var_str ("lib_cmd13"))
call global%add_prclib (lib)
write (u, "(A)") "* Input file"
write (u, "(A)")
call ifile_append (ifile, 'model = "Test"')
call ifile_append (ifile, 'process commands_13_p = s, s => s, s')
call ifile_append (ifile, 'compile')
call ifile_append (ifile, 'iterations = 1:1000')
call ifile_append (ifile, 'integrate (commands_13_p)')
call ifile_append (ifile, '?unweighted = false')
call ifile_append (ifile, 'n_events = 1')
call ifile_append (ifile, '?read_raw = false')
call ifile_append (ifile, 'sample_format = weight_stream')
call ifile_append (ifile, 'simulate (commands_13_p)')
call ifile_write (ifile, u)
write (u, "(A)")
write (u, "(A)") "* Parse file"
write (u, "(A)")
call parse_ifile (ifile, pn_root, u)
write (u, "(A)")
write (u, "(A)") "* Compile command list"
write (u, "(A)")
call command_list%compile (pn_root, global)
call command_list%write (u)
write (u, "(A)")
write (u, "(A)") "* Execute command list"
call command_list%execute (global)
write (u, "(A)")
write (u, "(A)") "* Verify output files"
write (u, "(A)")
inquire (file = "commands_13_p.evx", exist = exist)
if (exist) write (u, "(1x,A)") "raw"
inquire (file = "commands_13_p.weights.dat", exist = exist)
if (exist) write (u, "(1x,A)") "weight_stream"
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call ifile_final (ifile)
call command_list%final ()
call global%final ()
call syntax_cmd_list_final ()
call syntax_model_file_final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: commands_13"
end subroutine commands_13
@ %def commands_13
@
\subsubsection{Compile Empty Libraries}
(This is a regression test:) Declare two empty libraries and compile them.
<<Commands: execute tests>>=
call test (commands_14, "commands_14", &
"empty libraries", &
u, results)
<<Commands: test declarations>>=
public :: commands_14
<<Commands: tests>>=
subroutine commands_14 (u)
integer, intent(in) :: u
type(ifile_t) :: ifile
type(command_list_t), target :: command_list
type(rt_data_t), target :: global
type(parse_node_t), pointer :: pn_root
write (u, "(A)") "* Test output: commands_14"
write (u, "(A)") "* Purpose: define and compile empty libraries"
write (u, "(A)")
write (u, "(A)") "* Initialization"
write (u, "(A)")
call syntax_model_file_init ()
call syntax_cmd_list_init ()
call global%global_init ()
write (u, "(A)") "* Input file"
write (u, "(A)")
call ifile_append (ifile, 'model = "Test"')
call ifile_append (ifile, 'library = "lib1"')
call ifile_append (ifile, 'library = "lib2"')
call ifile_append (ifile, 'compile ()')
call ifile_write (ifile, u)
write (u, "(A)")
write (u, "(A)") "* Parse file"
write (u, "(A)")
call parse_ifile (ifile, pn_root)
write (u, "(A)") "* Compile command list"
write (u, "(A)")
call command_list%compile (pn_root, global)
write (u, "(A)") "* Execute command list"
write (u, "(A)")
call command_list%execute (global)
call global%prclib_stack%write (u)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call ifile_final (ifile)
call command_list%final ()
call global%final ()
call syntax_cmd_list_final ()
call syntax_model_file_final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: commands_14"
end subroutine commands_14
@ %def commands_14
@
\subsubsection{Compile Process}
Read a model, then declare a process and compile the library. The process
library is allocated explicitly. For the process definition, We take the
default ([[unit_test]]) method. There is no external code, so compilation of
the library is merely a formal status change.
<<Commands: execute tests>>=
call test (commands_15, "commands_15", &
"compilation", &
u, results)
<<Commands: test declarations>>=
public :: commands_15
<<Commands: tests>>=
subroutine commands_15 (u)
integer, intent(in) :: u
type(ifile_t) :: ifile
type(command_list_t), target :: command_list
type(rt_data_t), target :: global
type(parse_node_t), pointer :: pn_root
type(prclib_entry_t), pointer :: lib
write (u, "(A)") "* Test output: commands_15"
write (u, "(A)") "* Purpose: define process and compile library"
write (u, "(A)")
write (u, "(A)") "* Initialization"
write (u, "(A)")
call syntax_cmd_list_init ()
call syntax_model_file_init ()
call global%global_init ()
call global%var_list%set_string (var_str ("$method"), &
var_str ("unit_test"), is_known=.true.)
call global%var_list%set_string (var_str ("$phs_method"), &
var_str ("single"), is_known=.true.)
call global%var_list%set_string (var_str ("$integration_method"),&
var_str ("midpoint"), is_known=.true.)
call global%var_list%set_real (var_str ("sqrts"), &
1000._default, is_known=.true.)
call global%var_list%set_log (var_str ("?vis_history"),&
.false., is_known=.true.)
call global%var_list%set_log (var_str ("?integration_timer"),&
.false., is_known = .true.)
allocate (lib)
call lib%init (var_str ("lib_cmd15"))
call global%add_prclib (lib)
write (u, "(A)") "* Input file"
write (u, "(A)")
call ifile_append (ifile, 'model = "Test"')
call ifile_append (ifile, 'process t15 = s, s => s, s')
call ifile_append (ifile, 'iterations = 1:1000')
call ifile_append (ifile, 'integrate (t15)')
call ifile_write (ifile, u)
write (u, "(A)")
write (u, "(A)") "* Parse file"
write (u, "(A)")
call parse_ifile (ifile, pn_root)
write (u, "(A)") "* Compile command list"
write (u, "(A)")
call command_list%compile (pn_root, global)
write (u, "(A)") "* Execute command list"
write (u, "(A)")
call command_list%execute (global)
call global%prclib_stack%write (u)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call ifile_final (ifile)
call command_list%final ()
call global%final ()
call syntax_cmd_list_final ()
call syntax_model_file_final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: commands_15"
end subroutine commands_15
@ %def commands_15
@
\subsubsection{Observable}
Declare an observable, fill it and display.
<<Commands: execute tests>>=
call test (commands_16, "commands_16", &
"observables", &
u, results)
<<Commands: test declarations>>=
public :: commands_16
<<Commands: tests>>=
subroutine commands_16 (u)
integer, intent(in) :: u
type(ifile_t) :: ifile
type(command_list_t), target :: command_list
type(rt_data_t), target :: global
type(parse_node_t), pointer :: pn_root
write (u, "(A)") "* Test output: commands_16"
write (u, "(A)") "* Purpose: declare an observable"
write (u, "(A)")
write (u, "(A)") "* Initialization"
write (u, "(A)")
call syntax_cmd_list_init ()
call global%global_init ()
write (u, "(A)") "* Input file"
write (u, "(A)")
call ifile_append (ifile, '$obs_label = "foo"')
call ifile_append (ifile, '$obs_unit = "cm"')
call ifile_append (ifile, '$title = "Observable foo"')
call ifile_append (ifile, '$description = "This is observable foo"')
call ifile_append (ifile, 'observable foo')
call ifile_write (ifile, u)
write (u, "(A)")
write (u, "(A)") "* Parse file"
write (u, "(A)")
call parse_ifile (ifile, pn_root)
write (u, "(A)") "* Compile command list"
write (u, "(A)")
call command_list%compile (pn_root, global)
call command_list%write (u)
write (u, "(A)")
write (u, "(A)") "* Execute command list"
write (u, "(A)")
call command_list%execute (global)
write (u, "(A)") "* Record two data items"
write (u, "(A)")
call analysis_record_data (var_str ("foo"), 1._default)
call analysis_record_data (var_str ("foo"), 3._default)
write (u, "(A)") "* Display analysis store"
write (u, "(A)")
call analysis_write (u, verbose=.true.)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call ifile_final (ifile)
call analysis_final ()
call command_list%final ()
call global%final ()
call syntax_cmd_list_final ()
call syntax_model_file_final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: commands_16"
end subroutine commands_16
@ %def commands_16
@
\subsubsection{Histogram}
Declare a histogram, fill it and display.
<<Commands: execute tests>>=
call test (commands_17, "commands_17", &
"histograms", &
u, results)
<<Commands: test declarations>>=
public :: commands_17
<<Commands: tests>>=
subroutine commands_17 (u)
integer, intent(in) :: u
type(ifile_t) :: ifile
type(command_list_t), target :: command_list
type(rt_data_t), target :: global
type(parse_node_t), pointer :: pn_root
type(string_t), dimension(3) :: name
integer :: i
write (u, "(A)") "* Test output: commands_17"
write (u, "(A)") "* Purpose: declare histograms"
write (u, "(A)")
write (u, "(A)") "* Initialization"
write (u, "(A)")
call syntax_cmd_list_init ()
call global%global_init ()
write (u, "(A)") "* Input file"
write (u, "(A)")
call ifile_append (ifile, '$obs_label = "foo"')
call ifile_append (ifile, '$obs_unit = "cm"')
call ifile_append (ifile, '$title = "Histogram foo"')
call ifile_append (ifile, '$description = "This is histogram foo"')
call ifile_append (ifile, 'histogram foo (0,5,1)')
call ifile_append (ifile, '$title = "Histogram bar"')
call ifile_append (ifile, '$description = "This is histogram bar"')
call ifile_append (ifile, 'n_bins = 2')
call ifile_append (ifile, 'histogram bar (0,5)')
call ifile_append (ifile, '$title = "Histogram gee"')
call ifile_append (ifile, '$description = "This is histogram gee"')
call ifile_append (ifile, '?normalize_bins = true')
call ifile_append (ifile, 'histogram gee (0,5)')
call ifile_write (ifile, u)
write (u, "(A)")
write (u, "(A)") "* Parse file"
write (u, "(A)")
call parse_ifile (ifile, pn_root)
write (u, "(A)") "* Compile command list"
write (u, "(A)")
call command_list%compile (pn_root, global)
call command_list%write (u)
write (u, "(A)")
write (u, "(A)") "* Execute command list"
write (u, "(A)")
call command_list%execute (global)
write (u, "(A)") "* Record two data items"
write (u, "(A)")
name(1) = "foo"
name(2) = "bar"
name(3) = "gee"
do i = 1, 3
call analysis_record_data (name(i), 0.1_default, &
weight = 0.25_default)
call analysis_record_data (name(i), 3.1_default)
call analysis_record_data (name(i), 4.1_default, &
excess = 0.5_default)
call analysis_record_data (name(i), 7.1_default)
end do
write (u, "(A)") "* Display analysis store"
write (u, "(A)")
call analysis_write (u, verbose=.true.)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call ifile_final (ifile)
call analysis_final ()
call command_list%final ()
call global%final ()
call syntax_cmd_list_final ()
call syntax_model_file_final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: commands_17"
end subroutine commands_17
@ %def commands_17
@
\subsubsection{Plot}
Declare a plot, fill it and display contents.
<<Commands: execute tests>>=
call test (commands_18, "commands_18", &
"plots", &
u, results)
<<Commands: test declarations>>=
public :: commands_18
<<Commands: tests>>=
subroutine commands_18 (u)
integer, intent(in) :: u
type(ifile_t) :: ifile
type(command_list_t), target :: command_list
type(rt_data_t), target :: global
type(parse_node_t), pointer :: pn_root
write (u, "(A)") "* Test output: commands_18"
write (u, "(A)") "* Purpose: declare a plot"
write (u, "(A)")
write (u, "(A)") "* Initialization"
write (u, "(A)")
call syntax_cmd_list_init ()
call global%global_init ()
write (u, "(A)") "* Input file"
write (u, "(A)")
call ifile_append (ifile, '$obs_label = "foo"')
call ifile_append (ifile, '$obs_unit = "cm"')
call ifile_append (ifile, '$title = "Plot foo"')
call ifile_append (ifile, '$description = "This is plot foo"')
call ifile_append (ifile, '$x_label = "x axis"')
call ifile_append (ifile, '$y_label = "y axis"')
call ifile_append (ifile, '?x_log = false')
call ifile_append (ifile, '?y_log = true')
call ifile_append (ifile, 'x_min = -1')
call ifile_append (ifile, 'x_max = 1')
call ifile_append (ifile, 'y_min = 0.1')
call ifile_append (ifile, 'y_max = 1000')
call ifile_append (ifile, 'plot foo')
call ifile_write (ifile, u)
write (u, "(A)")
write (u, "(A)") "* Parse file"
write (u, "(A)")
call parse_ifile (ifile, pn_root)
write (u, "(A)") "* Compile command list"
write (u, "(A)")
call command_list%compile (pn_root, global)
call command_list%write (u)
write (u, "(A)")
write (u, "(A)") "* Execute command list"
write (u, "(A)")
call command_list%execute (global)
write (u, "(A)") "* Record two data items"
write (u, "(A)")
call analysis_record_data (var_str ("foo"), 0._default, 20._default, &
xerr = 0.25_default)
call analysis_record_data (var_str ("foo"), 0.5_default, 0.2_default, &
yerr = 0.07_default)
call analysis_record_data (var_str ("foo"), 3._default, 2._default)
write (u, "(A)") "* Display analysis store"
write (u, "(A)")
call analysis_write (u, verbose=.true.)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call ifile_final (ifile)
call analysis_final ()
call command_list%final ()
call global%final ()
call syntax_cmd_list_final ()
call syntax_model_file_final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: commands_18"
end subroutine commands_18
@ %def commands_18
@
\subsubsection{Graph}
Combine two (empty) plots to a graph.
<<Commands: execute tests>>=
call test (commands_19, "commands_19", &
"graphs", &
u, results)
<<Commands: test declarations>>=
public :: commands_19
<<Commands: tests>>=
subroutine commands_19 (u)
integer, intent(in) :: u
type(ifile_t) :: ifile
type(command_list_t), target :: command_list
type(rt_data_t), target :: global
type(parse_node_t), pointer :: pn_root
write (u, "(A)") "* Test output: commands_19"
write (u, "(A)") "* Purpose: combine two plots to a graph"
write (u, "(A)")
write (u, "(A)") "* Initialization"
write (u, "(A)")
call syntax_cmd_list_init ()
call global%global_init ()
write (u, "(A)") "* Input file"
write (u, "(A)")
call ifile_append (ifile, 'plot a')
call ifile_append (ifile, 'plot b')
call ifile_append (ifile, '$title = "Graph foo"')
call ifile_append (ifile, '$description = "This is graph foo"')
call ifile_append (ifile, 'graph foo = a & b')
call ifile_write (ifile, u)
write (u, "(A)")
write (u, "(A)") "* Parse file"
write (u, "(A)")
call parse_ifile (ifile, pn_root)
write (u, "(A)") "* Compile command list"
write (u, "(A)")
call command_list%compile (pn_root, global)
call command_list%write (u)
write (u, "(A)")
write (u, "(A)") "* Execute command list"
write (u, "(A)")
call command_list%execute (global)
write (u, "(A)") "* Display analysis object"
write (u, "(A)")
call analysis_write (var_str ("foo"), u)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call ifile_final (ifile)
call analysis_final ()
call command_list%final ()
call global%final ()
call syntax_cmd_list_final ()
call syntax_model_file_final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: commands_19"
end subroutine commands_19
@ %def commands_19
@
\subsubsection{Record Data}
Record data in previously allocated analysis objects.
<<Commands: execute tests>>=
call test (commands_20, "commands_20", &
"record data", &
u, results)
<<Commands: test declarations>>=
public :: commands_20
<<Commands: tests>>=
subroutine commands_20 (u)
integer, intent(in) :: u
type(ifile_t) :: ifile
type(command_list_t), target :: command_list
type(rt_data_t), target :: global
type(parse_node_t), pointer :: pn_root
write (u, "(A)") "* Test output: commands_20"
write (u, "(A)") "* Purpose: record data"
write (u, "(A)")
write (u, "(A)") "* Initialization: create observable, histogram, plot"
write (u, "(A)")
call syntax_cmd_list_init ()
call global%global_init ()
call analysis_init_observable (var_str ("o"))
call analysis_init_histogram (var_str ("h"), 0._default, 1._default, 3, &
normalize_bins = .false.)
call analysis_init_plot (var_str ("p"))
write (u, "(A)") "* Input file"
write (u, "(A)")
call ifile_append (ifile, 'record o (1.234)')
call ifile_append (ifile, 'record h (0.5)')
call ifile_append (ifile, 'record p (1, 2)')
call ifile_write (ifile, u)
write (u, "(A)")
write (u, "(A)") "* Parse file"
write (u, "(A)")
call parse_ifile (ifile, pn_root)
write (u, "(A)") "* Compile command list"
write (u, "(A)")
call command_list%compile (pn_root, global)
call command_list%write (u)
write (u, "(A)")
write (u, "(A)") "* Execute command list"
write (u, "(A)")
call command_list%execute (global)
write (u, "(A)") "* Display analysis object"
write (u, "(A)")
call analysis_write (u, verbose = .true.)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call ifile_final (ifile)
call analysis_final ()
call command_list%final ()
call global%final ()
call syntax_cmd_list_final ()
call syntax_model_file_final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: commands_20"
end subroutine commands_20
@ %def commands_20
@
\subsubsection{Analysis}
Declare an analysis expression and use it to fill an observable during
event generation.
<<Commands: execute tests>>=
call test (commands_21, "commands_21", &
"analysis expression", &
u, results)
<<Commands: test declarations>>=
public :: commands_21
<<Commands: tests>>=
subroutine commands_21 (u)
integer, intent(in) :: u
type(ifile_t) :: ifile
type(command_list_t), target :: command_list
type(rt_data_t), target :: global
type(parse_node_t), pointer :: pn_root
type(prclib_entry_t), pointer :: lib
write (u, "(A)") "* Test output: commands_21"
write (u, "(A)") "* Purpose: create and use analysis expression"
write (u, "(A)")
write (u, "(A)") "* Initialization: create observable"
write (u, "(A)")
call syntax_cmd_list_init ()
call syntax_model_file_init ()
call global%global_init ()
call global%init_fallback_model &
(var_str ("SM_hadrons"), var_str ("SM_hadrons.mdl"))
call global%var_list%set_string (var_str ("$method"), &
var_str ("unit_test"), is_known=.true.)
call global%var_list%set_string (var_str ("$phs_method"), &
var_str ("single"), is_known=.true.)
call global%var_list%set_string (var_str ("$integration_method"),&
var_str ("midpoint"), is_known=.true.)
call global%var_list%set_log (var_str ("?vis_history"),&
.false., is_known=.true.)
call global%var_list%set_log (var_str ("?integration_timer"),&
.false., is_known = .true.)
call global%var_list%set_real (var_str ("sqrts"), &
1000._default, is_known=.true.)
allocate (lib)
call lib%init (var_str ("lib_cmd8"))
call global%add_prclib (lib)
call analysis_init_observable (var_str ("m"))
write (u, "(A)") "* Input file"
write (u, "(A)")
call ifile_append (ifile, 'model = "Test"')
call ifile_append (ifile, 'process commands_21_p = s, s => s, s')
call ifile_append (ifile, 'compile')
call ifile_append (ifile, 'iterations = 1:100')
call ifile_append (ifile, 'integrate (commands_21_p)')
call ifile_append (ifile, '?unweighted = true')
call ifile_append (ifile, 'n_events = 3')
call ifile_append (ifile, '?read_raw = false')
call ifile_append (ifile, 'observable m')
call ifile_append (ifile, 'analysis = record m (eval M [s])')
call ifile_append (ifile, 'simulate (commands_21_p)')
call ifile_write (ifile, u)
write (u, "(A)")
write (u, "(A)") "* Parse file"
write (u, "(A)")
call parse_ifile (ifile, pn_root)
write (u, "(A)") "* Compile command list"
write (u, "(A)")
call command_list%compile (pn_root, global)
call command_list%write (u)
write (u, "(A)")
write (u, "(A)") "* Execute command list"
write (u, "(A)")
call command_list%execute (global)
write (u, "(A)") "* Display analysis object"
write (u, "(A)")
call analysis_write (u)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call ifile_final (ifile)
call analysis_final ()
call command_list%final ()
call global%final ()
call syntax_cmd_list_final ()
call syntax_model_file_final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: commands_21"
end subroutine commands_21
@ %def commands_21
@
\subsubsection{Write Analysis}
Write accumulated analysis data to file.
<<Commands: execute tests>>=
call test (commands_22, "commands_22", &
"write analysis", &
u, results)
<<Commands: test declarations>>=
public :: commands_22
<<Commands: tests>>=
subroutine commands_22 (u)
integer, intent(in) :: u
type(ifile_t) :: ifile
type(command_list_t), target :: command_list
type(rt_data_t), target :: global
type(parse_node_t), pointer :: pn_root
integer :: u_file, iostat
logical :: exist
character(80) :: buffer
write (u, "(A)") "* Test output: commands_22"
write (u, "(A)") "* Purpose: write analysis data"
write (u, "(A)")
write (u, "(A)") "* Initialization: create observable"
write (u, "(A)")
call syntax_cmd_list_init ()
call global%global_init ()
call analysis_init_observable (var_str ("m"))
call analysis_record_data (var_str ("m"), 125._default)
write (u, "(A)") "* Input file"
write (u, "(A)")
call ifile_append (ifile, '$out_file = "commands_22.dat"')
call ifile_append (ifile, 'write_analysis')
call ifile_write (ifile, u)
write (u, "(A)")
write (u, "(A)") "* Parse file"
write (u, "(A)")
call parse_ifile (ifile, pn_root)
write (u, "(A)") "* Compile command list"
write (u, "(A)")
call command_list%compile (pn_root, global)
call command_list%write (u)
write (u, "(A)")
write (u, "(A)") "* Execute command list"
write (u, "(A)")
call command_list%execute (global)
write (u, "(A)") "* Display analysis data"
write (u, "(A)")
inquire (file = "commands_22.dat", exist = exist)
if (.not. exist) then
write (u, "(A)") "ERROR: File commands_22.dat not found"
return
end if
u_file = free_unit ()
open (u_file, file = "commands_22.dat", &
action = "read", status = "old")
do
read (u_file, "(A)", iostat = iostat) buffer
if (iostat /= 0) exit
write (u, "(A)") trim (buffer)
end do
close (u_file)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call ifile_final (ifile)
call analysis_final ()
call command_list%final ()
call global%final ()
call syntax_cmd_list_final ()
call syntax_model_file_final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: commands_22"
end subroutine commands_22
@ %def commands_22
@
\subsubsection{Compile Analysis}
Write accumulated analysis data to file and compile.
<<Commands: execute tests>>=
if (MPOST_AVAILABLE) then
call test (commands_23, "commands_23", &
"compile analysis", &
u, results)
end if
<<Commands: test declarations>>=
public :: commands_23
<<Commands: tests>>=
subroutine commands_23 (u)
integer, intent(in) :: u
type(ifile_t) :: ifile
type(command_list_t), target :: command_list
type(rt_data_t), target :: global
type(parse_node_t), pointer :: pn_root
integer :: u_file, iostat
character(256) :: buffer
logical :: exist
type(graph_options_t) :: graph_options
write (u, "(A)") "* Test output: commands_23"
write (u, "(A)") "* Purpose: write and compile analysis data"
write (u, "(A)")
write (u, "(A)") "* Initialization: create and fill histogram"
write (u, "(A)")
call syntax_cmd_list_init ()
call global%global_init ()
call graph_options_init (graph_options)
call graph_options_set (graph_options, &
title = var_str ("Histogram for test: commands 23"), &
description = var_str ("This is a test."), &
width_mm = 125, height_mm = 85)
call analysis_init_histogram (var_str ("h"), &
0._default, 10._default, 2._default, .false., &
graph_options = graph_options)
call analysis_record_data (var_str ("h"), 1._default)
call analysis_record_data (var_str ("h"), 1._default)
call analysis_record_data (var_str ("h"), 1._default)
call analysis_record_data (var_str ("h"), 1._default)
call analysis_record_data (var_str ("h"), 3._default)
call analysis_record_data (var_str ("h"), 3._default)
call analysis_record_data (var_str ("h"), 3._default)
call analysis_record_data (var_str ("h"), 5._default)
call analysis_record_data (var_str ("h"), 7._default)
call analysis_record_data (var_str ("h"), 7._default)
call analysis_record_data (var_str ("h"), 7._default)
call analysis_record_data (var_str ("h"), 7._default)
call analysis_record_data (var_str ("h"), 9._default)
call analysis_record_data (var_str ("h"), 9._default)
call analysis_record_data (var_str ("h"), 9._default)
call analysis_record_data (var_str ("h"), 9._default)
call analysis_record_data (var_str ("h"), 9._default)
call analysis_record_data (var_str ("h"), 9._default)
call analysis_record_data (var_str ("h"), 9._default)
write (u, "(A)") "* Input file"
write (u, "(A)")
call ifile_append (ifile, '$out_file = "commands_23.dat"')
call ifile_append (ifile, 'compile_analysis')
call ifile_write (ifile, u)
write (u, "(A)")
write (u, "(A)") "* Parse file"
write (u, "(A)")
call parse_ifile (ifile, pn_root)
write (u, "(A)") "* Compile command list"
write (u, "(A)")
call command_list%compile (pn_root, global)
call command_list%write (u)
write (u, "(A)")
write (u, "(A)") "* Delete Postscript output"
write (u, "(A)")
inquire (file = "commands_23.ps", exist = exist)
if (exist) then
u_file = free_unit ()
open (u_file, file = "commands_23.ps", action = "write", status = "old")
close (u_file, status = "delete")
end if
inquire (file = "commands_23.ps", exist = exist)
write (u, "(1x,A,L1)") "Postcript output exists = ", exist
write (u, "(A)")
write (u, "(A)") "* Execute command list"
write (u, "(A)")
call command_list%execute (global)
write (u, "(A)") "* TeX file"
write (u, "(A)")
inquire (file = "commands_23.tex", exist = exist)
if (.not. exist) then
write (u, "(A)") "ERROR: File commands_23.tex not found"
return
end if
u_file = free_unit ()
open (u_file, file = "commands_23.tex", &
action = "read", status = "old")
do
read (u_file, "(A)", iostat = iostat) buffer
if (iostat /= 0) exit
write (u, "(A)") trim (buffer)
end do
close (u_file)
write (u, *)
inquire (file = "commands_23.ps", exist = exist)
write (u, "(1x,A,L1)") "Postcript output exists = ", exist
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call ifile_final (ifile)
call analysis_final ()
call command_list%final ()
call global%final ()
call syntax_cmd_list_final ()
call syntax_model_file_final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: commands_23"
end subroutine commands_23
@ %def commands_23
@
\subsubsection{Histogram}
Declare a histogram, fill it and display.
<<Commands: execute tests>>=
call test (commands_24, "commands_24", &
"drawing options", &
u, results)
<<Commands: test declarations>>=
public :: commands_24
<<Commands: tests>>=
subroutine commands_24 (u)
integer, intent(in) :: u
type(ifile_t) :: ifile
type(command_list_t), target :: command_list
type(rt_data_t), target :: global
type(parse_node_t), pointer :: pn_root
write (u, "(A)") "* Test output: commands_24"
write (u, "(A)") "* Purpose: check graph and drawing options"
write (u, "(A)")
write (u, "(A)") "* Initialization"
write (u, "(A)")
call syntax_cmd_list_init ()
call global%global_init ()
write (u, "(A)") "* Input file"
write (u, "(A)")
call ifile_append (ifile, '$title = "Title"')
call ifile_append (ifile, '$description = "Description"')
call ifile_append (ifile, '$x_label = "X Label"')
call ifile_append (ifile, '$y_label = "Y Label"')
call ifile_append (ifile, 'graph_width_mm = 111')
call ifile_append (ifile, 'graph_height_mm = 222')
call ifile_append (ifile, 'x_min = -11')
call ifile_append (ifile, 'x_max = 22')
call ifile_append (ifile, 'y_min = -33')
call ifile_append (ifile, 'y_max = 44')
call ifile_append (ifile, '$gmlcode_bg = "GML Code BG"')
call ifile_append (ifile, '$gmlcode_fg = "GML Code FG"')
call ifile_append (ifile, '$fill_options = "Fill Options"')
call ifile_append (ifile, '$draw_options = "Draw Options"')
call ifile_append (ifile, '$err_options = "Error Options"')
call ifile_append (ifile, '$symbol = "Symbol"')
call ifile_append (ifile, 'histogram foo (0,1)')
call ifile_append (ifile, 'plot bar')
call ifile_write (ifile, u)
write (u, "(A)")
write (u, "(A)") "* Parse file"
write (u, "(A)")
call parse_ifile (ifile, pn_root)
write (u, "(A)") "* Compile command list"
write (u, "(A)")
call command_list%compile (pn_root, global)
call command_list%write (u)
write (u, "(A)")
write (u, "(A)") "* Execute command list"
write (u, "(A)")
call command_list%execute (global)
write (u, "(A)") "* Display analysis store"
write (u, "(A)")
call analysis_write (u, verbose=.true.)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call ifile_final (ifile)
call analysis_final ()
call command_list%final ()
call global%final ()
call syntax_cmd_list_final ()
call syntax_model_file_final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: commands_24"
end subroutine commands_24
@ %def commands_24
@
\subsubsection{Local Environment}
Declare a local environment.
<<Commands: execute tests>>=
call test (commands_25, "commands_25", &
"local process environment", &
u, results)
<<Commands: test declarations>>=
public :: commands_25
<<Commands: tests>>=
subroutine commands_25 (u)
integer, intent(in) :: u
type(ifile_t) :: ifile
type(command_list_t), target :: command_list
type(rt_data_t), target :: global
type(parse_node_t), pointer :: pn_root
write (u, "(A)") "* Test output: commands_25"
write (u, "(A)") "* Purpose: declare local environment for process"
write (u, "(A)")
call syntax_model_file_init ()
call syntax_cmd_list_init ()
call global%global_init ()
call global%var_list%set_log (var_str ("?omega_openmp"), &
.false., is_known = .true.)
write (u, "(A)") "* Input file"
write (u, "(A)")
call ifile_append (ifile, 'library = "commands_25_lib"')
call ifile_append (ifile, 'model = "Test"')
call ifile_append (ifile, 'process commands_25_p1 = g, g => g, g &
&{ model = "QCD" }')
call ifile_write (ifile, u)
write (u, "(A)")
write (u, "(A)") "* Parse file"
write (u, "(A)")
call parse_ifile (ifile, pn_root)
write (u, "(A)") "* Compile command list"
write (u, "(A)")
call command_list%compile (pn_root, global)
call command_list%write (u)
write (u, "(A)")
write (u, "(A)") "* Execute command list"
write (u, "(A)")
call command_list%execute (global)
call global%write_libraries (u)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call ifile_final (ifile)
call command_list%final ()
call global%final ()
call syntax_cmd_list_final ()
call syntax_model_file_final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: commands_25"
end subroutine commands_25
@ %def commands_25
@
\subsubsection{Alternative Setups}
Declare a list of alternative setups.
<<Commands: execute tests>>=
call test (commands_26, "commands_26", &
"alternative setups", &
u, results)
<<Commands: test declarations>>=
public :: commands_26
<<Commands: tests>>=
subroutine commands_26 (u)
integer, intent(in) :: u
type(ifile_t) :: ifile
type(command_list_t), target :: command_list
type(rt_data_t), target :: global
type(parse_node_t), pointer :: pn_root
write (u, "(A)") "* Test output: commands_26"
write (u, "(A)") "* Purpose: declare alternative setups for simulation"
write (u, "(A)")
call syntax_cmd_list_init ()
call global%global_init ()
write (u, "(A)") "* Input file"
write (u, "(A)")
call ifile_append (ifile, 'int i = 0')
call ifile_append (ifile, 'alt_setup = ({ i = 1 }, { i = 2 })')
call ifile_write (ifile, u)
write (u, "(A)")
write (u, "(A)") "* Parse file"
write (u, "(A)")
call parse_ifile (ifile, pn_root)
write (u, "(A)") "* Compile command list"
write (u, "(A)")
call command_list%compile (pn_root, global)
call command_list%write (u)
write (u, "(A)")
write (u, "(A)") "* Execute command list"
write (u, "(A)")
call command_list%execute (global)
call global%write_expr (u)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call ifile_final (ifile)
call command_list%final ()
call global%final ()
call syntax_cmd_list_final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: commands_26"
end subroutine commands_26
@ %def commands_26
@
\subsubsection{Unstable Particle}
Define decay processes and declare a particle as unstable. Also check
the commands stable, polarized, unpolarized.
<<Commands: execute tests>>=
call test (commands_27, "commands_27", &
"unstable and polarized particles", &
u, results)
<<Commands: test declarations>>=
public :: commands_27
<<Commands: tests>>=
subroutine commands_27 (u)
integer, intent(in) :: u
type(ifile_t) :: ifile
type(command_list_t), target :: command_list
type(rt_data_t), target :: global
type(parse_node_t), pointer :: pn_root
type(prclib_entry_t), pointer :: lib
write (u, "(A)") "* Test output: commands_27"
write (u, "(A)") "* Purpose: modify particle properties"
write (u, "(A)")
call syntax_cmd_list_init ()
call syntax_model_file_init ()
call global%global_init ()
call global%var_list%set_string (var_str ("$method"), &
var_str ("unit_test"), is_known=.true.)
call global%var_list%set_string (var_str ("$phs_method"), &
var_str ("single"), is_known=.true.)
call global%var_list%set_string (var_str ("$integration_method"),&
var_str ("midpoint"), is_known=.true.)
call global%var_list%set_log (var_str ("?vis_history"),&
.false., is_known=.true.)
call global%var_list%set_log (var_str ("?integration_timer"),&
.false., is_known = .true.)
allocate (lib)
call lib%init (var_str ("commands_27_lib"))
call global%add_prclib (lib)
write (u, "(A)") "* Input file"
write (u, "(A)")
call ifile_append (ifile, 'model = "Test"')
call ifile_append (ifile, 'ff = 0.4')
call ifile_append (ifile, 'process d1 = s => f, fbar')
call ifile_append (ifile, 'unstable s (d1)')
call ifile_append (ifile, 'polarized f, fbar')
call ifile_write (ifile, u)
write (u, "(A)")
write (u, "(A)") "* Parse file"
write (u, "(A)")
call parse_ifile (ifile, pn_root)
write (u, "(A)") "* Compile command list"
write (u, "(A)")
call command_list%compile (pn_root, global)
call command_list%write (u)
write (u, "(A)")
write (u, "(A)") "* Execute command list"
write (u, "(A)")
call command_list%execute (global)
write (u, "(A)") "* Show model"
write (u, "(A)")
call global%model%write (u)
write (u, "(A)")
write (u, "(A)") "* Extra Input"
write (u, "(A)")
call ifile_final (ifile)
call ifile_append (ifile, '?diagonal_decay = true')
call ifile_append (ifile, 'unstable s (d1)')
call ifile_write (ifile, u)
write (u, "(A)")
write (u, "(A)") "* Parse file"
write (u, "(A)")
call parse_ifile (ifile, pn_root)
write (u, "(A)") "* Compile command list"
write (u, "(A)")
call command_list%final ()
call command_list%compile (pn_root, global)
call command_list%write (u)
write (u, "(A)")
write (u, "(A)") "* Execute command list"
write (u, "(A)")
call command_list%execute (global)
write (u, "(A)") "* Show model"
write (u, "(A)")
call global%model%write (u)
write (u, "(A)")
write (u, "(A)") "* Extra Input"
write (u, "(A)")
call ifile_final (ifile)
call ifile_append (ifile, '?isotropic_decay = true')
call ifile_append (ifile, 'unstable s (d1)')
call ifile_write (ifile, u)
write (u, "(A)")
write (u, "(A)") "* Parse file"
write (u, "(A)")
call parse_ifile (ifile, pn_root)
write (u, "(A)") "* Compile command list"
write (u, "(A)")
call command_list%final ()
call command_list%compile (pn_root, global)
call command_list%write (u)
write (u, "(A)")
write (u, "(A)") "* Execute command list"
write (u, "(A)")
call command_list%execute (global)
write (u, "(A)") "* Show model"
write (u, "(A)")
call global%model%write (u)
write (u, "(A)")
write (u, "(A)") "* Extra Input"
write (u, "(A)")
call ifile_final (ifile)
call ifile_append (ifile, 'stable s')
call ifile_append (ifile, 'unpolarized f')
call ifile_write (ifile, u)
write (u, "(A)")
write (u, "(A)") "* Parse file"
write (u, "(A)")
call parse_ifile (ifile, pn_root)
write (u, "(A)") "* Compile command list"
write (u, "(A)")
call command_list%final ()
call command_list%compile (pn_root, global)
call command_list%write (u)
write (u, "(A)")
write (u, "(A)") "* Execute command list"
write (u, "(A)")
call command_list%execute (global)
write (u, "(A)") "* Show model"
write (u, "(A)")
call global%model%write (u)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call ifile_final (ifile)
call command_list%final ()
call global%final ()
call syntax_model_file_init ()
call syntax_cmd_list_final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: commands_27"
end subroutine commands_27
@ %def commands_27
@
\subsubsection{Quit the program}
Quit the program.
<<Commands: execute tests>>=
call test (commands_28, "commands_28", &
"quit", &
u, results)
<<Commands: test declarations>>=
public :: commands_28
<<Commands: tests>>=
subroutine commands_28 (u)
integer, intent(in) :: u
type(ifile_t) :: ifile
type(command_list_t), target :: command_list
type(rt_data_t), target :: global
type(parse_node_t), pointer :: pn_root1, pn_root2
type(string_t), dimension(0) :: no_vars
write (u, "(A)") "* Test output: commands_28"
write (u, "(A)") "* Purpose: quit the program"
write (u, "(A)")
write (u, "(A)") "* Initialization"
write (u, "(A)")
call syntax_cmd_list_init ()
call global%global_init ()
write (u, "(A)") "* Input file: quit without code"
write (u, "(A)")
call ifile_append (ifile, 'quit')
call ifile_write (ifile, u)
write (u, "(A)")
write (u, "(A)") "* Parse file"
write (u, "(A)")
call parse_ifile (ifile, pn_root1, u)
write (u, "(A)")
write (u, "(A)") "* Compile command list"
write (u, "(A)")
call command_list%compile (pn_root1, global)
call command_list%write (u)
write (u, "(A)")
write (u, "(A)") "* Execute command list"
write (u, "(A)")
call command_list%execute (global)
call global%write (u, vars = no_vars)
write (u, "(A)")
write (u, "(A)") "* Input file: quit with code"
write (u, "(A)")
call ifile_final (ifile)
call command_list%final ()
call ifile_append (ifile, 'quit ( 3 + 4 )')
call ifile_write (ifile, u)
write (u, "(A)")
write (u, "(A)") "* Parse file"
write (u, "(A)")
call parse_ifile (ifile, pn_root2, u)
write (u, "(A)")
write (u, "(A)") "* Compile command list"
write (u, "(A)")
call command_list%compile (pn_root2, global)
call command_list%write (u)
write (u, "(A)")
write (u, "(A)") "* Execute command list"
write (u, "(A)")
call command_list%execute (global)
call global%write (u, vars = no_vars)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call ifile_final (ifile)
call command_list%final ()
call global%final ()
call syntax_cmd_list_final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: commands_28"
end subroutine commands_28
@ %def commands_28
@
\subsubsection{SLHA interface}
Testing commands steering the SLHA interface.
<<Commands: execute tests>>=
call test (commands_29, "commands_29", &
"SLHA interface", &
u, results)
<<Commands: test declarations>>=
public :: commands_29
<<Commands: tests>>=
subroutine commands_29 (u)
integer, intent(in) :: u
type(ifile_t) :: ifile
type(command_list_t), target :: command_list
type(rt_data_t), target :: global
type(var_list_t), pointer :: model_vars
type(parse_node_t), pointer :: pn_root
write (u, "(A)") "* Test output: commands_29"
write (u, "(A)") "* Purpose: test SLHA interface"
write (u, "(A)")
write (u, "(A)") "* Initialization"
write (u, "(A)")
call syntax_cmd_list_init ()
call syntax_model_file_init ()
call syntax_slha_init ()
call global%global_init ()
write (u, "(A)") "* Model MSSM, read SLHA file"
write (u, "(A)")
call ifile_append (ifile, 'model = "MSSM"')
call ifile_append (ifile, '?slha_read_decays = true')
call ifile_append (ifile, 'read_slha ("sps1ap_decays.slha")')
call ifile_write (ifile, u)
write (u, "(A)")
write (u, "(A)") "* Parse file"
write (u, "(A)")
call parse_ifile (ifile, pn_root, u)
write (u, "(A)")
write (u, "(A)") "* Compile command list"
write (u, "(A)")
call command_list%compile (pn_root, global)
call command_list%write (u)
write (u, "(A)")
write (u, "(A)") "* Model MSSM, default values:"
write (u, "(A)")
call global%model%write (u, verbose = .false., &
show_vertices = .false., show_particles = .false.)
write (u, "(A)")
write (u, "(A)") "* Selected global variables"
write (u, "(A)")
model_vars => global%model%get_var_list_ptr ()
call model_vars%write_var (var_str ("mch1"), u)
call model_vars%write_var (var_str ("wch1"), u)
write (u, "(A)")
write (u, "(A)") "* Execute command list"
write (u, "(A)")
call command_list%execute (global)
write (u, "(A)") "* Model MSSM, values from SLHA file"
write (u, "(A)")
call global%model%write (u, verbose = .false., &
show_vertices = .false., show_particles = .false.)
write (u, "(A)")
write (u, "(A)") "* Selected global variables"
write (u, "(A)")
model_vars => global%model%get_var_list_ptr ()
call model_vars%write_var (var_str ("mch1"), u)
call model_vars%write_var (var_str ("wch1"), u)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call ifile_final (ifile)
call command_list%final ()
call global%final ()
call syntax_slha_final ()
call syntax_model_file_final ()
call syntax_cmd_list_final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: commands_29"
end subroutine commands_29
@ %def commands_29
@
\subsubsection{Expressions for scales}
Declare a scale, factorization scale or factorization scale expression.
<<Commands: execute tests>>=
call test (commands_30, "commands_30", &
"scales", &
u, results)
<<Commands: test declarations>>=
public :: commands_30
<<Commands: tests>>=
subroutine commands_30 (u)
integer, intent(in) :: u
type(ifile_t) :: ifile
type(command_list_t), target :: command_list
type(rt_data_t), target :: global
type(parse_node_t), pointer :: pn_root
write (u, "(A)") "* Test output: commands_30"
write (u, "(A)") "* Purpose: define scales"
write (u, "(A)")
write (u, "(A)") "* Initialization"
write (u, "(A)")
call syntax_cmd_list_init ()
call global%global_init ()
write (u, "(A)") "* Input file"
write (u, "(A)")
call ifile_append (ifile, 'scale = 200 GeV')
call ifile_append (ifile, &
'factorization_scale = eval Pt [particle]')
call ifile_append (ifile, &
'renormalization_scale = eval E [particle]')
call ifile_write (ifile, u)
write (u, "(A)")
write (u, "(A)") "* Parse file"
write (u, "(A)")
call parse_ifile (ifile, pn_root, u)
write (u, "(A)")
write (u, "(A)") "* Compile command list"
write (u, "(A)")
call command_list%compile (pn_root, global)
call command_list%write (u)
write (u, "(A)")
write (u, "(A)") "* Execute command list"
write (u, "(A)")
call command_list%execute (global)
call global%write_expr (u)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call ifile_final (ifile)
call command_list%final ()
call global%final ()
call syntax_cmd_list_final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: commands_30"
end subroutine commands_30
@ %def commands_30
@
\subsubsection{Weight and reweight expressions}
Declare an expression for event weights and reweighting.
<<Commands: execute tests>>=
call test (commands_31, "commands_31", &
"event weights/reweighting", &
u, results)
<<Commands: test declarations>>=
public :: commands_31
<<Commands: tests>>=
subroutine commands_31 (u)
integer, intent(in) :: u
type(ifile_t) :: ifile
type(command_list_t), target :: command_list
type(rt_data_t), target :: global
type(parse_node_t), pointer :: pn_root
write (u, "(A)") "* Test output: commands_31"
write (u, "(A)") "* Purpose: define weight/reweight"
write (u, "(A)")
write (u, "(A)") "* Initialization"
write (u, "(A)")
call syntax_cmd_list_init ()
call global%global_init ()
write (u, "(A)") "* Input file"
write (u, "(A)")
call ifile_append (ifile, 'weight = eval Pz [particle]')
call ifile_append (ifile, 'reweight = eval M2 [particle]')
call ifile_write (ifile, u)
write (u, "(A)")
write (u, "(A)") "* Parse file"
write (u, "(A)")
call parse_ifile (ifile, pn_root, u)
write (u, "(A)")
write (u, "(A)") "* Compile command list"
write (u, "(A)")
call command_list%compile (pn_root, global)
call command_list%write (u)
write (u, "(A)")
write (u, "(A)") "* Execute command list"
write (u, "(A)")
call command_list%execute (global)
call global%write_expr (u)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call ifile_final (ifile)
call command_list%final ()
call global%final ()
call syntax_cmd_list_final ()
call syntax_model_file_final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: commands_31"
end subroutine commands_31
@ %def commands_31
@
\subsubsection{Selecting events}
Declare an expression for selecting events in an analysis.
<<Commands: execute tests>>=
call test (commands_32, "commands_32", &
"event selection", &
u, results)
<<Commands: test declarations>>=
public :: commands_32
<<Commands: tests>>=
subroutine commands_32 (u)
integer, intent(in) :: u
type(ifile_t) :: ifile
type(command_list_t), target :: command_list
type(rt_data_t), target :: global
type(parse_node_t), pointer :: pn_root
write (u, "(A)") "* Test output: commands_32"
write (u, "(A)") "* Purpose: define selection"
write (u, "(A)")
write (u, "(A)") "* Initialization"
write (u, "(A)")
call syntax_cmd_list_init ()
call global%global_init ()
write (u, "(A)") "* Input file"
write (u, "(A)")
call ifile_append (ifile, 'selection = any PDG == 13 [particle]')
call ifile_write (ifile, u)
write (u, "(A)")
write (u, "(A)") "* Parse file"
write (u, "(A)")
call parse_ifile (ifile, pn_root, u)
write (u, "(A)")
write (u, "(A)") "* Compile command list"
write (u, "(A)")
call command_list%compile (pn_root, global)
call command_list%write (u)
write (u, "(A)")
write (u, "(A)") "* Execute command list"
write (u, "(A)")
call command_list%execute (global)
call global%write_expr (u)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call ifile_final (ifile)
call command_list%final ()
call global%final ()
call syntax_cmd_list_final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: commands_32"
end subroutine commands_32
@ %def commands_32
@
\subsubsection{Executing shell commands}
Execute a shell command.
<<Commands: execute tests>>=
call test (commands_33, "commands_33", &
"execute shell command", &
u, results)
<<Commands: test declarations>>=
public :: commands_33
<<Commands: tests>>=
subroutine commands_33 (u)
integer, intent(in) :: u
type(ifile_t) :: ifile
type(command_list_t), target :: command_list
type(rt_data_t), target :: global
type(parse_node_t), pointer :: pn_root
integer :: u_file, iostat
character(3) :: buffer
write (u, "(A)") "* Test output: commands_33"
write (u, "(A)") "* Purpose: execute shell command"
write (u, "(A)")
write (u, "(A)") "* Initialization"
write (u, "(A)")
call syntax_cmd_list_init ()
call global%global_init ()
write (u, "(A)") "* Input file"
write (u, "(A)")
call ifile_append (ifile, 'exec ("echo foo >> bar")')
call ifile_write (ifile, u)
write (u, "(A)")
write (u, "(A)") "* Parse file"
write (u, "(A)")
call parse_ifile (ifile, pn_root, u)
write (u, "(A)")
write (u, "(A)") "* Compile command list"
write (u, "(A)")
call command_list%compile (pn_root, global)
call command_list%write (u)
write (u, "(A)")
write (u, "(A)") "* Execute command list"
write (u, "(A)")
call command_list%execute (global)
u_file = free_unit ()
open (u_file, file = "bar", &
action = "read", status = "old")
do
read (u_file, "(A)", iostat = iostat) buffer
if (iostat /= 0) exit
end do
write (u, "(A,A)") "should be 'foo': ", trim (buffer)
close (u_file)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call ifile_final (ifile)
call command_list%final ()
call global%final ()
call syntax_cmd_list_final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: commands_33"
end subroutine commands_33
@ %def commands_33
@
\subsubsection{Callback}
Instead of an explicit write, use the callback feature to write the
analysis file during event generation. We generate 4 events and
arrange that the callback is executed while writing the 3rd event.
<<Commands: execute tests>>=
call test (commands_34, "commands_34", &
"analysis via callback", &
u, results)
<<Commands: test declarations>>=
public :: commands_34
<<Commands: tests>>=
subroutine commands_34 (u)
integer, intent(in) :: u
type(ifile_t) :: ifile
type(command_list_t), target :: command_list
type(rt_data_t), target :: global
type(parse_node_t), pointer :: pn_root
type(prclib_entry_t), pointer :: lib
type(event_callback_34_t) :: event_callback
write (u, "(A)") "* Test output: commands_34"
write (u, "(A)") "* Purpose: write analysis data"
write (u, "(A)")
write (u, "(A)") "* Initialization: create observable"
write (u, "(A)")
call syntax_cmd_list_init ()
call global%global_init ()
call syntax_model_file_init ()
call global%global_init ()
call global%init_fallback_model &
(var_str ("SM_hadrons"), var_str ("SM_hadrons.mdl"))
call global%var_list%set_string (var_str ("$method"), &
var_str ("unit_test"), is_known=.true.)
call global%var_list%set_string (var_str ("$phs_method"), &
var_str ("single"), is_known=.true.)
call global%var_list%set_string (var_str ("$integration_method"),&
var_str ("midpoint"), is_known=.true.)
call global%var_list%set_real (var_str ("sqrts"), &
1000._default, is_known=.true.)
call global%var_list%set_log (var_str ("?vis_history"),&
.false., is_known=.true.)
call global%var_list%set_log (var_str ("?integration_timer"),&
.false., is_known = .true.)
allocate (lib)
call lib%init (var_str ("lib_cmd34"))
call global%add_prclib (lib)
write (u, "(A)") "* Prepare callback for writing analysis to I/O unit"
write (u, "(A)")
event_callback%u = u
call global%set_event_callback (event_callback)
write (u, "(A)") "* Input file"
write (u, "(A)")
call ifile_append (ifile, 'model = "Test"')
call ifile_append (ifile, 'process commands_34_p = s, s => s, s')
call ifile_append (ifile, 'compile')
call ifile_append (ifile, 'iterations = 1:1000')
call ifile_append (ifile, 'integrate (commands_34_p)')
call ifile_append (ifile, 'observable sq')
call ifile_append (ifile, 'analysis = record sq (sqrts)')
call ifile_append (ifile, 'n_events = 4')
call ifile_append (ifile, 'event_callback_interval = 3')
call ifile_append (ifile, 'simulate (commands_34_p)')
call ifile_write (ifile, u)
write (u, "(A)")
write (u, "(A)") "* Parse file"
write (u, "(A)")
call parse_ifile (ifile, pn_root)
write (u, "(A)") "* Compile command list"
write (u, "(A)")
call command_list%compile (pn_root, global)
call command_list%write (u)
write (u, "(A)")
write (u, "(A)") "* Execute command list"
write (u, "(A)")
call command_list%execute (global)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call ifile_final (ifile)
call analysis_final ()
call command_list%final ()
call global%final ()
call syntax_cmd_list_final ()
call syntax_model_file_final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: commands_34"
end subroutine commands_34
@ %def commands_34
@ For this test, we invent a callback object which simply writes the
analysis file, using the standard call for this. Here we rely on the
fact that the analysis data are stored as a global entity, otherwise
we would have to access them via the event object.
<<Commands: test auxiliary types>>=
type, extends (event_callback_t) :: event_callback_34_t
private
integer :: u = 0
contains
procedure :: write => event_callback_34_write
procedure :: proc => event_callback_34
end type event_callback_34_t
@ %def event_callback_t
@ The output routine is unused. The actual callback should write the
analysis data to the output unit that we have injected into the
callback object.
<<Commands: test auxiliary>>=
subroutine event_callback_34_write (event_callback, unit)
class(event_callback_34_t), intent(in) :: event_callback
integer, intent(in), optional :: unit
end subroutine event_callback_34_write
subroutine event_callback_34 (event_callback, i, event)
class(event_callback_34_t), intent(in) :: event_callback
integer(i64), intent(in) :: i
class(generic_event_t), intent(in) :: event
call analysis_write (event_callback%u)
end subroutine event_callback_34
@ %def event_callback_34_write
@ %def event_callback_34
@
\clearpage
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{Toplevel module WHIZARD}
<<[[whizard.f90]]>>=
<<File header>>
module whizard
use io_units
<<Use strings>>
use system_defs, only: VERSION_STRING
use system_defs, only: EOF, BACKSLASH
use diagnostics
use os_interface
use ifiles
use lexers
use parser
use eval_trees
use models
use phs_forests
use prclib_stacks
use slha_interface
use blha_config
use rt_data
use commands
<<Standard module head>>
<<WHIZARD: public>>
<<WHIZARD: types>>
<<WHIZARD: variables>>
save
contains
<<WHIZARD: procedures>>
end module whizard
@ %def whizard
@
\subsection{Options}
Here we introduce a wrapper that holds various user options, so they
can transparently be passed from the main program to the [[whizard]]
object. Most parameters are used for initializing the [[global]]
state.
<<WHIZARD: public>>=
public :: whizard_options_t
<<WHIZARD: types>>=
type :: whizard_options_t
type(string_t) :: job_id
type(string_t), dimension(:), allocatable :: pack_args
type(string_t), dimension(:), allocatable :: unpack_args
type(string_t) :: preload_model
type(string_t) :: default_lib
type(string_t) :: preload_libraries
logical :: rebuild_library = .false.
logical :: recompile_library = .false.
logical :: rebuild_phs = .false.
logical :: rebuild_grids = .false.
logical :: rebuild_events = .false.
end type whizard_options_t
@ %def whizard_options_t
@
\subsection{Parse tree stack}
We collect all parse trees that we generate in the [[whizard]] object. To
this end, we create a stack of parse trees. They must not be finalized before
the [[global]] object is finalized, because items such as a cut definition may
contain references to the parse tree from which they were generated.
<<WHIZARD: types>>=
type, extends (parse_tree_t) :: pt_entry_t
type(pt_entry_t), pointer :: previous => null ()
end type pt_entry_t
@ %def pt_entry_t
@ This is the stack. Since we always prepend, we just need the [[last]]
pointer.
<<WHIZARD: types>>=
type :: pt_stack_t
type(pt_entry_t), pointer :: last => null ()
contains
<<WHIZARD: pt stack: TBP>>
end type pt_stack_t
@ %def pt_stack_t
@ The finalizer is called at the very end.
<<WHIZARD: pt stack: TBP>>=
procedure :: final => pt_stack_final
<<WHIZARD: procedures>>=
subroutine pt_stack_final (pt_stack)
class(pt_stack_t), intent(inout) :: pt_stack
type(pt_entry_t), pointer :: current
do while (associated (pt_stack%last))
current => pt_stack%last
pt_stack%last => current%previous
call parse_tree_final (current%parse_tree_t)
deallocate (current)
end do
end subroutine pt_stack_final
@ %def pt_stack_final
@ Create and push a new entry, keeping the previous ones.
<<WHIZARD: pt stack: TBP>>=
procedure :: push => pt_stack_push
<<WHIZARD: procedures>>=
subroutine pt_stack_push (pt_stack, parse_tree)
class(pt_stack_t), intent(inout) :: pt_stack
type(parse_tree_t), intent(out), pointer :: parse_tree
type(pt_entry_t), pointer :: current
allocate (current)
parse_tree => current%parse_tree_t
current%previous => pt_stack%last
pt_stack%last => current
end subroutine pt_stack_push
@ %def pt_stack_push
@
\subsection{The [[whizard]] object}
An object of type [[whizard_t]] is the top-level wrapper for a
\whizard\ instance. The object holds various default
settings and the current state of the generator, the [[global]] object
of type [[rt_data_t]]. This object contains, for instance, the list
of variables and the process libraries.
Since components of the [[global]] subobject are frequently used as
targets, the [[whizard]] object should also consistently carry the
[[target]] attribute.
The various self-tests do no not use this object. They initialize
only specific subsets of the system, according to their needs.
Note: we intend to allow several concurrent instances. In the current
implementation, there are still a few obstacles to this: the model
library and the syntax tables are global variables, and the error
handling uses global state. This should be improved.
<<WHIZARD: public>>=
public :: whizard_t
<<WHIZARD: types>>=
type :: whizard_t
type(whizard_options_t) :: options
type(rt_data_t) :: global
type(pt_stack_t) :: pt_stack
contains
<<WHIZARD: whizard: TBP>>
end type whizard_t
@ %def whizard_t
@
\subsection{Initialization and finalization}
<<WHIZARD: whizard: TBP>>=
procedure :: init => whizard_init
<<WHIZARD: procedures>>=
subroutine whizard_init (whizard, options, paths, logfile)
class(whizard_t), intent(out), target :: whizard
type(whizard_options_t), intent(in) :: options
type(paths_t), intent(in), optional :: paths
type(string_t), intent(in), optional :: logfile
call init_syntax_tables ()
whizard%options = options
call whizard%global%global_init (paths, logfile)
call whizard%init_job_id ()
call whizard%init_rebuild_flags ()
call whizard%unpack_files ()
call whizard%preload_model ()
call whizard%preload_library ()
call whizard%global%init_fallback_model &
(var_str ("SM_hadrons"), var_str ("SM_hadrons.mdl"))
end subroutine whizard_init
@ %def whizard_init
@ Apart from the global data which have been initialized above, the
process and model lists need to be finalized.
<<WHIZARD: whizard: TBP>>=
procedure :: final => whizard_final
<<WHIZARD: procedures>>=
subroutine whizard_final (whizard)
class(whizard_t), intent(inout), target :: whizard
call whizard%global%final ()
call whizard%pt_stack%final ()
call whizard%pack_files ()
call final_syntax_tables ()
end subroutine whizard_final
@ %def whizard_final
@ Set the job ID, if nonempty. If the ID string is empty, the value remains
undefined.
<<WHIZARD: whizard: TBP>>=
procedure :: init_job_id => whizard_init_job_id
<<WHIZARD: procedures>>=
subroutine whizard_init_job_id (whizard)
class(whizard_t), intent(inout), target :: whizard
associate (var_list => whizard%global%var_list, options => whizard%options)
if (options%job_id /= "") then
call var_list%set_string (var_str ("$job_id"), &
options%job_id, is_known=.true.)
end if
end associate
end subroutine whizard_init_job_id
@ %def whizard_init_job_id
@
Set the rebuild flags. They can be specified on the command line and
set the initial value for the associated logical variables.
<<WHIZARD: whizard: TBP>>=
procedure :: init_rebuild_flags => whizard_init_rebuild_flags
<<WHIZARD: procedures>>=
subroutine whizard_init_rebuild_flags (whizard)
class(whizard_t), intent(inout), target :: whizard
associate (var_list => whizard%global%var_list, options => whizard%options)
call var_list%append_log (var_str ("?rebuild_library"), &
options%rebuild_library, intrinsic=.true.)
call var_list%append_log (var_str ("?recompile_library"), &
options%recompile_library, intrinsic=.true.)
call var_list%append_log (var_str ("?rebuild_phase_space"), &
options%rebuild_phs, intrinsic=.true.)
call var_list%append_log (var_str ("?rebuild_grids"), &
options%rebuild_grids, intrinsic=.true.)
call var_list%append_log (var_str ("?rebuild_events"), &
options%rebuild_events, intrinsic=.true.)
end associate
end subroutine whizard_init_rebuild_flags
@ %def whizard_init_rebuild_flags
@
Pack/unpack files in the working directory, if requested.
<<WHIZARD: whizard: TBP>>=
procedure :: pack_files => whizard_pack_files
procedure :: unpack_files => whizard_unpack_files
<<WHIZARD: procedures>>=
subroutine whizard_pack_files (whizard)
class(whizard_t), intent(in), target :: whizard
logical :: exist
integer :: i
type(string_t) :: file
if (allocated (whizard%options%pack_args)) then
do i = 1, size (whizard%options%pack_args)
file = whizard%options%pack_args(i)
call msg_message ("Packing file/dir '" // char (file) // "'")
exist = os_file_exist (file) .or. os_dir_exist (file)
if (exist) then
call os_pack_file (whizard%options%pack_args(i), &
whizard%global%os_data)
else
call msg_error ("File/dir '" // char (file) // "' not found")
end if
end do
end if
end subroutine whizard_pack_files
subroutine whizard_unpack_files (whizard)
class(whizard_t), intent(in), target :: whizard
logical :: exist
integer :: i
type(string_t) :: file
if (allocated (whizard%options%unpack_args)) then
do i = 1, size (whizard%options%unpack_args)
file = whizard%options%unpack_args(i)
call msg_message ("Unpacking file '" // char (file) // "'")
exist = os_file_exist (file)
if (exist) then
call os_unpack_file (whizard%options%unpack_args(i), &
whizard%global%os_data)
else
call msg_error ("File '" // char (file) // "' not found")
end if
end do
end if
end subroutine whizard_unpack_files
@ %def whizard_pack_files
@ %def whizard_unpack_files
@
This procedure preloads a model, if a model name is given.
<<WHIZARD: whizard: TBP>>=
procedure :: preload_model => whizard_preload_model
<<WHIZARD: procedures>>=
subroutine whizard_preload_model (whizard)
class(whizard_t), intent(inout), target :: whizard
type(string_t) :: model_name
model_name = whizard%options%preload_model
if (model_name /= "") then
call whizard%global%read_model (model_name, whizard%global%preload_model)
whizard%global%model => whizard%global%preload_model
if (associated (whizard%global%model)) then
call whizard%global%model%link_var_list (whizard%global%var_list)
call whizard%global%var_list%set_string (var_str ("$model_name"), &
model_name, is_known = .true.)
call msg_message ("Preloaded model: " &
// char (model_name))
else
call msg_fatal ("Preloading model " // char (model_name) &
// " failed")
end if
else
call msg_message ("No model preloaded")
end if
end subroutine whizard_preload_model
@ %def whizard_preload_model
@
This procedure preloads a library, if a library name is given.
Note: This version just opens a new library with that name. It does not load
(yet) an existing library on file, as previous \whizard\ versions would do.
<<WHIZARD: whizard: TBP>>=
procedure :: preload_library => whizard_preload_library
<<WHIZARD: procedures>>=
subroutine whizard_preload_library (whizard)
class(whizard_t), intent(inout), target :: whizard
type(string_t) :: library_name, libs
type(string_t), dimension(:), allocatable :: libname_static
type(prclib_entry_t), pointer :: lib_entry
integer :: i
call get_prclib_static (libname_static)
do i = 1, size (libname_static)
allocate (lib_entry)
call lib_entry%init_static (libname_static(i))
call whizard%global%add_prclib (lib_entry)
end do
libs = adjustl (whizard%options%preload_libraries)
if (libs == "" .and. whizard%options%default_lib /= "") then
allocate (lib_entry)
call lib_entry%init (whizard%options%default_lib)
call whizard%global%add_prclib (lib_entry)
call msg_message ("Preloaded library: " // &
char (whizard%options%default_lib))
end if
SCAN_LIBS: do while (libs /= "")
call split (libs, library_name, " ")
if (library_name /= "") then
allocate (lib_entry)
call lib_entry%init (library_name)
call whizard%global%add_prclib (lib_entry)
call msg_message ("Preloaded library: " // char (library_name))
end if
end do SCAN_LIBS
end subroutine whizard_preload_library
@ %def whizard_preload_library
@
\subsection{Initialization and finalization: syntax tables}
Initialize/finalize the syntax tables used by WHIZARD. These are effectively
singleton objects. We introduce a module variable that tracks the
initialization status.
Without syntax tables, essentially nothing will work. Any initializer has to
call this.
<<WHIZARD: variables>>=
logical :: syntax_tables_exist = .false.
@ %def syntax_tables_exist
@
<<WHIZARD: public>>=
public :: init_syntax_tables
public :: final_syntax_tables
<<WHIZARD: procedures>>=
subroutine init_syntax_tables ()
if (.not. syntax_tables_exist) then
call syntax_model_file_init ()
call syntax_phs_forest_init ()
call syntax_pexpr_init ()
call syntax_slha_init ()
call syntax_cmd_list_init ()
syntax_tables_exist = .true.
end if
end subroutine init_syntax_tables
subroutine final_syntax_tables ()
if (syntax_tables_exist) then
call syntax_model_file_final ()
call syntax_phs_forest_final ()
call syntax_pexpr_final ()
call syntax_slha_final ()
call syntax_cmd_list_final ()
syntax_tables_exist = .false.
end if
end subroutine final_syntax_tables
@ %def init_syntax_tables
@ %def final_syntax_tables
@ Write the syntax tables to external files.
<<WHIZARD: public>>=
public :: write_syntax_tables
<<WHIZARD: procedures>>=
subroutine write_syntax_tables ()
integer :: unit
character(*), parameter :: file_model = "whizard.model_file.syntax"
character(*), parameter :: file_phs = "whizard.phase_space_file.syntax"
character(*), parameter :: file_pexpr = "whizard.prt_expressions.syntax"
character(*), parameter :: file_slha = "whizard.slha.syntax"
character(*), parameter :: file_sindarin = "whizard.sindarin.syntax"
if (.not. syntax_tables_exist) call init_syntax_tables ()
unit = free_unit ()
print *, "Writing file '" // file_model // "'"
open (unit=unit, file=file_model, status="replace", action="write")
write (unit, "(A)") VERSION_STRING
write (unit, "(A)") "Syntax definition file: " // file_model
call syntax_model_file_write (unit)
close (unit)
print *, "Writing file '" // file_phs // "'"
open (unit=unit, file=file_phs, status="replace", action="write")
write (unit, "(A)") VERSION_STRING
write (unit, "(A)") "Syntax definition file: " // file_phs
call syntax_phs_forest_write (unit)
close (unit)
print *, "Writing file '" // file_pexpr // "'"
open (unit=unit, file=file_pexpr, status="replace", action="write")
write (unit, "(A)") VERSION_STRING
write (unit, "(A)") "Syntax definition file: " // file_pexpr
call syntax_pexpr_write (unit)
close (unit)
print *, "Writing file '" // file_slha // "'"
open (unit=unit, file=file_slha, status="replace", action="write")
write (unit, "(A)") VERSION_STRING
write (unit, "(A)") "Syntax definition file: " // file_slha
call syntax_slha_write (unit)
close (unit)
print *, "Writing file '" // file_sindarin // "'"
open (unit=unit, file=file_sindarin, status="replace", action="write")
write (unit, "(A)") VERSION_STRING
write (unit, "(A)") "Syntax definition file: " // file_sindarin
call syntax_cmd_list_write (unit)
close (unit)
end subroutine write_syntax_tables
@ %def write_syntax_tables
@
\subsection{Execute command lists}
Process commands given on the command line, stored as an [[ifile]]. The whole
input is read, compiled and executed as a whole.
<<WHIZARD: whizard: TBP>>=
procedure :: process_ifile => whizard_process_ifile
<<WHIZARD: procedures>>=
subroutine whizard_process_ifile (whizard, ifile, quit, quit_code)
class(whizard_t), intent(inout), target :: whizard
type(ifile_t), intent(in) :: ifile
logical, intent(out) :: quit
integer, intent(out) :: quit_code
type(lexer_t), target :: lexer
type(stream_t), target :: stream
call msg_message ("Reading commands given on the command line")
call lexer_init_cmd_list (lexer)
call stream_init (stream, ifile)
call whizard%process_stream (stream, lexer, quit, quit_code)
call stream_final (stream)
call lexer_final (lexer)
end subroutine whizard_process_ifile
@ %def whizard_process_ifile
@ Process standard input as a command list. The whole input is read,
compiled and executed as a whole.
<<WHIZARD: whizard: TBP>>=
procedure :: process_stdin => whizard_process_stdin
<<WHIZARD: procedures>>=
subroutine whizard_process_stdin (whizard, quit, quit_code)
class(whizard_t), intent(inout), target :: whizard
logical, intent(out) :: quit
integer, intent(out) :: quit_code
type(lexer_t), target :: lexer
type(stream_t), target :: stream
call msg_message ("Reading commands from standard input")
call lexer_init_cmd_list (lexer)
call stream_init (stream, 5)
call whizard%process_stream (stream, lexer, quit, quit_code)
call stream_final (stream)
call lexer_final (lexer)
end subroutine whizard_process_stdin
@ %def whizard_process_stdin
@ Process a file as a command list.
<<WHIZARD: whizard: TBP>>=
procedure :: process_file => whizard_process_file
<<WHIZARD: procedures>>=
subroutine whizard_process_file (whizard, file, quit, quit_code)
class(whizard_t), intent(inout), target :: whizard
type(string_t), intent(in) :: file
logical, intent(out) :: quit
integer, intent(out) :: quit_code
type(lexer_t), target :: lexer
type(stream_t), target :: stream
logical :: exist
call msg_message ("Reading commands from file '" // char (file) // "'")
inquire (file=char(file), exist=exist)
if (exist) then
call lexer_init_cmd_list (lexer)
call stream_init (stream, char (file))
call whizard%process_stream (stream, lexer, quit, quit_code)
call stream_final (stream)
call lexer_final (lexer)
else
call msg_error ("File '" // char (file) // "' not found")
end if
end subroutine whizard_process_file
@ %def whizard_process_file
@
<<WHIZARD: whizard: TBP>>=
procedure :: process_stream => whizard_process_stream
<<WHIZARD: procedures>>=
subroutine whizard_process_stream (whizard, stream, lexer, quit, quit_code)
class(whizard_t), intent(inout), target :: whizard
type(stream_t), intent(inout), target :: stream
type(lexer_t), intent(inout), target :: lexer
logical, intent(out) :: quit
integer, intent(out) :: quit_code
type(parse_tree_t), pointer :: parse_tree
type(command_list_t), target :: command_list
call lexer_assign_stream (lexer, stream)
call whizard%pt_stack%push (parse_tree)
call parse_tree_init (parse_tree, syntax_cmd_list, lexer)
if (associated (parse_tree%get_root_ptr ())) then
whizard%global%lexer => lexer
call command_list%compile (parse_tree%get_root_ptr (), &
whizard%global)
end if
call whizard%global%activate ()
call command_list%execute (whizard%global)
call command_list%final ()
quit = whizard%global%quit
quit_code = whizard%global%quit_code
end subroutine whizard_process_stream
@ %def whizard_process_stream
@
\subsection{The WHIZARD shell}
This procedure implements interactive mode. One line is processed at
a time.
<<WHIZARD: whizard: TBP>>=
procedure :: shell => whizard_shell
<<WHIZARD: procedures>>=
subroutine whizard_shell (whizard, quit_code)
class(whizard_t), intent(inout), target :: whizard
integer, intent(out) :: quit_code
type(lexer_t), target :: lexer
type(stream_t), target :: stream
type(string_t) :: prompt1
type(string_t) :: prompt2
type(string_t) :: input
type(string_t) :: extra
integer :: last
integer :: iostat
logical :: mask_tmp
logical :: quit
call msg_message ("Launching interactive shell")
call lexer_init_cmd_list (lexer)
prompt1 = "whish? "
prompt2 = " > "
COMMAND_LOOP: do
call put (6, prompt1)
call get (5, input, iostat=iostat)
if (iostat > 0 .or. iostat == EOF) exit COMMAND_LOOP
CONTINUE_INPUT: do
last = len_trim (input)
if (extract (input, last, last) /= BACKSLASH) exit CONTINUE_INPUT
call put (6, prompt2)
call get (5, extra, iostat=iostat)
if (iostat > 0) exit COMMAND_LOOP
input = replace (input, last, extra)
end do CONTINUE_INPUT
call stream_init (stream, input)
mask_tmp = mask_fatal_errors
mask_fatal_errors = .true.
call whizard%process_stream (stream, lexer, quit, quit_code)
msg_count = 0
mask_fatal_errors = mask_tmp
call stream_final (stream)
if (quit) exit COMMAND_LOOP
end do COMMAND_LOOP
print *
call lexer_final (lexer)
end subroutine whizard_shell
@ %def whizard_shell
@
\clearpage
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{Query Feature Support}
This module accesses the various optional features (modules) that
WHIZARD can support and repors on their availability.
<<[[features.f90]]>>=
module features
use string_utils, only: lower_case
use system_dependencies, only: WHIZARD_VERSION
<<Features: dependencies>>
<<Standard module head>>
<<Features: public>>
contains
<<Features: procedures>>
end module features
@ %def features
@
\subsection{Output}
<<Features: public>>=
public :: print_features
<<Features: procedures>>=
subroutine print_features ()
print "(A)", "WHIZARD " // WHIZARD_VERSION
print "(A)", "Build configuration:"
<<Features: config>>
print "(A)", "Optional features available in this build:"
<<Features: print>>
end subroutine print_features
@ %def print_features
@
\subsection{Query function}
<<Features: procedures>>=
subroutine check (feature, recognized, result, help)
character(*), intent(in) :: feature
logical, intent(out) :: recognized
character(*), intent(out) :: result, help
recognized = .true.
result = "no"
select case (lower_case (trim (feature)))
<<Features: cases>>
case default
recognized = .false.
end select
end subroutine check
@ %def check
@ Print this result:
<<Features: procedures>>=
subroutine print_check (feature)
character(*), intent(in) :: feature
character(16) :: f
logical :: recognized
character(10) :: result
character(48) :: help
call check (feature, recognized, result, help)
if (.not. recognized) then
result = "unknown"
help = ""
end if
f = feature
print "(2x,A,1x,A,'(',A,')')", f, result, trim (help)
end subroutine print_check
@ %def print_check
@
\subsection{Basic configuration}
<<Features: config>>=
call print_check ("precision")
<<Features: dependencies>>=
use kinds, only: default
<<Features: cases>>=
case ("precision")
write (result, "(I0)") precision (1._default)
help = "significant decimals of real/complex numbers"
@
\subsection{Optional features case by case}
<<Features: print>>=
call print_check ("OpenMP")
<<Features: dependencies>>=
use system_dependencies, only: openmp_is_active
<<Features: cases>>=
case ("openmp")
if (openmp_is_active ()) then
result = "yes"
end if
help = "OpenMP parallel execution"
@
<<Features: print>>=
call print_check ("GoSam")
<<Features: dependencies>>=
use system_dependencies, only: GOSAM_AVAILABLE
<<Features: cases>>=
case ("gosam")
if (GOSAM_AVAILABLE) then
result = "yes"
end if
help = "external NLO matrix element provider"
@
<<Features: print>>=
call print_check ("OpenLoops")
<<Features: dependencies>>=
use system_dependencies, only: OPENLOOPS_AVAILABLE
<<Features: cases>>=
case ("openloops")
if (OPENLOOPS_AVAILABLE) then
result = "yes"
end if
help = "external NLO matrix element provider"
@
<<Features: print>>=
call print_check ("Recola")
<<Features: dependencies>>=
use system_dependencies, only: RECOLA_AVAILABLE
<<Features: cases>>=
case ("recola")
if (RECOLA_AVAILABLE) then
result = "yes"
end if
help = "external NLO matrix element provider"
@
<<Features: print>>=
call print_check ("LHAPDF")
<<Features: dependencies>>=
use system_dependencies, only: LHAPDF5_AVAILABLE
use system_dependencies, only: LHAPDF6_AVAILABLE
<<Features: cases>>=
case ("lhapdf")
if (LHAPDF5_AVAILABLE) then
result = "v5"
else if (LHAPDF6_AVAILABLE) then
result = "v6"
end if
help = "PDF library"
@
<<Features: print>>=
call print_check ("HOPPET")
<<Features: dependencies>>=
use system_dependencies, only: HOPPET_AVAILABLE
<<Features: cases>>=
case ("hoppet")
if (HOPPET_AVAILABLE) then
result = "yes"
end if
help = "PDF evolution package"
@
<<Features: print>>=
call print_check ("fastjet")
<<Features: dependencies>>=
use jets, only: fastjet_available
<<Features: cases>>=
case ("fastjet")
if (fastjet_available ()) then
result = "yes"
end if
help = "jet-clustering package"
@
<<Features: print>>=
call print_check ("Pythia6")
<<Features: dependencies>>=
use system_dependencies, only: PYTHIA6_AVAILABLE
<<Features: cases>>=
case ("pythia6")
if (PYTHIA6_AVAILABLE) then
result = "yes"
end if
help = "direct access for shower/hadronization"
@
<<Features: print>>=
call print_check ("Pythia8")
<<Features: dependencies>>=
use system_dependencies, only: PYTHIA8_AVAILABLE
<<Features: cases>>=
case ("pythia8")
if (PYTHIA8_AVAILABLE) then
result = "yes"
end if
help = "direct access for shower/hadronization"
@
<<Features: print>>=
call print_check ("StdHEP")
<<Features: cases>>=
case ("stdhep")
result = "yes"
help = "event I/O format"
@
<<Features: print>>=
call print_check ("HepMC")
<<Features: dependencies>>=
use hepmc_interface, only: hepmc_is_available
<<Features: cases>>=
case ("hepmc")
if (hepmc_is_available ()) then
result = "yes"
end if
help = "event I/O format"
@
<<Features: print>>=
call print_check ("LCIO")
<<Features: dependencies>>=
use lcio_interface, only: lcio_is_available
<<Features: cases>>=
case ("lcio")
if (lcio_is_available ()) then
result = "yes"
end if
help = "event I/O format"
@
<<Features: print>>=
call print_check ("MetaPost")
<<Features: dependencies>>=
use system_dependencies, only: EVENT_ANALYSIS
<<Features: cases>>=
case ("metapost")
result = EVENT_ANALYSIS
help = "graphical event analysis via LaTeX/MetaPost"
@
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
Index: trunk/src/events/events.nw
===================================================================
--- trunk/src/events/events.nw (revision 8482)
+++ trunk/src/events/events.nw (revision 8483)
@@ -1,17315 +1,17315 @@
%% -*- ess-noweb-default-code-mode: f90-mode; noweb-default-code-mode: f90-mode; -*-
% WHIZARD code as NOWEB source: event handling objects
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\chapter{Generic Event Handling}
\includemodulegraph{events}
Event records allow the MC to communicate with the outside world. The
event record should exhibit the observable contents of a physical
event. We should be able to read and write events. The actual
implementation of the event need not be defined yet, for that purpose.
We have the following basic modules:
\begin{description}
\item[event\_base]
Abstract base type for event records. The base type contains a
reference to a [[particle_set_t]] object as the event core, and it
holds some data that we should always expect, such as the squared
matrix element and event weight.
\item[eio\_data]
Transparent container for the metadata of an event sample.
\item[eio\_base]
Abstract base type for event-record input and output. The
implementations of this base type represent specific event I/O
formats.
\end{description}
These are the implementation modules:
\begin{description}
\item[eio\_checkpoints]
Auxiliary output format. The only purpose is to provide screen
diagnostics during event output.
\item[eio\_callback]
Auxiliary output format. The only purpose is to execute a callback
procedure, so we have a hook for external access during event output.
\item[eio\_weights]
- Print some event summary data, no details. The main use if for
+ Print some event summary data, no details. The main use is for
testing purposes.
\item[eio\_dump]
Dump the contents of WHIZARD's [[particle_set]] internal record,
using the [[write]] method of that record as-is. The main use if for
testing purposes.
\item[hep\_common]
Implements traditional HEP common blocks that are (still) used by
some of the event I/O formats below.
\item[hepmc\_interface]
Access particle objects of the HepMC package. Functional only if this
package is linked. The interface is working both for HepMC2 and HepMC3.
\item[lcio\_interface]
Access objects of the LCIO package. Functional only if this
package is linked.
\item[hep\_events]
Interface between the event record and the common blocks.
\item[eio\_ascii]
Collection of event output formats that write ASCII files.
\item[eio\_lhef]
LHEF for input and output.
\item[eio\_stdhep]
Support for the StdHEP format (binary, machine-independent).
\item[eio\_hepmc]
Support for the HepMC format (C++).
\item[eio\_lcio]
Support for the LCIO format (C++).
\end{description}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{Generic Event Handling}
We introduce events first in form of an abstract type, together with
some utilities. Abstract events can be used by other modules, in
particular event I/O, without introducing an explicit dependency on
the event implementation.
<<[[event_base.f90]]>>=
<<File header>>
module event_base
<<Use kinds>>
use kinds, only: i64
<<Use strings>>
use io_units
use string_utils, only: lower_case
use diagnostics
use model_data
use particles
<<Standard module head>>
<<Event base: public>>
<<Event base: parameters>>
<<Event base: types>>
<<Event base: interfaces>>
contains
<<Event base: procedures>>
end module event_base
@ %def event_base
@
\subsection{generic event type}
<<Event base: public>>=
public :: generic_event_t
<<Event base: types>>=
type, abstract :: generic_event_t
!private
logical :: particle_set_is_valid = .false.
type(particle_set_t), pointer :: particle_set => null ()
logical :: sqme_ref_known = .false.
real(default) :: sqme_ref = 0
logical :: sqme_prc_known = .false.
real(default) :: sqme_prc = 0
logical :: weight_ref_known = .false.
real(default) :: weight_ref = 0
logical :: weight_prc_known = .false.
real(default) :: weight_prc = 0
logical :: excess_prc_known = .false.
real(default) :: excess_prc = 0
logical :: n_dropped_known = .false.
integer :: n_dropped = 0
integer :: n_alt = 0
logical :: sqme_alt_known = .false.
real(default), dimension(:), allocatable :: sqme_alt
logical :: weight_alt_known = .false.
real(default), dimension(:), allocatable :: weight_alt
contains
<<Event base: generic event: TBP>>
end type generic_event_t
@ %def generic_event_t
@
\subsection{Initialization}
This determines the number of alternate weights and sqme values.
<<Event base: generic event: TBP>>=
procedure :: base_init => generic_event_init
<<Event base: procedures>>=
subroutine generic_event_init (event, n_alt)
class(generic_event_t), intent(out) :: event
integer, intent(in) :: n_alt
event%n_alt = n_alt
allocate (event%sqme_alt (n_alt))
allocate (event%weight_alt (n_alt))
end subroutine generic_event_init
@ %def generic_event_init
@
\subsection{Access particle set}
The particle set is the core of the event. We allow access to it via
a pointer, and we maintain the information whether the particle set
is valid, i.e., has been filled with meaningful data.
<<Event base: generic event: TBP>>=
procedure :: has_valid_particle_set => generic_event_has_valid_particle_set
procedure :: accept_particle_set => generic_event_accept_particle_set
procedure :: discard_particle_set => generic_event_discard_particle_set
<<Event base: procedures>>=
function generic_event_has_valid_particle_set (event) result (flag)
class(generic_event_t), intent(in) :: event
logical :: flag
flag = event%particle_set_is_valid
end function generic_event_has_valid_particle_set
subroutine generic_event_accept_particle_set (event)
class(generic_event_t), intent(inout) :: event
event%particle_set_is_valid = .true.
end subroutine generic_event_accept_particle_set
subroutine generic_event_discard_particle_set (event)
class(generic_event_t), intent(inout) :: event
event%particle_set_is_valid = .false.
end subroutine generic_event_discard_particle_set
@ %def generic_event_has_valid_particle_set
@ %def generic_event_accept_particle_set
@ %def generic_event_discard_particle_set
@
These procedures deal with the particle set directly. Return the pointer:
<<Event base: generic event: TBP>>=
procedure :: get_particle_set_ptr => generic_event_get_particle_set_ptr
<<Event base: procedures>>=
function generic_event_get_particle_set_ptr (event) result (ptr)
class(generic_event_t), intent(in) :: event
type(particle_set_t), pointer :: ptr
ptr => event%particle_set
end function generic_event_get_particle_set_ptr
@ %def generic_event_get_particle_set_ptr
@
Let it point to some existing particle set:
<<Event base: generic event: TBP>>=
procedure :: link_particle_set => generic_event_link_particle_set
<<Event base: procedures>>=
subroutine generic_event_link_particle_set (event, particle_set)
class(generic_event_t), intent(inout) :: event
type(particle_set_t), intent(in), target :: particle_set
event%particle_set => particle_set
call event%accept_particle_set ()
end subroutine generic_event_link_particle_set
@ %def generic_event_link_particle_set
@
\subsection{Access sqme and weight}
There are several incarnations: the current value, a reference value,
alternate values.
<<Event base: generic event: TBP>>=
procedure :: sqme_prc_is_known => generic_event_sqme_prc_is_known
procedure :: sqme_ref_is_known => generic_event_sqme_ref_is_known
procedure :: sqme_alt_is_known => generic_event_sqme_alt_is_known
procedure :: weight_prc_is_known => generic_event_weight_prc_is_known
procedure :: weight_ref_is_known => generic_event_weight_ref_is_known
procedure :: weight_alt_is_known => generic_event_weight_alt_is_known
procedure :: excess_prc_is_known => generic_event_excess_prc_is_known
<<Event base: procedures>>=
function generic_event_sqme_prc_is_known (event) result (flag)
class(generic_event_t), intent(in) :: event
logical :: flag
flag = event%sqme_prc_known
end function generic_event_sqme_prc_is_known
function generic_event_sqme_ref_is_known (event) result (flag)
class(generic_event_t), intent(in) :: event
logical :: flag
flag = event%sqme_ref_known
end function generic_event_sqme_ref_is_known
function generic_event_sqme_alt_is_known (event) result (flag)
class(generic_event_t), intent(in) :: event
logical :: flag
flag = event%sqme_alt_known
end function generic_event_sqme_alt_is_known
function generic_event_weight_prc_is_known (event) result (flag)
class(generic_event_t), intent(in) :: event
logical :: flag
flag = event%weight_prc_known
end function generic_event_weight_prc_is_known
function generic_event_weight_ref_is_known (event) result (flag)
class(generic_event_t), intent(in) :: event
logical :: flag
flag = event%weight_ref_known
end function generic_event_weight_ref_is_known
function generic_event_weight_alt_is_known (event) result (flag)
class(generic_event_t), intent(in) :: event
logical :: flag
flag = event%weight_alt_known
end function generic_event_weight_alt_is_known
function generic_event_excess_prc_is_known (event) result (flag)
class(generic_event_t), intent(in) :: event
logical :: flag
flag = event%excess_prc_known
end function generic_event_excess_prc_is_known
@ %def generic_event_sqme_prc_is_known
@ %def generic_event_sqme_ref_is_known
@ %def generic_event_sqme_alt_is_known
@ %def generic_event_weight_prc_is_known
@ %def generic_event_weight_ref_is_known
@ %def generic_event_weight_alt_is_known
@ %def generic_event_excess_prc_is_known
@
<<Event base: generic event: TBP>>=
procedure :: get_n_alt => generic_event_get_n_alt
<<Event base: procedures>>=
function generic_event_get_n_alt (event) result (n)
class(generic_event_t), intent(in) :: event
integer :: n
n = event%n_alt
end function generic_event_get_n_alt
@ %def generic_event_get_n_alt
@
<<Event base: generic event: TBP>>=
procedure :: get_sqme_prc => generic_event_get_sqme_prc
procedure :: get_sqme_ref => generic_event_get_sqme_ref
generic :: get_sqme_alt => &
generic_event_get_sqme_alt_0, generic_event_get_sqme_alt_1
procedure :: generic_event_get_sqme_alt_0
procedure :: generic_event_get_sqme_alt_1
procedure :: get_weight_prc => generic_event_get_weight_prc
procedure :: get_weight_ref => generic_event_get_weight_ref
generic :: get_weight_alt => &
generic_event_get_weight_alt_0, generic_event_get_weight_alt_1
procedure :: generic_event_get_weight_alt_0
procedure :: generic_event_get_weight_alt_1
procedure :: get_n_dropped => generic_event_get_n_dropped
procedure :: get_excess_prc => generic_event_get_excess_prc
<<Event base: procedures>>=
function generic_event_get_sqme_prc (event) result (sqme)
class(generic_event_t), intent(in) :: event
real(default) :: sqme
if (event%sqme_prc_known) then
sqme = event%sqme_prc
else
sqme = 0
end if
end function generic_event_get_sqme_prc
function generic_event_get_sqme_ref (event) result (sqme)
class(generic_event_t), intent(in) :: event
real(default) :: sqme
if (event%sqme_ref_known) then
sqme = event%sqme_ref
else
sqme = 0
end if
end function generic_event_get_sqme_ref
function generic_event_get_sqme_alt_0 (event, i) result (sqme)
class(generic_event_t), intent(in) :: event
integer, intent(in) :: i
real(default) :: sqme
if (event%sqme_alt_known) then
sqme = event%sqme_alt(i)
else
sqme = 0
end if
end function generic_event_get_sqme_alt_0
function generic_event_get_sqme_alt_1 (event) result (sqme)
class(generic_event_t), intent(in) :: event
real(default), dimension(event%n_alt) :: sqme
sqme = event%sqme_alt
end function generic_event_get_sqme_alt_1
function generic_event_get_weight_prc (event) result (weight)
class(generic_event_t), intent(in) :: event
real(default) :: weight
if (event%weight_prc_known) then
weight = event%weight_prc
else
weight = 0
end if
end function generic_event_get_weight_prc
function generic_event_get_weight_ref (event) result (weight)
class(generic_event_t), intent(in) :: event
real(default) :: weight
if (event%weight_ref_known) then
weight = event%weight_ref
else
weight = 0
end if
end function generic_event_get_weight_ref
function generic_event_get_weight_alt_0 (event, i) result (weight)
class(generic_event_t), intent(in) :: event
integer, intent(in) :: i
real(default) :: weight
if (event%weight_alt_known) then
weight = event%weight_alt(i)
else
weight = 0
end if
end function generic_event_get_weight_alt_0
function generic_event_get_weight_alt_1 (event) result (weight)
class(generic_event_t), intent(in) :: event
real(default), dimension(event%n_alt) :: weight
weight = event%weight_alt
end function generic_event_get_weight_alt_1
function generic_event_get_excess_prc (event) result (excess)
class(generic_event_t), intent(in) :: event
real(default) :: excess
if (event%excess_prc_known) then
excess = event%excess_prc
else
excess = 0
end if
end function generic_event_get_excess_prc
function generic_event_get_n_dropped (event) result (n_dropped)
class(generic_event_t), intent(in) :: event
integer :: n_dropped
if (event%n_dropped_known) then
n_dropped = event%n_dropped
else
n_dropped = 0
end if
end function generic_event_get_n_dropped
@ %def generic_event_get_sqme_prc
@ %def generic_event_get_sqme_ref
@ %def generic_event_get_sqme_alt
@ %def generic_event_get_weight_prc
@ %def generic_event_get_weight_ref
@ %def generic_event_get_weight_alt
@ %def generic_event_get_n_dropped
@ %def generic_event_get_excess_prc
@
<<Event base: generic event: TBP>>=
procedure :: set_sqme_prc => generic_event_set_sqme_prc
procedure :: set_sqme_ref => generic_event_set_sqme_ref
procedure :: set_sqme_alt => generic_event_set_sqme_alt
procedure :: set_weight_prc => generic_event_set_weight_prc
procedure :: set_weight_ref => generic_event_set_weight_ref
procedure :: set_weight_alt => generic_event_set_weight_alt
procedure :: set_excess_prc => generic_event_set_excess_prc
procedure :: set_n_dropped => generic_event_set_n_dropped
<<Event base: procedures>>=
subroutine generic_event_set_sqme_prc (event, sqme)
class(generic_event_t), intent(inout) :: event
real(default), intent(in) :: sqme
event%sqme_prc = sqme
event%sqme_prc_known = .true.
end subroutine generic_event_set_sqme_prc
subroutine generic_event_set_sqme_ref (event, sqme)
class(generic_event_t), intent(inout) :: event
real(default), intent(in) :: sqme
event%sqme_ref = sqme
event%sqme_ref_known = .true.
end subroutine generic_event_set_sqme_ref
subroutine generic_event_set_sqme_alt (event, sqme)
class(generic_event_t), intent(inout) :: event
real(default), dimension(:), intent(in) :: sqme
event%sqme_alt = sqme
event%sqme_alt_known = .true.
end subroutine generic_event_set_sqme_alt
subroutine generic_event_set_weight_prc (event, weight)
class(generic_event_t), intent(inout) :: event
real(default), intent(in) :: weight
event%weight_prc = weight
event%weight_prc_known = .true.
end subroutine generic_event_set_weight_prc
subroutine generic_event_set_weight_ref (event, weight)
class(generic_event_t), intent(inout) :: event
real(default), intent(in) :: weight
event%weight_ref = weight
event%weight_ref_known = .true.
end subroutine generic_event_set_weight_ref
subroutine generic_event_set_weight_alt (event, weight)
class(generic_event_t), intent(inout) :: event
real(default), dimension(:), intent(in) :: weight
event%weight_alt = weight
event%weight_alt_known = .true.
end subroutine generic_event_set_weight_alt
subroutine generic_event_set_excess_prc (event, excess)
class(generic_event_t), intent(inout) :: event
real(default), intent(in) :: excess
event%excess_prc = excess
event%excess_prc_known = .true.
end subroutine generic_event_set_excess_prc
subroutine generic_event_set_n_dropped (event, n_dropped)
class(generic_event_t), intent(inout) :: event
integer, intent(in) :: n_dropped
event%n_dropped = n_dropped
event%n_dropped_known = .true.
end subroutine generic_event_set_n_dropped
@ %def generic_event_set_sqme_prc
@ %def generic_event_set_sqme_ref
@ %def generic_event_set_sqme_alt
@ %def generic_event_set_weight_prc
@ %def generic_event_set_weight_ref
@ %def generic_event_set_weight_alt
@ %def generic_event_set_n_dropped
@
Set the appropriate entry directly.
<<Event base: generic event: TBP>>=
procedure :: set => generic_event_set
<<Event base: procedures>>=
subroutine generic_event_set (event, &
weight_ref, weight_prc, weight_alt, &
excess_prc, n_dropped, &
sqme_ref, sqme_prc, sqme_alt)
class(generic_event_t), intent(inout) :: event
real(default), intent(in), optional :: weight_ref, weight_prc
real(default), intent(in), optional :: sqme_ref, sqme_prc
real(default), dimension(:), intent(in), optional :: sqme_alt, weight_alt
real(default), intent(in), optional :: excess_prc
integer, intent(in), optional :: n_dropped
if (present (sqme_prc)) then
call event%set_sqme_prc (sqme_prc)
end if
if (present (sqme_ref)) then
call event%set_sqme_ref (sqme_ref)
end if
if (present (sqme_alt)) then
call event%set_sqme_alt (sqme_alt)
end if
if (present (weight_prc)) then
call event%set_weight_prc (weight_prc)
end if
if (present (weight_ref)) then
call event%set_weight_ref (weight_ref)
end if
if (present (weight_alt)) then
call event%set_weight_alt (weight_alt)
end if
if (present (excess_prc)) then
call event%set_excess_prc (excess_prc)
end if
if (present (n_dropped)) then
call event%set_n_dropped (n_dropped)
end if
end subroutine generic_event_set
@ %def generic_event_set
@
\subsection{Pure Virtual Methods}
These procedures can only implemented in the concrete implementation.
Output (verbose, depending on parameters).
<<Event base: generic event: TBP>>=
procedure (generic_event_write), deferred :: write
<<Event base: interfaces>>=
abstract interface
subroutine generic_event_write (object, unit, &
show_process, show_transforms, &
show_decay, verbose, testflag)
import
class(generic_event_t), intent(in) :: object
integer, intent(in), optional :: unit
logical, intent(in), optional :: show_process
logical, intent(in), optional :: show_transforms
logical, intent(in), optional :: show_decay
logical, intent(in), optional :: verbose
logical, intent(in), optional :: testflag
end subroutine generic_event_write
end interface
@ %def generic_event_write
@
Generate an event, based on a selector index [[i_mci]], and optionally on an
extra set of random numbers [[r]]. For the main bunch of random numbers that
the generator needs, the event object should contain its own generator.
<<Event base: generic event: TBP>>=
procedure (generic_event_generate), deferred :: generate
<<Event base: interfaces>>=
abstract interface
subroutine generic_event_generate (event, i_mci, r, i_nlo)
import
class(generic_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 generic_event_generate
end interface
@ %def event_generate
@
Alternative : inject a particle set that is supposed to represent the hard
process.
How this determines the event, is dependent on the event structure,
therefore this is a deferred method.
<<Event base: generic event: TBP>>=
procedure (generic_event_set_hard_particle_set), deferred :: &
set_hard_particle_set
<<Event base: interfaces>>=
abstract interface
subroutine generic_event_set_hard_particle_set (event, particle_set)
import
class(generic_event_t), intent(inout) :: event
type(particle_set_t), intent(in) :: particle_set
end subroutine generic_event_set_hard_particle_set
end interface
@ %def generic_event_set_hard_particle_set
@ Event index handlers.
<<Event base: generic event: TBP>>=
procedure (generic_event_set_index), deferred :: set_index
procedure (generic_event_handler), deferred :: reset_index
procedure (generic_event_increment_index), deferred :: increment_index
@
<<Event base: interfaces>>=
abstract interface
subroutine generic_event_set_index (event, index)
import
class(generic_event_t), intent(inout) :: event
integer, intent(in) :: index
end subroutine generic_event_set_index
end interface
abstract interface
subroutine generic_event_handler (event)
import
class(generic_event_t), intent(inout) :: event
end subroutine generic_event_handler
end interface
abstract interface
subroutine generic_event_increment_index (event, offset)
import
class(generic_event_t), intent(inout) :: event
integer, intent(in), optional :: offset
end subroutine generic_event_increment_index
end interface
@ %def generic_event_set_index
@ %def generic_event_increment_index
@ %def generic_event_handler
@ Evaluate any expressions associated with the event. No argument needed.
<<Event base: generic event: TBP>>=
procedure (generic_event_handler), deferred :: evaluate_expressions
@
Select internal parameters
<<Event base: generic event: TBP>>=
procedure (generic_event_select), deferred :: select
<<Event base: interfaces>>=
abstract interface
subroutine generic_event_select (event, i_mci, i_term, channel)
import
class(generic_event_t), intent(inout) :: event
integer, intent(in) :: i_mci, i_term, channel
end subroutine generic_event_select
end interface
@ %def generic_event_select
@ Return a pointer to the model for the currently active process.
<<Event base: generic event: TBP>>=
procedure (generic_event_get_model_ptr), deferred :: get_model_ptr
<<Event base: interfaces>>=
abstract interface
function generic_event_get_model_ptr (event) result (model)
import
class(generic_event_t), intent(in) :: event
class(model_data_t), pointer :: model
end function generic_event_get_model_ptr
end interface
@ %def generic_event_get_model_ptr
@ Return data used by external event formats.
<<Event base: generic event: TBP>>=
procedure (generic_event_has_index), deferred :: has_index
procedure (generic_event_get_index), deferred :: get_index
procedure (generic_event_get_fac_scale), deferred :: get_fac_scale
procedure (generic_event_get_alpha_s), deferred :: get_alpha_s
procedure (generic_event_get_sqrts), deferred :: get_sqrts
procedure (generic_event_get_polarization), deferred :: get_polarization
procedure (generic_event_get_beam_file), deferred :: get_beam_file
procedure (generic_event_get_process_name), deferred :: &
get_process_name
<<Event base: interfaces>>=
abstract interface
function generic_event_has_index (event) result (flag)
import
class(generic_event_t), intent(in) :: event
logical :: flag
end function generic_event_has_index
end interface
abstract interface
function generic_event_get_index (event) result (index)
import
class(generic_event_t), intent(in) :: event
integer :: index
end function generic_event_get_index
end interface
abstract interface
function generic_event_get_fac_scale (event) result (fac_scale)
import
class(generic_event_t), intent(in) :: event
real(default) :: fac_scale
end function generic_event_get_fac_scale
end interface
abstract interface
function generic_event_get_alpha_s (event) result (alpha_s)
import
class(generic_event_t), intent(in) :: event
real(default) :: alpha_s
end function generic_event_get_alpha_s
end interface
abstract interface
function generic_event_get_sqrts (event) result (sqrts)
import
class(generic_event_t), intent(in) :: event
real(default) :: sqrts
end function generic_event_get_sqrts
end interface
abstract interface
function generic_event_get_polarization (event) result (pol)
import
class(generic_event_t), intent(in) :: event
real(default), dimension(2) :: pol
end function generic_event_get_polarization
end interface
abstract interface
function generic_event_get_beam_file (event) result (file)
import
class(generic_event_t), intent(in) :: event
type(string_t) :: file
end function generic_event_get_beam_file
end interface
abstract interface
function generic_event_get_process_name (event) result (name)
import
class(generic_event_t), intent(in) :: event
type(string_t) :: name
end function generic_event_get_process_name
end interface
@ %def generic_event_get_index
@ %def generic_event_get_fac_scale
@ %def generic_event_get_alpha_s
@ %def generic_event_get_sqrts
@ %def generic_event_get_polarization
@ %def generic_event_get_beam_file
@ %def generic_event_get_process_name
@ Set data used by external event formats.
<<Event base: generic event: TBP>>=
procedure (generic_event_set_alpha_qcd_forced), deferred :: &
set_alpha_qcd_forced
procedure (generic_event_set_scale_forced), deferred :: &
set_scale_forced
<<Event base: interfaces>>=
abstract interface
subroutine generic_event_set_alpha_qcd_forced (event, alpha_qcd)
import
class(generic_event_t), intent(inout) :: event
real(default), intent(in) :: alpha_qcd
end subroutine generic_event_set_alpha_qcd_forced
end interface
abstract interface
subroutine generic_event_set_scale_forced (event, scale)
import
class(generic_event_t), intent(inout) :: event
real(default), intent(in) :: scale
end subroutine generic_event_set_scale_forced
end interface
@ %def generic_event_set_alpha_qcd_forced
@ %def generic_event_set_scale_forced
@
\subsection{Utilities}
Applying this, current event contents are marked as incomplete but
are not deleted. In particular, the initialization is kept.
<<Event base: generic event: TBP>>=
procedure :: reset_contents => generic_event_reset_contents
procedure :: base_reset_contents => generic_event_reset_contents
<<Event base: procedures>>=
subroutine generic_event_reset_contents (event)
class(generic_event_t), intent(inout) :: event
call event%discard_particle_set ()
event%sqme_ref_known = .false.
event%sqme_prc_known = .false.
event%sqme_alt_known = .false.
event%weight_ref_known = .false.
event%weight_prc_known = .false.
event%weight_alt_known = .false.
event%excess_prc_known = .false.
end subroutine generic_event_reset_contents
@ %def generic_event_reset_contents
@ Pacify particle set.
<<Event base: generic event: TBP>>=
procedure :: pacify_particle_set => generic_event_pacify_particle_set
<<Event base: procedures>>=
subroutine generic_event_pacify_particle_set (event)
class(generic_event_t), intent(inout) :: event
if (event%has_valid_particle_set ()) call pacify (event%particle_set)
end subroutine generic_event_pacify_particle_set
@ %def generic_event_pacify_particle_set
@
\subsection{Event normalization}
The parameters for event normalization. For unweighted events,
[[NORM_UNIT]] is intended as default, while for weighted events, it is
[[NORM_SIGMA]].
Note: the unit test for this is in [[eio_data_2]] below.
<<Event base: parameters>>=
integer, parameter, public :: NORM_UNDEFINED = 0
integer, parameter, public :: NORM_UNIT = 1
integer, parameter, public :: NORM_N_EVT = 2
integer, parameter, public :: NORM_SIGMA = 3
integer, parameter, public :: NORM_S_N = 4
@ %def NORM_UNDEFINED NORM_UNIT NORM_N_EVT NORM_SIGMA NORM_S_N
@ These functions translate between the user representation and the
internal one.
<<Event base: public>>=
public :: event_normalization_mode
public :: event_normalization_string
<<Event base: procedures>>=
function event_normalization_mode (string, unweighted) result (mode)
integer :: mode
type(string_t), intent(in) :: string
logical, intent(in) :: unweighted
select case (lower_case (char (string)))
case ("auto")
if (unweighted) then
mode = NORM_UNIT
else
mode = NORM_SIGMA
end if
case ("1")
mode = NORM_UNIT
case ("1/n")
mode = NORM_N_EVT
case ("sigma")
mode = NORM_SIGMA
case ("sigma/n")
mode = NORM_S_N
case default
call msg_fatal ("Event normalization: unknown value '" &
// char (string) // "'")
end select
end function event_normalization_mode
function event_normalization_string (norm_mode) result (string)
integer, intent(in) :: norm_mode
type(string_t) :: string
select case (norm_mode)
case (NORM_UNDEFINED); string = "[undefined]"
case (NORM_UNIT); string = "'1'"
case (NORM_N_EVT); string = "'1/n'"
case (NORM_SIGMA); string = "'sigma'"
case (NORM_S_N); string = "'sigma/n'"
case default; string = "???"
end select
end function event_normalization_string
@ %def event_normalization_mode
@ %def event_normalization_string
@ We place this here as a generic helper, so we can update event
weights whenever we need, not just in connection with an event sample
data object.
<<Event base: public>>=
public :: event_normalization_update
<<Event base: procedures>>=
subroutine event_normalization_update (weight, sigma, n, mode_new, mode_old)
real(default), intent(inout) :: weight
real(default), intent(in) :: sigma
integer, intent(in) :: n
integer, intent(in) :: mode_new, mode_old
if (mode_new /= mode_old) then
if (sigma > 0 .and. n > 0) then
weight = weight / factor (mode_old) * factor (mode_new)
else
call msg_fatal ("Event normalization update: null sample")
end if
end if
contains
function factor (mode)
real(default) :: factor
integer, intent(in) :: mode
select case (mode)
case (NORM_UNIT); factor = 1._default
case (NORM_N_EVT); factor = 1._default / n
case (NORM_SIGMA); factor = sigma
case (NORM_S_N); factor = sigma / n
case default
call msg_fatal ("Event normalization update: undefined mode")
end select
end function factor
end subroutine event_normalization_update
@ %def event_normalization_update
@
\subsection{Callback container}
This derived type contains a callback procedure that can
be executed during event I/O. The callback procedure is given the
event object (with class [[generic_event]]) and an event index.
This is a simple wrapper. The object is abstract, so the the actual
procedure is introduced by overriding the deferred one. We use the
PASS attribute, so we may supplement runtime data in the callback object
if desired.
<<Event base: public>>=
public :: event_callback_t
<<Event base: types>>=
type, abstract :: event_callback_t
private
contains
procedure(event_callback_write), deferred :: write
procedure(event_callback_proc), deferred :: proc
end type event_callback_t
@ %def event_callback_t
@ Identify the callback procedure in output
<<Event base: interfaces>>=
abstract interface
subroutine event_callback_write (event_callback, unit)
import
class(event_callback_t), intent(in) :: event_callback
integer, intent(in), optional :: unit
end subroutine event_callback_write
end interface
@ %def event_callback_write
@ This is the procedure interface.
<<Event base: interfaces>>=
abstract interface
subroutine event_callback_proc (event_callback, i, event)
import
class(event_callback_t), intent(in) :: event_callback
integer(i64), intent(in) :: i
class(generic_event_t), intent(in) :: event
end subroutine event_callback_proc
end interface
@ %def event_callback_proc
@ A dummy implementation for testing and fallback.
<<Event base: public>>=
public :: event_callback_nop_t
<<Event base: types>>=
type, extends (event_callback_t) :: event_callback_nop_t
private
contains
procedure :: write => event_callback_nop_write
procedure :: proc => event_callback_nop
end type event_callback_nop_t
@ %def event_callback_t
<<Event base: procedures>>=
subroutine event_callback_nop_write (event_callback, unit)
class(event_callback_nop_t), intent(in) :: event_callback
integer, intent(in), optional :: unit
integer :: u
u = given_output_unit (unit)
write (u, "(1x,A)") "NOP"
end subroutine event_callback_nop_write
subroutine event_callback_nop (event_callback, i, event)
class(event_callback_nop_t), intent(in) :: event_callback
integer(i64), intent(in) :: i
class(generic_event_t), intent(in) :: event
end subroutine event_callback_nop
@ %def event_callback_nop_write
@ %def event_callback_nop
@
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{Event Handle}
This module defines an abstract base type that allows us to communicate any
type of event record within the program. The concrete extensions are expected
to consist of pointers, such as the C pointers for HepMC or LCIO events, so
the communication object is a very light-weight one.
<<[[event_handles.f90]]>>=
<<File header>>
module event_handles
<<Standard module head>>
<<Event handle: public>>
<<Event handle: types>>
end module event_handles
@ %def event_handles
@
There is only one abstract type.
<<Event handle: public>>=
public :: event_handle_t
<<Event handle: types>>=
type, abstract :: event_handle_t
end type event_handle_t
@ %def event_handle_t
@
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{Event Sample Data}
We define a simple and transparent container for (meta)data that are
associated with an event sample.
<<[[eio_data.f90]]>>=
<<File header>>
module eio_data
<<Use kinds>>
<<Use strings>>
use io_units
use numeric_utils
use diagnostics
use event_base
<<Standard module head>>
<<EIO data: public>>
<<EIO data: types>>
contains
<<EIO data: procedures>>
end module eio_data
@ %def eio_data
@
\subsection{Event Sample Data}
These are data that apply to an event sample as a whole. They are
given in an easily portable form (no fancy structure) and are used for
initializing event formats.
There are two MD5 sums here. [[md5sum_proc]] depends only on the
definition of the contributing processes. A sample with matching
checksum can be rescanned with modified model parameters, beam
structure etc, to recalculate observables. [[md5sum_config]] includes
all relevant data. Rescanning a sample with matching checksum will
produce identical observables. (A third checksum might be added which
depends on the event sample itself. This is not needed, so far.)
If alternate weights are part of the event sample ([[n_alt]] nonzero),
there is a configuration MD5 sum for each of them.
<<EIO data: public>>=
public :: event_sample_data_t
<<EIO data: types>>=
type :: event_sample_data_t
character(32) :: md5sum_prc = ""
character(32) :: md5sum_cfg = ""
logical :: unweighted = .true.
logical :: negative_weights = .false.
integer :: norm_mode = NORM_UNDEFINED
integer :: n_beam = 0
integer, dimension(2) :: pdg_beam = 0
real(default), dimension(2) :: energy_beam = 0
integer :: n_proc = 0
integer :: n_evt = 0
integer :: nlo_multiplier = 1
integer :: split_n_evt = 0
integer :: split_n_kbytes = 0
integer :: split_index = 0
real(default) :: total_cross_section = 0
integer, dimension(:), allocatable :: proc_num_id
integer :: n_alt = 0
character(32), dimension(:), allocatable :: md5sum_alt
real(default), dimension(:), allocatable :: cross_section
real(default), dimension(:), allocatable :: error
contains
<<EIO data: event sample data: TBP>>
end type event_sample_data_t
@ %def event_sample_data_t
@ Initialize: allocate for the number of processes
<<EIO data: event sample data: TBP>>=
procedure :: init => event_sample_data_init
<<EIO data: procedures>>=
subroutine event_sample_data_init (data, n_proc, n_alt)
class(event_sample_data_t), intent(out) :: data
integer, intent(in) :: n_proc
integer, intent(in), optional :: n_alt
data%n_proc = n_proc
allocate (data%proc_num_id (n_proc), source = 0)
allocate (data%cross_section (n_proc), source = 0._default)
allocate (data%error (n_proc), source = 0._default)
if (present (n_alt)) then
data%n_alt = n_alt
allocate (data%md5sum_alt (n_alt))
data%md5sum_alt = ""
end if
end subroutine event_sample_data_init
@ %def event_sample_data_init
@ Output.
<<EIO data: event sample data: TBP>>=
procedure :: write => event_sample_data_write
<<EIO data: procedures>>=
subroutine event_sample_data_write (data, unit)
class(event_sample_data_t), intent(in) :: data
integer, intent(in), optional :: unit
integer :: u, i
u = given_output_unit (unit)
write (u, "(1x,A)") "Event sample properties:"
write (u, "(3x,A,A,A)") "MD5 sum (proc) = '", data%md5sum_prc, "'"
write (u, "(3x,A,A,A)") "MD5 sum (config) = '", data%md5sum_cfg, "'"
write (u, "(3x,A,L1)") "unweighted = ", data%unweighted
write (u, "(3x,A,L1)") "negative weights = ", data%negative_weights
write (u, "(3x,A,A)") "normalization = ", &
char (event_normalization_string (data%norm_mode))
write (u, "(3x,A,I0)") "number of beams = ", data%n_beam
write (u, "(5x,A,2(1x,I19))") "PDG = ", &
data%pdg_beam(:data%n_beam)
write (u, "(5x,A,2(1x,ES19.12))") "Energy = ", &
data%energy_beam(:data%n_beam)
if (data%n_evt > 0) then
write (u, "(3x,A,I0)") "number of events = ", data%n_evt
end if
if (.not. vanishes (data%total_cross_section)) then
write (u, "(3x,A,ES19.12)") "total cross sec. = ", &
data%total_cross_section
end if
write (u, "(3x,A,I0)") "num of processes = ", data%n_proc
do i = 1, data%n_proc
write (u, "(3x,A,I0)") "Process #", data%proc_num_id (i)
select case (data%n_beam)
case (1)
write (u, "(5x,A,ES19.12)") "Width = ", data%cross_section(i)
case (2)
write (u, "(5x,A,ES19.12)") "CSec = ", data%cross_section(i)
end select
write (u, "(5x,A,ES19.12)") "Error = ", data%error(i)
end do
if (data%n_alt > 0) then
write (u, "(3x,A,I0)") "num of alt wgt = ", data%n_alt
do i = 1, data%n_alt
write (u, "(5x,A,A,A,1x,I0)") "MD5 sum (cfg) = '", &
data%md5sum_alt(i), "'", i
end do
end if
end subroutine event_sample_data_write
@ %def event_sample_data_write
@
\subsection{Unit tests}
Test module, followed by the corresponding implementation module.
<<[[eio_data_ut.f90]]>>=
<<File header>>
module eio_data_ut
use unit_tests
use eio_data_uti
<<Standard module head>>
<<EIO data: public test>>
contains
<<EIO data: test driver>>
end module eio_data_ut
@ %def eio_data_ut
@
<<[[eio_data_uti.f90]]>>=
<<File header>>
module eio_data_uti
<<Use kinds>>
<<Use strings>>
use event_base
use eio_data
<<Standard module head>>
<<EIO data: test declarations>>
contains
<<EIO data: tests>>
end module eio_data_uti
@ %def eio_data_ut
@ API: driver for the unit tests below.
<<EIO data: public test>>=
public :: eio_data_test
<<EIO data: test driver>>=
subroutine eio_data_test (u, results)
integer, intent(in) :: u
type(test_results_t), intent(inout) :: results
<<EIO data: execute tests>>
end subroutine eio_data_test
@ %def eio_data_test
@
\subsubsection{Event Sample Data}
Print the contents of a sample data block.
<<EIO data: execute tests>>=
call test (eio_data_1, "eio_data_1", &
"event sample data", &
u, results)
<<EIO data: test declarations>>=
public :: eio_data_1
<<EIO data: tests>>=
subroutine eio_data_1 (u)
integer, intent(in) :: u
type(event_sample_data_t) :: data
write (u, "(A)") "* Test output: eio_data_1"
write (u, "(A)") "* Purpose: display event sample data"
write (u, "(A)")
write (u, "(A)") "* Decay process, one component"
write (u, "(A)")
call data%init (1, 1)
data%n_beam = 1
data%pdg_beam(1) = 25
data%energy_beam(1) = 125
data%norm_mode = NORM_UNIT
data%proc_num_id = [42]
data%cross_section = [1.23e-4_default]
data%error = 5e-6_default
data%md5sum_prc = "abcdefghijklmnopabcdefghijklmnop"
data%md5sum_cfg = "12345678901234561234567890123456"
data%md5sum_alt(1) = "uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu"
call data%write (u)
write (u, "(A)")
write (u, "(A)") "* Scattering process, two components"
write (u, "(A)")
call data%init (2)
data%n_beam = 2
data%pdg_beam = [2212, -2212]
data%energy_beam = [8._default, 10._default]
data%norm_mode = NORM_SIGMA
data%proc_num_id = [12, 34]
data%cross_section = [100._default, 88._default]
data%error = [1._default, 0.1_default]
call data%write (u)
write (u, "(A)")
write (u, "(A)") "* Test output end: eio_data_1"
end subroutine eio_data_1
@ %def eio_data_1
@
\subsubsection{Event Normalization}
Check the functions for translating modes and updating weights.
<<EIO data: execute tests>>=
call test (eio_data_2, "eio_data_2", &
"event normalization", &
u, results)
<<EIO data: test declarations>>=
public :: eio_data_2
<<EIO data: tests>>=
subroutine eio_data_2 (u)
integer, intent(in) :: u
type(string_t) :: s
logical :: unweighted
real(default) :: w, w0, sigma
integer :: n
write (u, "(A)") "* Test output: eio_data_2"
write (u, "(A)") "* Purpose: handle event normalization"
write (u, "(A)")
write (u, "(A)") "* Normalization strings"
write (u, "(A)")
s = "auto"
unweighted = .true.
write (u, "(1x,A,1x,L1,1x,A)") char (s), unweighted, &
char (event_normalization_string &
(event_normalization_mode (s, unweighted)))
s = "AUTO"
unweighted = .false.
write (u, "(1x,A,1x,L1,1x,A)") char (s), unweighted, &
char (event_normalization_string &
(event_normalization_mode (s, unweighted)))
unweighted = .true.
s = "1"
write (u, "(2(1x,A))") char (s), char (event_normalization_string &
(event_normalization_mode (s, unweighted)))
s = "1/n"
write (u, "(2(1x,A))") char (s), char (event_normalization_string &
(event_normalization_mode (s, unweighted)))
s = "Sigma"
write (u, "(2(1x,A))") char (s), char (event_normalization_string &
(event_normalization_mode (s, unweighted)))
s = "sigma/N"
write (u, "(2(1x,A))") char (s), char (event_normalization_string &
(event_normalization_mode (s, unweighted)))
write (u, "(A)")
write (u, "(A)") "* Normalization update"
write (u, "(A)")
sigma = 5
n = 2
w0 = 1
w = w0
call event_normalization_update (w, sigma, n, NORM_UNIT, NORM_UNIT)
write (u, "(2(F6.3))") w0, w
w = w0
call event_normalization_update (w, sigma, n, NORM_N_EVT, NORM_UNIT)
write (u, "(2(F6.3))") w0, w
w = w0
call event_normalization_update (w, sigma, n, NORM_SIGMA, NORM_UNIT)
write (u, "(2(F6.3))") w0, w
w = w0
call event_normalization_update (w, sigma, n, NORM_S_N, NORM_UNIT)
write (u, "(2(F6.3))") w0, w
write (u, *)
w0 = 0.5
w = w0
call event_normalization_update (w, sigma, n, NORM_UNIT, NORM_N_EVT)
write (u, "(2(F6.3))") w0, w
w = w0
call event_normalization_update (w, sigma, n, NORM_N_EVT, NORM_N_EVT)
write (u, "(2(F6.3))") w0, w
w = w0
call event_normalization_update (w, sigma, n, NORM_SIGMA, NORM_N_EVT)
write (u, "(2(F6.3))") w0, w
w = w0
call event_normalization_update (w, sigma, n, NORM_S_N, NORM_N_EVT)
write (u, "(2(F6.3))") w0, w
write (u, *)
w0 = 5.0
w = w0
call event_normalization_update (w, sigma, n, NORM_UNIT, NORM_SIGMA)
write (u, "(2(F6.3))") w0, w
w = w0
call event_normalization_update (w, sigma, n, NORM_N_EVT, NORM_SIGMA)
write (u, "(2(F6.3))") w0, w
w = w0
call event_normalization_update (w, sigma, n, NORM_SIGMA, NORM_SIGMA)
write (u, "(2(F6.3))") w0, w
w = w0
call event_normalization_update (w, sigma, n, NORM_S_N, NORM_SIGMA)
write (u, "(2(F6.3))") w0, w
write (u, *)
w0 = 2.5
w = w0
call event_normalization_update (w, sigma, n, NORM_UNIT, NORM_S_N)
write (u, "(2(F6.3))") w0, w
w = w0
call event_normalization_update (w, sigma, n, NORM_N_EVT, NORM_S_N)
write (u, "(2(F6.3))") w0, w
w = w0
call event_normalization_update (w, sigma, n, NORM_SIGMA, NORM_S_N)
write (u, "(2(F6.3))") w0, w
w = w0
call event_normalization_update (w, sigma, n, NORM_S_N, NORM_S_N)
write (u, "(2(F6.3))") w0, w
write (u, "(A)")
write (u, "(A)") "* Test output end: eio_data_2"
end subroutine eio_data_2
@ %def eio_data_2
@
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{Abstract I/O Handler}
This module defines an abstract object for event I/O and the
associated methods.
There are [[output]] and [[input]] methods which
write or read a single event from/to the I/O stream, respectively.
The I/O stream itself may be a file, a common block, or an externally
linked structure, depending on the concrete implementation.
A [[write]] method prints the current content of the
implementation-dependent event record in human-readable form.
The [[init_in]]/[[init_out]] and [[final]] prepare
and finalize the I/O stream, respectively. There is also a
[[switch_inout]] method which turns an input stream into an output
stream where events can be appended.
Optionally, output files can be split in chunks of well-defined size. The
[[split_out]] method takes care of this.
<<[[eio_base.f90]]>>=
<<File header>>
module eio_base
use kinds, only: i64
<<Use strings>>
use io_units
use diagnostics
use model_data
use event_base
use event_handles, only: event_handle_t
use eio_data
<<Standard module head>>
<<EIO base: public>>
<<EIO base: types>>
<<EIO base: interfaces>>
contains
<<EIO base: procedures>>
end module eio_base
@ %def eio_base
@
\subsection{Type}
We can assume that most implementations will need the file extension as a
fixed string and, if they support file splitting, the current file index.
The fallback model is useful for implementations that are able to read
unknown files which may contain hadrons etc., not in the current
hard-interaction model.
<<EIO base: public>>=
public :: eio_t
<<EIO base: types>>=
type, abstract :: eio_t
type(string_t) :: sample
type(string_t) :: extension
type(string_t) :: filename
logical :: has_file = .false.
logical :: split = .false.
integer :: split_n_evt = 0
integer :: split_n_kbytes = 0
integer :: split_index = 0
integer :: split_count = 0
class(model_data_t), pointer :: fallback_model => null ()
contains
<<EIO base: eio: TBP>>
end type eio_t
@ %def eio_t
@ Write to screen. If possible, this should display the contents of the
current event, i.e., the last one that was written or read.
<<EIO base: eio: TBP>>=
procedure (eio_write), deferred :: write
<<EIO base: interfaces>>=
abstract interface
subroutine eio_write (object, unit)
import
class(eio_t), intent(in) :: object
integer, intent(in), optional :: unit
end subroutine eio_write
end interface
@ %def eio_write
@ Finalize. This should write/read footer data and close input/output
channels.
<<EIO base: eio: TBP>>=
procedure (eio_final), deferred :: final
<<EIO base: interfaces>>=
abstract interface
subroutine eio_final (object)
import
class(eio_t), intent(inout) :: object
end subroutine eio_final
end interface
@ %def eio_final
@ Determine splitting parameters from the event sample data.
<<EIO base: eio: TBP>>=
procedure :: set_splitting => eio_set_splitting
<<EIO base: procedures>>=
subroutine eio_set_splitting (eio, data)
class(eio_t), intent(inout) :: eio
type(event_sample_data_t), intent(in) :: data
eio%split = data%split_n_evt > 0 .or. data%split_n_kbytes > 0
if (eio%split) then
eio%split_n_evt = data%split_n_evt
eio%split_n_kbytes = data%split_n_kbytes
eio%split_index = data%split_index
eio%split_count = 0
end if
end subroutine eio_set_splitting
@ %def eio_set_splitting
@ Update the byte count and check if it has increased. We use integer
division to determine the number of [[n_kbytes]] blocks that are in
the event file.
<<EIO base: eio: TBP>>=
procedure :: update_split_count => eio_update_split_count
<<EIO base: procedures>>=
subroutine eio_update_split_count (eio, increased)
class(eio_t), intent(inout) :: eio
logical, intent(out) :: increased
integer :: split_count_old
if (eio%split_n_kbytes > 0) then
split_count_old = eio%split_count
eio%split_count = eio%file_size_kbytes () / eio%split_n_kbytes
increased = eio%split_count > split_count_old
end if
end subroutine eio_update_split_count
@ %def eio_update_split_count
@ Generate a filename, taking a possible split index into account.
<<EIO base: eio: TBP>>=
procedure :: set_filename => eio_set_filename
<<EIO base: procedures>>=
subroutine eio_set_filename (eio)
class(eio_t), intent(inout) :: eio
character(32) :: buffer
if (eio%split) then
write (buffer, "(I0,'.')") eio%split_index
eio%filename = eio%sample // "." // trim (buffer) // eio%extension
eio%has_file = .true.
else
eio%filename = eio%sample // "." // eio%extension
eio%has_file = .true.
end if
end subroutine eio_set_filename
@ %def eio_set_filename
@ Set the fallback model.
<<EIO base: eio: TBP>>=
procedure :: set_fallback_model => eio_set_fallback_model
<<EIO base: procedures>>=
subroutine eio_set_fallback_model (eio, model)
class(eio_t), intent(inout) :: eio
class(model_data_t), intent(in), target :: model
eio%fallback_model => model
end subroutine eio_set_fallback_model
@ %def eio_set_fallback_model
@ Initialize for output. We provide process names. This should
open an event file if appropriate and write header data. Some methods
may require event sample data.
<<EIO base: eio: TBP>>=
procedure (eio_init_out), deferred :: init_out
<<EIO base: interfaces>>=
abstract interface
subroutine eio_init_out (eio, sample, data, success, extension)
import
class(eio_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_init_out
end interface
@ %def eio_init_out
@ Initialize for input. We provide process names. This should open an event
file if appropriate and read header data. The [[md5sum]] can be used to check
the integrity of the configuration, it it provides a checksum to compare with.
In case the extension has changed the extension is also given as an argument.
The [[data]] argument is [[intent(inout)]]: we may read part of it and
keep other parts and/or check them against the data in the file.
<<EIO base: eio: TBP>>=
procedure (eio_init_in), deferred :: init_in
<<EIO base: interfaces>>=
abstract interface
subroutine eio_init_in (eio, sample, data, success, extension)
import
class(eio_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_init_in
end interface
@ %def eio_init_in
@ Re-initialize for output. This should change the status of any event file
from input to output and position it for appending new events.
<<EIO base: eio: TBP>>=
procedure (eio_switch_inout), deferred :: switch_inout
<<EIO base: interfaces>>=
abstract interface
subroutine eio_switch_inout (eio, success)
import
class(eio_t), intent(inout) :: eio
logical, intent(out), optional :: success
end subroutine eio_switch_inout
end interface
@ %def eio_switch_inout
@ This is similar: split the output, i.e., close the current file and open a
new one. The default implementation does nothing. For the feature to work,
an implementation must override this.
<<EIO base: eio: TBP>>=
procedure :: split_out => eio_split_out
<<EIO base: procedures>>=
subroutine eio_split_out (eio)
class(eio_t), intent(inout) :: eio
end subroutine eio_split_out
@ %def eio_split_out
@ Determine the file size in kilobytes. More exactly, determine the
size in units of 1024 storage units, as returned by the INQUIRE statement.
The implementation returns zero if there is no file. The
[[has_file]] flag is set by the [[set_filename]] method, so we can be
confident that the [[inquire]] call is meaningful. If this algorithm
doesn't apply for a particular format, we still can override the
procedure.
<<EIO base: eio: TBP>>=
procedure :: file_size_kbytes => eio_file_size_kbytes
<<EIO base: procedures>>=
function eio_file_size_kbytes (eio) result (kbytes)
class(eio_t), intent(in) :: eio
integer :: kbytes
integer(i64) :: bytes
if (eio%has_file) then
inquire (file = char (eio%filename), size = bytes)
if (bytes > 0) then
kbytes = bytes / 1024
else
kbytes = 0
end if
else
kbytes = 0
end if
end function eio_file_size_kbytes
@ %def eio_file_size_kbytes
@ Output an event. All data can be taken from the [[event]] record.
The index [[i_prc]] identifies the process among the processes that
are contained in the current sample. The [[reading]] flag, if present,
indicates that the event was read from file, not generated.
The [[passed]] flag tells us that this event has passed the selection
criteria. Depending on the event format, we may choose to skip events
that have not passed.
<<EIO base: eio: TBP>>=
procedure (eio_output), deferred :: output
<<EIO base: interfaces>>=
abstract interface
subroutine eio_output &
(eio, event, i_prc, reading, passed, pacify, event_handle)
import
class(eio_t), intent(inout) :: eio
class(generic_event_t), intent(in), target :: event
integer, intent(in) :: i_prc
logical, intent(in), optional :: reading, passed, pacify
class(event_handle_t), intent(inout), optional :: event_handle
end subroutine eio_output
end interface
@ %def eio_output
@ Input an event. This should fill all event data that cannot be inferred
from the associated process.
The input is broken down into two parts. First we read the [[i_prc]]
index. So we know which process to expect in the subsequent event.
If we have reached end of file, we also will know.
Then, we read the event itself.
The parameter [[iostat]] is supposed to be set as the Fortran standard
requires, negative for EOF and positive for error.
<<EIO base: eio: TBP>>=
procedure (eio_input_i_prc), deferred :: input_i_prc
procedure (eio_input_event), deferred :: input_event
<<EIO base: interfaces>>=
abstract interface
subroutine eio_input_i_prc (eio, i_prc, iostat)
import
class(eio_t), intent(inout) :: eio
integer, intent(out) :: i_prc
integer, intent(out) :: iostat
end subroutine eio_input_i_prc
end interface
abstract interface
subroutine eio_input_event (eio, event, iostat, event_handle)
import
class(eio_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_input_event
end interface
@ %def eio_input
@
<<EIO base: eio: TBP>>=
procedure (eio_skip), deferred :: skip
<<EIO base: interfaces>>=
abstract interface
subroutine eio_skip (eio, iostat)
import
class(eio_t), intent(inout) :: eio
integer, intent(out) :: iostat
end subroutine eio_skip
end interface
@ %def eio_skip
@
\subsection{Unit tests}
Test module, followed by the corresponding implementation module.
<<[[eio_base_ut.f90]]>>=
<<File header>>
module eio_base_ut
use unit_tests
use eio_base_uti
<<Standard module head>>
<<EIO base: public test>>
<<EIO base: public test auxiliary>>
contains
<<EIO base: test driver>>
end module eio_base_ut
@ %def eio_base_ut
@
<<[[eio_base_uti.f90]]>>=
<<File header>>
module eio_base_uti
<<Use kinds>>
<<Use strings>>
use io_units
use lorentz
use model_data
use particles
use event_base
use event_handles, only: event_handle_t
use eio_data
use eio_base
<<Standard module head>>
<<EIO base: public test auxiliary>>
<<EIO base: test declarations>>
<<EIO base: test types>>
<<EIO base: test variables>>
contains
<<EIO base: tests>>
<<EIO base: test auxiliary>>
end module eio_base_uti
@ %def eio_base_ut
@ API: driver for the unit tests below.
<<EIO base: public test>>=
public :: eio_base_test
<<EIO base: test driver>>=
subroutine eio_base_test (u, results)
integer, intent(in) :: u
type(test_results_t), intent(inout) :: results
<<EIO base: execute tests>>
end subroutine eio_base_test
@ %def eio_base_test
@ The caller has to provide procedures that prepare and cleanup the test
environment. They depend on modules that are not available here.
<<EIO base: test types>>=
abstract interface
subroutine eio_prepare_event (event, unweighted, n_alt, sample_norm)
import
class(generic_event_t), intent(inout), pointer :: event
logical, intent(in), optional :: unweighted
integer, intent(in), optional :: n_alt
type(string_t), intent(in), optional :: sample_norm
end subroutine eio_prepare_event
end interface
abstract interface
subroutine eio_cleanup_event (event)
import
class(generic_event_t), intent(inout), pointer :: event
end subroutine eio_cleanup_event
end interface
@ We store pointers to the test-environment handlers as module variables.
This allows us to call them from the test routines themselves, which don't
allow for extra arguments.
<<EIO base: public test auxiliary>>=
public :: eio_prepare_test, eio_cleanup_test
<<EIO base: test types>>=
procedure(eio_prepare_event), pointer :: eio_prepare_test => null ()
procedure(eio_cleanup_event), pointer :: eio_cleanup_test => null ()
@ %def eio_prepare_test eio_cleanup_test
@ Similarly, for the fallback (hadron) model that some eio tests require:
<<EIO base: test types>>=
abstract interface
subroutine eio_prepare_model (model)
import
class(model_data_t), intent(inout), pointer :: model
end subroutine eio_prepare_model
end interface
abstract interface
subroutine eio_cleanup_model (model)
import
class(model_data_t), intent(inout), target :: model
end subroutine eio_cleanup_model
end interface
<<EIO base: public test auxiliary>>=
public :: eio_prepare_fallback_model, eio_cleanup_fallback_model
<<EIO base: test variables>>=
procedure(eio_prepare_model), pointer :: eio_prepare_fallback_model => null ()
procedure(eio_cleanup_model), pointer :: eio_cleanup_fallback_model => null ()
@ %def eio_prepare_fallback_model eio_cleanup_fallback_model
@
\subsubsection{Test type for event I/O}
The contents simulate the contents of an external file. We have the
[[sample]] string as the file name and the array of momenta
[[event_p]] as the list of events. The
second index is the event index. The [[event_i]] component is the pointer
to the current event, [[event_n]] is the total number of stored events.
<<EIO base: test types>>=
type, extends (eio_t) :: eio_test_t
integer :: event_n = 0
integer :: event_i = 0
integer :: i_prc = 0
type(vector4_t), dimension(:,:), allocatable :: event_p
contains
<<EIO base: eio test: TBP>>
end type eio_test_t
@ %def eio_test_t
@ Write to screen. Pretend that this is an actual event format.
<<EIO base: eio test: TBP>>=
procedure :: write => eio_test_write
<<EIO base: test auxiliary>>=
subroutine eio_test_write (object, unit)
class(eio_test_t), intent(in) :: object
integer, intent(in), optional :: unit
integer :: u, i
u = given_output_unit (unit)
write (u, "(1x,A)") "Test event stream"
if (object%event_i /= 0) then
write (u, "(1x,A,I0,A)") "Event #", object%event_i, ":"
do i = 1, size (object%event_p, 1)
call vector4_write (object%event_p(i, object%event_i), u)
end do
end if
end subroutine eio_test_write
@ %def eio_test_write
@ Finalizer. For the test case, we just reset the event count,
but keep the stored ``events''. For the real implementations, the events
would be stored on an external medium, so we would delete the object
contents.
<<EIO base: eio test: TBP>>=
procedure :: final => eio_test_final
<<EIO base: test auxiliary>>=
subroutine eio_test_final (object)
class(eio_test_t), intent(inout) :: object
object%event_i = 0
end subroutine eio_test_final
@ %def eio_test_final
@ Initialization: We store the process IDs and the energy from the beam-data
object. We also allocate the momenta (i.e., the simulated event record) for a
fixed maximum size of 10 events, 2 momenta each. There is only a single
process.
<<EIO base: eio test: TBP>>=
procedure :: init_out => eio_test_init_out
<<EIO base: test auxiliary>>=
subroutine eio_test_init_out (eio, sample, data, success, extension)
class(eio_test_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
eio%sample = sample
eio%event_n = 0
eio%event_i = 0
allocate (eio%event_p (2, 10))
if (present (success)) success = .true.
end subroutine eio_test_init_out
@ %def eio_test_init_out
@ Initialization for input. Nothing to do for the test type.
<<EIO base: eio test: TBP>>=
procedure :: init_in => eio_test_init_in
<<EIO base: test auxiliary>>=
subroutine eio_test_init_in (eio, sample, data, success, extension)
class(eio_test_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
if (present (success)) success = .true.
end subroutine eio_test_init_in
@ %def eio_test_init_in
@ Switch from output to input. Again, nothing to do for the test type.
<<EIO base: eio test: TBP>>=
procedure :: switch_inout => eio_test_switch_inout
<<EIO base: test auxiliary>>=
subroutine eio_test_switch_inout (eio, success)
class(eio_test_t), intent(inout) :: eio
logical, intent(out), optional :: success
if (present (success)) success = .true.
end subroutine eio_test_switch_inout
@ %def eio_test_switch_inout
@ Output. Increment the event counter and store the momenta of the current
event.
<<EIO base: eio test: TBP>>=
procedure :: output => eio_test_output
<<EIO base: test auxiliary>>=
subroutine eio_test_output &
(eio, event, i_prc, reading, passed, pacify, event_handle)
class(eio_test_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
type(particle_t) :: prt
eio%event_n = eio%event_n + 1
eio%event_i = eio%event_n
eio%i_prc = i_prc
pset => event%get_particle_set_ptr ()
prt = pset%get_particle (3)
eio%event_p(1, eio%event_i) = prt%get_momentum ()
prt = pset%get_particle (4)
eio%event_p(2, eio%event_i) = prt%get_momentum ()
end subroutine eio_test_output
@ %def eio_test_output
@ Input. Increment the event counter and retrieve the momenta of the current
event. For the test case, we do not actually modify the current event.
<<EIO base: eio test: TBP>>=
procedure :: input_i_prc => eio_test_input_i_prc
procedure :: input_event => eio_test_input_event
<<EIO base: test auxiliary>>=
subroutine eio_test_input_i_prc (eio, i_prc, iostat)
class(eio_test_t), intent(inout) :: eio
integer, intent(out) :: i_prc
integer, intent(out) :: iostat
i_prc = eio%i_prc
iostat = 0
end subroutine eio_test_input_i_prc
subroutine eio_test_input_event (eio, event, iostat, event_handle)
class(eio_test_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
eio%event_i = eio%event_i + 1
iostat = 0
end subroutine eio_test_input_event
@ %def eio_test_input_i_prc
@ %def eio_test_input_event
@
<<EIO base: eio test: TBP>>=
procedure :: skip => eio_test_skip
<<EIO base: test auxiliary>>=
subroutine eio_test_skip (eio, iostat)
class(eio_test_t), intent(inout) :: eio
integer, intent(out) :: iostat
iostat = 0
end subroutine eio_test_skip
@ %def eio_test_skip
@
\subsubsection{Test I/O methods}
<<EIO base: execute tests>>=
call test (eio_base_1, "eio_base_1", &
"read and write event contents", &
u, results)
<<EIO base: test declarations>>=
public :: eio_base_1
<<EIO base: tests>>=
subroutine eio_base_1 (u)
integer, intent(in) :: u
class(generic_event_t), pointer :: event
class(eio_t), allocatable :: eio
integer :: i_prc, iostat
type(string_t) :: sample
write (u, "(A)") "* Test output: eio_base_1"
write (u, "(A)") "* Purpose: generate and read/write an event"
write (u, "(A)")
write (u, "(A)") "* Initialize test process"
call eio_prepare_test (event, unweighted = .false.)
write (u, "(A)")
write (u, "(A)") "* Generate and write an event"
write (u, "(A)")
sample = "eio_test1"
allocate (eio_test_t :: eio)
call eio%init_out (sample)
call event%generate (1, [0._default, 0._default])
call eio%output (event, 42)
call eio%write (u)
call eio%final ()
write (u, "(A)")
write (u, "(A)") "* Re-read the event"
write (u, "(A)")
call eio%init_in (sample)
call eio%input_i_prc (i_prc, iostat)
call eio%input_event (event, iostat)
call eio%write (u)
write (u, "(A)")
write (u, "(1x,A,I0)") "i = ", i_prc
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 eio%output (event, 5)
call eio%write (u)
call eio%final ()
write (u, "(A)")
write (u, "(A)") "* Re-read both events"
write (u, "(A)")
call eio%init_in (sample)
call eio%input_i_prc (i_prc, iostat)
call eio%input_event (event, iostat)
call eio%input_i_prc (i_prc, iostat)
call eio%input_event (event, iostat)
call eio%write (u)
write (u, "(A)")
write (u, "(1x,A,I0)") "i = ", i_prc
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call eio%final ()
deallocate (eio)
call eio_cleanup_test (event)
write (u, "(A)")
write (u, "(A)") "* Test output end: eio_base_1"
end subroutine eio_base_1
@ %def eio_base_1
@
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{Direct Event Access}
As a convenient application of the base type, we construct an event
handler that allows us of setting and retrieving events just in the
same way as an file I/O format, but directly dealing with particle
data and momenta. This is an input and output format, but we do not
care about counting events.
<<[[eio_direct.f90]]>>=
<<File header>>
module eio_direct
<<Use kinds>>
<<Use strings>>
use io_units
use diagnostics
use cputime
use lorentz, only: vector4_t
use particles, only: particle_set_t
use model_data, only: model_data_t
use event_base
use event_handles, only: event_handle_t
use eio_data
use eio_base
<<Standard module head>>
<<EIO direct: public>>
<<EIO direct: types>>
contains
<<EIO direct: procedures>>
end module eio_direct
@ %def eio_direct
@
\subsection{Type}
<<EIO direct: public>>=
public :: eio_direct_t
<<EIO direct: types>>=
type, extends (eio_t) :: eio_direct_t
private
logical :: i_evt_set = .false.
integer :: i_evt = 0
integer :: i_prc = 0
integer :: i_mci = 0
integer :: i_term = 0
integer :: channel = 0
logical :: passed_set = .false.
logical :: passed = .true.
type(particle_set_t) :: pset
contains
<<EIO direct: eio direct: TBP>>
end type eio_direct_t
@ %def eio_direct_t
@
\subsection{Common Methods}
Output.
<<EIO direct: eio direct: TBP>>=
procedure :: write => eio_direct_write
<<EIO direct: procedures>>=
subroutine eio_direct_write (object, unit)
class(eio_direct_t), intent(in) :: object
integer, intent(in), optional :: unit
integer :: u
u = given_output_unit (unit)
write (u, "(1x,A)") "Event direct access:"
if (object%i_evt_set) then
write (u, "(3x,A,1x,I0)") "i_evt =", object%i_evt
else
write (u, "(3x,A)") "i_evt = [undefined]"
end if
write (u, "(3x,A,1x,I0)") "i_prc =", object%i_prc
write (u, "(3x,A,1x,I0)") "i_mci =", object%i_prc
write (u, "(3x,A,1x,I0)") "i_term =", object%i_prc
write (u, "(3x,A,1x,I0)") "channel =", object%i_prc
if (object%passed_set) then
write (u, "(3x,A,1x,L1)") "passed =", object%passed
else
write (u, "(3x,A)") "passed = [N/A]"
end if
call object%pset%write (u)
end subroutine eio_direct_write
@ %def eio_direct_write
@ Finalizer: trivial.
<<EIO direct: eio direct: TBP>>=
procedure :: final => eio_direct_final
<<EIO direct: procedures>>=
subroutine eio_direct_final (object)
class(eio_direct_t), intent(inout) :: object
call object%pset%final ()
end subroutine eio_direct_final
@ %def eio_direct_final
@ Initialize for input and/or output, both are identical
<<EIO direct: eio direct: TBP>>=
procedure :: init_out => eio_direct_init_out
<<EIO direct: procedures>>=
subroutine eio_direct_init_out (eio, sample, data, success, extension)
class(eio_direct_t), intent(inout) :: eio
type(string_t), intent(in) :: sample
type(string_t), intent(in), optional :: extension
type(event_sample_data_t), intent(in), optional :: data
logical, intent(out), optional :: success
if (present (success)) success = .true.
end subroutine eio_direct_init_out
@ %def eio_direct_init_out
@
<<EIO direct: eio direct: TBP>>=
procedure :: init_in => eio_direct_init_in
<<EIO direct: procedures>>=
subroutine eio_direct_init_in (eio, sample, data, success, extension)
class(eio_direct_t), intent(inout) :: eio
type(string_t), intent(in) :: sample
type(string_t), intent(in), optional :: extension
type(event_sample_data_t), intent(inout), optional :: data
logical, intent(out), optional :: success
if (present (success)) success = .true.
end subroutine eio_direct_init_in
@ %def eio_direct_init_in
@ Switch from input to output: no-op
<<EIO direct: eio direct: TBP>>=
procedure :: switch_inout => eio_direct_switch_inout
<<EIO direct: procedures>>=
subroutine eio_direct_switch_inout (eio, success)
class(eio_direct_t), intent(inout) :: eio
logical, intent(out), optional :: success
if (present (success)) success = .true.
end subroutine eio_direct_switch_inout
@ %def eio_direct_switch_inout
@ Output: transfer event contents from the [[event]] object to the
[[eio]] object. Note that finalization of the particle set is not
(yet) automatic.
<<EIO direct: eio direct: TBP>>=
procedure :: output => eio_direct_output
<<EIO direct: procedures>>=
subroutine eio_direct_output &
(eio, event, i_prc, reading, passed, pacify, event_handle)
class(eio_direct_t), intent(inout) :: eio
class(generic_event_t), intent(in), target :: event
integer, intent(in) :: i_prc
logical, intent(in), optional :: reading, passed, pacify
class(event_handle_t), intent(inout), optional :: event_handle
type(particle_set_t), pointer :: pset_ptr
call eio%pset%final ()
if (event%has_index ()) then
call eio%set_event_index (event%get_index ())
else
call eio%reset_event_index ()
end if
if (present (passed)) then
eio%passed = passed
eio%passed_set = .true.
else
eio%passed_set = .false.
end if
pset_ptr => event%get_particle_set_ptr ()
if (associated (pset_ptr)) then
eio%i_prc = i_prc
eio%pset = pset_ptr
end if
end subroutine eio_direct_output
@ %def eio_direct_output
@ Input: transfer event contents from the [[eio]] object to the
[[event]] object. The [[i_prc]] parameter has been stored inside the
[[eio]] record before.
<<EIO direct: eio direct: TBP>>=
procedure :: input_i_prc => eio_direct_input_i_prc
procedure :: input_event => eio_direct_input_event
<<EIO direct: procedures>>=
subroutine eio_direct_input_i_prc (eio, i_prc, iostat)
class(eio_direct_t), intent(inout) :: eio
integer, intent(out) :: i_prc
integer, intent(out) :: iostat
i_prc = eio%i_prc
iostat = 0
end subroutine eio_direct_input_i_prc
subroutine eio_direct_input_event (eio, event, iostat, event_handle)
class(eio_direct_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
call event%select (eio%i_mci, eio%i_term, eio%channel)
if (eio%has_event_index ()) then
call event%set_index (eio%get_event_index ())
else
call event%reset_index ()
end if
call event%set_hard_particle_set (eio%pset)
end subroutine eio_direct_input_event
@ %def eio_direct_input_i_prc
@ %def eio_direct_input_event
@ No-op.
<<EIO direct: eio direct: TBP>>=
procedure :: skip => eio_direct_skip
<<EIO direct: procedures>>=
subroutine eio_direct_skip (eio, iostat)
class(eio_direct_t), intent(inout) :: eio
integer, intent(out) :: iostat
iostat = 0
end subroutine eio_direct_skip
@ %def eio_direct_skip
@
\subsection{Retrieve individual contents}
<<EIO direct: eio direct: TBP>>=
procedure :: has_event_index => eio_direct_has_event_index
procedure :: get_event_index => eio_direct_get_event_index
procedure :: passed_known => eio_direct_passed_known
procedure :: has_passed => eio_direct_has_passed
procedure :: get_n_in => eio_direct_get_n_in
procedure :: get_n_out => eio_direct_get_n_out
procedure :: get_n_tot => eio_direct_get_n_tot
<<EIO direct: procedures>>=
function eio_direct_has_event_index (eio) result (flag)
class(eio_direct_t), intent(in) :: eio
logical :: flag
flag = eio%i_evt_set
end function eio_direct_has_event_index
function eio_direct_get_event_index (eio) result (index)
class(eio_direct_t), intent(in) :: eio
integer :: index
if (eio%has_event_index ()) then
index = eio%i_evt
else
index = 0
end if
end function eio_direct_get_event_index
function eio_direct_passed_known (eio) result (flag)
class(eio_direct_t), intent(in) :: eio
logical :: flag
flag = eio%passed_set
end function eio_direct_passed_known
function eio_direct_has_passed (eio) result (flag)
class(eio_direct_t), intent(in) :: eio
logical :: flag
if (eio%passed_known ()) then
flag = eio%passed
else
flag = .true.
end if
end function eio_direct_has_passed
function eio_direct_get_n_in (eio) result (n_in)
class(eio_direct_t), intent(in) :: eio
integer :: n_in
n_in = eio%pset%get_n_in ()
end function eio_direct_get_n_in
function eio_direct_get_n_out (eio) result (n_out)
class(eio_direct_t), intent(in) :: eio
integer :: n_out
n_out = eio%pset%get_n_out ()
end function eio_direct_get_n_out
function eio_direct_get_n_tot (eio) result (n_tot)
class(eio_direct_t), intent(in) :: eio
integer :: n_tot
n_tot = eio%pset%get_n_tot ()
end function eio_direct_get_n_tot
@ %def eio_direct_has_event_index
@ %def eio_direct_get_event_index
@ %def eio_direct_passed_known
@ %def eio_direct_has_passed
@ %def eio_direct_get_n_in
@ %def eio_direct_get_n_out
@ %def eio_direct_get_n_tot
@ All momenta as a single allocatable array.
<<EIO direct: eio direct: TBP>>=
procedure :: get_momentum_array => eio_direct_get_momentum_array
<<EIO direct: procedures>>=
subroutine eio_direct_get_momentum_array (eio, p)
class(eio_direct_t), intent(in) :: eio
type(vector4_t), dimension(:), allocatable, intent(out) :: p
integer :: n
n = eio%get_n_tot ()
allocate (p (n))
p(:) = eio%pset%get_momenta ()
end subroutine eio_direct_get_momentum_array
@ %def eio_direct_get_momentum_array
@
\subsection{Manual access}
Build the contained particle set from scratch.
<<EIO direct: eio direct: TBP>>=
procedure :: init_direct => eio_direct_init_direct
<<EIO direct: procedures>>=
subroutine eio_direct_init_direct &
(eio, n_beam, n_in, n_rem, n_vir, n_out, pdg, model)
class(eio_direct_t), intent(out) :: eio
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
call eio%pset%init_direct (n_beam, n_in, n_rem, n_vir, n_out, pdg, model)
end subroutine eio_direct_init_direct
@ %def eio_direct_init_direct
@ Set/reset the event index, which is optional.
<<EIO direct: eio direct: TBP>>=
procedure :: set_event_index => eio_direct_set_event_index
procedure :: reset_event_index => eio_direct_reset_event_index
<<EIO direct: procedures>>=
subroutine eio_direct_set_event_index (eio, index)
class(eio_direct_t), intent(inout) :: eio
integer, intent(in) :: index
eio%i_evt = index
eio%i_evt_set = .true.
end subroutine eio_direct_set_event_index
subroutine eio_direct_reset_event_index (eio)
class(eio_direct_t), intent(inout) :: eio
eio%i_evt_set = .false.
end subroutine eio_direct_reset_event_index
@ %def eio_direct_set_event_index
@ %def eio_direct_reset_event_index
@ Set the selection indices. This is supposed to select the [[i_prc]],
[[i_mci]], [[i_term]], and [[channel]]
entries of the event where the momentum set has to be stored, respectively.
The selection indices determine the process, MCI set, calculation term, and
phase-space channel is to be used for recalculation. The index values must
not be zero, even if the do not apply.
<<EIO direct: eio direct: TBP>>=
procedure :: set_selection_indices => eio_direct_set_selection_indices
<<EIO direct: procedures>>=
subroutine eio_direct_set_selection_indices &
(eio, i_prc, i_mci, i_term, channel)
class(eio_direct_t), intent(inout) :: eio
integer, intent(in) :: i_prc
integer, intent(in) :: i_mci
integer, intent(in) :: i_term
integer, intent(in) :: channel
eio%i_prc = i_prc
eio%i_mci = i_mci
eio%i_term = i_term
eio%channel = channel
end subroutine eio_direct_set_selection_indices
@ %def eio_direct_set_i_prc
@ Set momentum (or momenta -- elemental).
<<EIO direct: eio direct: TBP>>=
generic :: set_momentum => set_momentum_single
generic :: set_momentum => set_momentum_all
procedure :: set_momentum_single => eio_direct_set_momentum_single
procedure :: set_momentum_all => eio_direct_set_momentum_all
<<EIO direct: procedures>>=
subroutine eio_direct_set_momentum_single (eio, i, p, p2, on_shell)
class(eio_direct_t), intent(inout) :: eio
integer, intent(in) :: i
type(vector4_t), intent(in) :: p
real(default), intent(in), optional :: p2
logical, intent(in), optional :: on_shell
call eio%pset%set_momentum (i, p, p2, on_shell)
end subroutine eio_direct_set_momentum_single
subroutine eio_direct_set_momentum_all (eio, p, p2, on_shell)
class(eio_direct_t), intent(inout) :: eio
type(vector4_t), dimension(:), intent(in) :: p
real(default), dimension(:), intent(in), optional :: p2
logical, intent(in), optional :: on_shell
call eio%pset%set_momentum (p, p2, on_shell)
end subroutine eio_direct_set_momentum_all
@ %def eio_direct_set_momentum
@
\subsection{Unit tests}
Test module, followed by the corresponding implementation module.
<<[[eio_direct_ut.f90]]>>=
<<File header>>
module eio_direct_ut
use unit_tests
use eio_direct_uti
<<Standard module head>>
<<EIO direct: public test>>
contains
<<EIO direct: test driver>>
end module eio_direct_ut
@ %def eio_direct_ut
@
<<[[eio_direct_uti.f90]]>>=
<<File header>>
module eio_direct_uti
<<Use kinds>>
<<Use strings>>
use lorentz, only: vector4_t
use model_data, only: model_data_t
use event_base
use eio_data
use eio_base
use eio_direct
use eio_base_ut, only: eio_prepare_test, eio_cleanup_test
<<Standard module head>>
<<EIO direct: test declarations>>
contains
<<EIO direct: tests>>
end module eio_direct_uti
@ %def eio_direct_ut
@ API: driver for the unit tests below.
<<EIO direct: public test>>=
public :: eio_direct_test
<<EIO direct: test driver>>=
subroutine eio_direct_test (u, results)
integer, intent(in) :: u
type(test_results_t), intent(inout) :: results
<<EIO direct: execute tests>>
end subroutine eio_direct_test
@ %def eio_direct_test
@
\subsubsection{Test I/O methods}
We test the implementation of all I/O methods.
<<EIO direct: execute tests>>=
call test (eio_direct_1, "eio_direct_1", &
"read and write event contents", &
u, results)
<<EIO direct: test declarations>>=
public :: eio_direct_1
<<EIO direct: tests>>=
subroutine eio_direct_1 (u)
integer, intent(in) :: u
class(generic_event_t), pointer :: event
class(eio_t), allocatable :: eio
type(event_sample_data_t) :: data
type(string_t) :: sample
type(vector4_t), dimension(:), allocatable :: p
class(model_data_t), pointer :: model
integer :: i, n_events, iostat, i_prc
write (u, "(A)") "* Test output: eio_direct_1"
write (u, "(A)") "* Purpose: generate and read/write an event"
write (u, "(A)")
write (u, "(A)") "* Initialize test process"
call eio_prepare_test (event, unweighted = .false.)
write (u, "(A)")
write (u, "(A)") "* Initial state"
write (u, "(A)")
allocate (eio_direct_t :: eio)
call eio%write (u)
write (u, "(A)")
write (u, "(A)") "* Extract an empty event"
write (u, "(A)")
call eio%output (event, 1)
call eio%write (u)
write (u, "(A)")
write (u, "(A)") "* Retrieve contents"
write (u, "(A)")
select type (eio)
class is (eio_direct_t)
if (eio%has_event_index ()) write (u, "(A,1x,I0)") "index =", eio%get_event_index ()
if (eio%passed_known ()) write (u, "(A,1x,L1)") "passed =", eio%has_passed ()
write (u, "(A,1x,I0)") "n_in =", eio%get_n_in ()
write (u, "(A,1x,I0)") "n_out =", eio%get_n_out ()
end select
write (u, "(A)")
write (u, "(A)") "* Generate and extract an event"
write (u, "(A)")
call event%generate (1, [0._default, 0._default])
call event%set_index (42)
model => event%get_model_ptr ()
sample = ""
call eio%init_out (sample)
call eio%output (event, 1, passed = .true.)
call eio%write (u)
write (u, "(A)")
write (u, "(A)") "* Retrieve contents"
write (u, "(A)")
select type (eio)
class is (eio_direct_t)
if (eio%has_event_index ()) write (u, "(A,1x,I0)") "index =", eio%get_event_index ()
if (eio%passed_known ()) write (u, "(A,1x,L1)") "passed =", eio%has_passed ()
write (u, "(A,1x,I0)") "n_in =", eio%get_n_in ()
write (u, "(A,1x,I0)") "n_out =", eio%get_n_out ()
end select
select type (eio)
class is (eio_direct_t)
call eio%get_momentum_array (p)
if (allocated (p)) then
write (u, "(A)") "p[3] ="
call p(3)%write (u)
end if
end select
write (u, "(A)")
write (u, "(A)") "* Re-create an eio event record: initialization"
write (u, "(A)")
call eio%final ()
select type (eio)
class is (eio_direct_t)
call eio%init_direct ( &
n_beam = 0, n_in = 2, n_rem = 0, n_vir = 0, n_out = 2, &
pdg = [25, 25, 25, 25], model = model)
call eio%set_event_index (42)
call eio%set_selection_indices (1, 1, 1, 1)
call eio%write (u)
end select
write (u, "(A)")
write (u, "(A)") "* Re-create an eio event record: &
&set momenta, interchanged"
write (u, "(A)")
select type (eio)
class is (eio_direct_t)
call eio%set_momentum (p([1,2,4,3]), on_shell=.true.)
call eio%write (u)
end select
write (u, "(A)")
write (u, "(A)") "* 'read' i_prc"
write (u, "(A)")
call eio%input_i_prc (i_prc, iostat)
write (u, "(1x,A,1x,I0)") "i_prc =", i_prc
write (u, "(1x,A,1x,I0)") "iostat =", iostat
write (u, "(A)")
write (u, "(A)") "* 'read' (fill) event"
write (u, "(A)")
call eio%input_event (event, iostat)
write (u, "(1x,A,1x,I0)") "iostat =", iostat
write (u, "(A)")
call event%write (u)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call eio%final ()
deallocate (eio)
call eio_cleanup_test (event)
write (u, "(A)")
write (u, "(A)") "* Test output end: eio_direct_1"
end subroutine eio_direct_1
@ %def eio_direct_1
@
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{Event Generation Checkpoints}
This is an output-only format. Its only use is to write screen
messages every $n$ events, to inform the user about progress.
<<[[eio_checkpoints.f90]]>>=
<<File header>>
module eio_checkpoints
<<Use strings>>
use io_units
use diagnostics
use cputime
use event_base
use event_handles, only: event_handle_t
use eio_data
use eio_base
<<Standard module head>>
<<EIO checkpoints: public>>
<<EIO checkpoints: parameters>>
<<EIO checkpoints: types>>
contains
<<EIO checkpoints: procedures>>
end module eio_checkpoints
@ %def eio_checkpoints
@
\subsection{Type}
<<EIO checkpoints: public>>=
public :: eio_checkpoints_t
<<EIO checkpoints: types>>=
type, extends (eio_t) :: eio_checkpoints_t
logical :: active = .false.
logical :: running = .false.
integer :: val = 0
integer :: n_events = 0
integer :: n_read = 0
integer :: i_evt = 0
logical :: blank = .false.
type(timer_t) :: timer
contains
<<EIO checkpoints: eio checkpoints: TBP>>
end type eio_checkpoints_t
@ %def eio_checkpoints_t
@
\subsection{Specific Methods}
Set parameters that are specifically used for checkpointing.
<<EIO checkpoints: eio checkpoints: TBP>>=
procedure :: set_parameters => eio_checkpoints_set_parameters
<<EIO checkpoints: procedures>>=
subroutine eio_checkpoints_set_parameters (eio, checkpoint, blank)
class(eio_checkpoints_t), intent(inout) :: eio
integer, intent(in) :: checkpoint
logical, intent(in), optional :: blank
eio%val = checkpoint
if (present (blank)) eio%blank = blank
end subroutine eio_checkpoints_set_parameters
@ %def eio_checkpoints_set_parameters
@
\subsection{Common Methods}
Output. This is not the actual event format, but a readable account
of the current status.
<<EIO checkpoints: eio checkpoints: TBP>>=
procedure :: write => eio_checkpoints_write
<<EIO checkpoints: procedures>>=
subroutine eio_checkpoints_write (object, unit)
class(eio_checkpoints_t), intent(in) :: object
integer, intent(in), optional :: unit
integer :: u
u = given_output_unit (unit)
if (object%active) then
write (u, "(1x,A)") "Event-sample checkpoints: active"
write (u, "(3x,A,I0)") "interval = ", object%val
write (u, "(3x,A,I0)") "n_events = ", object%n_events
write (u, "(3x,A,I0)") "n_read = ", object%n_read
write (u, "(3x,A,I0)") "n_current = ", object%i_evt
write (u, "(3x,A,L1)") "blanking = ", object%blank
call object%timer%write (u)
else
write (u, "(1x,A)") "Event-sample checkpoints: off"
end if
end subroutine eio_checkpoints_write
@ %def eio_checkpoints_write
@ Finalizer: trivial.
<<EIO checkpoints: eio checkpoints: TBP>>=
procedure :: final => eio_checkpoints_final
<<EIO checkpoints: procedures>>=
subroutine eio_checkpoints_final (object)
class(eio_checkpoints_t), intent(inout) :: object
object%active = .false.
end subroutine eio_checkpoints_final
@ %def eio_checkpoints_final
@ Activate checkpointing for event generation or writing.
<<EIO checkpoints: eio checkpoints: TBP>>=
procedure :: init_out => eio_checkpoints_init_out
<<EIO checkpoints: procedures>>=
subroutine eio_checkpoints_init_out (eio, sample, data, success, extension)
class(eio_checkpoints_t), intent(inout) :: eio
type(string_t), intent(in) :: sample
type(string_t), intent(in), optional :: extension
type(event_sample_data_t), intent(in), optional :: data
logical, intent(out), optional :: success
if (present (data)) then
if (eio%val > 0) then
eio%active = .true.
eio%i_evt = 0
eio%n_read = 0
eio%n_events = data%n_evt * data%nlo_multiplier
end if
end if
if (present (success)) success = .true.
end subroutine eio_checkpoints_init_out
@ %def eio_checkpoints_init_out
@ No checkpointing for event reading.
<<EIO checkpoints: eio checkpoints: TBP>>=
procedure :: init_in => eio_checkpoints_init_in
<<EIO checkpoints: procedures>>=
subroutine eio_checkpoints_init_in (eio, sample, data, success, extension)
class(eio_checkpoints_t), intent(inout) :: eio
type(string_t), intent(in) :: sample
type(string_t), intent(in), optional :: extension
type(event_sample_data_t), intent(inout), optional :: data
logical, intent(out), optional :: success
call msg_bug ("Event checkpoints: event input not supported")
if (present (success)) success = .false.
end subroutine eio_checkpoints_init_in
@ %def eio_checkpoints_init_in
@ Switch from input to output: also not supported.
<<EIO checkpoints: eio checkpoints: TBP>>=
procedure :: switch_inout => eio_checkpoints_switch_inout
<<EIO checkpoints: procedures>>=
subroutine eio_checkpoints_switch_inout (eio, success)
class(eio_checkpoints_t), intent(inout) :: eio
logical, intent(out), optional :: success
call msg_bug ("Event checkpoints: in-out switch not supported")
if (present (success)) success = .false.
end subroutine eio_checkpoints_switch_inout
@ %def eio_checkpoints_switch_inout
@ Checkpoints: display progress for the current event, if applicable.
<<EIO checkpoints: eio checkpoints: TBP>>=
procedure :: output => eio_checkpoints_output
<<EIO checkpoints: procedures>>=
subroutine eio_checkpoints_output &
(eio, event, i_prc, reading, passed, pacify, event_handle)
class(eio_checkpoints_t), intent(inout) :: eio
class(generic_event_t), intent(in), target :: event
integer, intent(in) :: i_prc
logical, intent(in), optional :: reading, passed, pacify
class(event_handle_t), intent(inout), optional :: event_handle
logical :: rd
rd = .false.; if (present (reading)) rd = reading
if (eio%active) then
if (.not. eio%running) call eio%startup ()
if (eio%running) then
eio%i_evt = eio%i_evt + 1
if (rd) then
eio%n_read = eio%n_read + 1
else if (mod (eio%i_evt, eio%val) == 0) then
call eio%message (eio%blank)
end if
if (eio%i_evt == eio%n_events) call eio%shutdown ()
end if
end if
end subroutine eio_checkpoints_output
@ %def eio_checkpoints_output
@ When the first event is called, we have to initialize the screen output.
<<EIO checkpoints: eio checkpoints: TBP>>=
procedure :: startup => eio_checkpoints_startup
<<EIO checkpoints: procedures>>=
subroutine eio_checkpoints_startup (eio)
class(eio_checkpoints_t), intent(inout) :: eio
if (eio%active .and. eio%i_evt < eio%n_events) then
call msg_message ("")
call msg_message (checkpoint_bar)
call msg_message (checkpoint_head)
call msg_message (checkpoint_bar)
write (msg_buffer, checkpoint_fmt) 0., 0, eio%n_events - eio%i_evt, "???"
call msg_message ()
eio%running = .true.
call eio%timer%start ()
end if
end subroutine eio_checkpoints_startup
@ %def eio_checkpoints_startup
@ This message is printed at every checkpoint.
<<EIO checkpoints: eio checkpoints: TBP>>=
procedure :: message => eio_checkpoints_message
<<EIO checkpoints: procedures>>=
subroutine eio_checkpoints_message (eio, testflag)
class(eio_checkpoints_t), intent(inout) :: eio
logical, intent(in), optional :: testflag
real :: t
type(time_t) :: time_remaining
type(string_t) :: time_string
call eio%timer%stop ()
t = eio%timer
call eio%timer%restart ()
time_remaining = &
nint (t / (eio%i_evt - eio%n_read) * (eio%n_events - eio%i_evt))
time_string = time_remaining%to_string_ms (blank = testflag)
write (msg_buffer, checkpoint_fmt) &
100 * (eio%i_evt - eio%n_read) / real (eio%n_events - eio%n_read), &
eio%i_evt - eio%n_read, &
eio%n_events - eio%i_evt, &
char (time_string)
call msg_message ()
end subroutine eio_checkpoints_message
@ %def eio_checkpoints_message
@ When the last event is called, wrap up.
<<EIO checkpoints: eio checkpoints: TBP>>=
procedure :: shutdown => eio_checkpoints_shutdown
<<EIO checkpoints: procedures>>=
subroutine eio_checkpoints_shutdown (eio)
class(eio_checkpoints_t), intent(inout) :: eio
if (mod (eio%i_evt, eio%val) /= 0) then
write (msg_buffer, checkpoint_fmt) &
100., eio%i_evt - eio%n_read, 0, "0m:00s"
call msg_message ()
end if
call msg_message (checkpoint_bar)
call msg_message ("")
eio%running = .false.
end subroutine eio_checkpoints_shutdown
@ %def eio_checkpoints_shutdown
<<EIO checkpoints: eio checkpoints: TBP>>=
procedure :: input_i_prc => eio_checkpoints_input_i_prc
procedure :: input_event => eio_checkpoints_input_event
<<EIO checkpoints: procedures>>=
subroutine eio_checkpoints_input_i_prc (eio, i_prc, iostat)
class(eio_checkpoints_t), intent(inout) :: eio
integer, intent(out) :: i_prc
integer, intent(out) :: iostat
call msg_bug ("Event checkpoints: event input not supported")
i_prc = 0
iostat = 1
end subroutine eio_checkpoints_input_i_prc
subroutine eio_checkpoints_input_event (eio, event, iostat, event_handle)
class(eio_checkpoints_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
call msg_bug ("Event checkpoints: event input not supported")
iostat = 1
end subroutine eio_checkpoints_input_event
@ %def eio_checkpoints_input_i_prc
@ %def eio_checkpoints_input_event
@
<<EIO checkpoints: eio checkpoints: TBP>>=
procedure :: skip => eio_checkpoints_skip
<<EIO checkpoints: procedures>>=
subroutine eio_checkpoints_skip (eio, iostat)
class(eio_checkpoints_t), intent(inout) :: eio
integer, intent(out) :: iostat
iostat = 0
end subroutine eio_checkpoints_skip
@ %def eio_checkpoints_skip
@
\subsection{Message header}
<<EIO checkpoints: parameters>>=
character(*), parameter :: &
checkpoint_head = "| % complete | events generated | events remaining &
&| time remaining"
character(*), parameter :: &
checkpoint_bar = "|==================================================&
&=================|"
character(*), parameter :: &
checkpoint_fmt = "(' ',F5.1,T16,I9,T35,I9,T58,A)"
@ %def checkpoint_head
@ %def checkpoint_bar
@ %def checkpoint_fmt
@ %def checkpointing_t
@
\subsection{Unit tests}
Test module, followed by the corresponding implementation module.
<<[[eio_checkpoints_ut.f90]]>>=
<<File header>>
module eio_checkpoints_ut
use unit_tests
use eio_checkpoints_uti
<<Standard module head>>
<<EIO checkpoints: public test>>
contains
<<EIO checkpoints: test driver>>
end module eio_checkpoints_ut
@ %def eio_checkpoints_ut
@
<<[[eio_checkpoints_uti.f90]]>>=
<<File header>>
module eio_checkpoints_uti
<<Use kinds>>
<<Use strings>>
use event_base
use eio_data
use eio_base
use eio_checkpoints
use eio_base_ut, only: eio_prepare_test, eio_cleanup_test
<<Standard module head>>
<<EIO checkpoints: test declarations>>
contains
<<EIO checkpoints: tests>>
end module eio_checkpoints_uti
@ %def eio_checkpoints_ut
@ API: driver for the unit tests below.
<<EIO checkpoints: public test>>=
public :: eio_checkpoints_test
<<EIO checkpoints: test driver>>=
subroutine eio_checkpoints_test (u, results)
integer, intent(in) :: u
type(test_results_t), intent(inout) :: results
<<EIO checkpoints: execute tests>>
end subroutine eio_checkpoints_test
@ %def eio_checkpoints_test
@
\subsubsection{Test I/O methods}
We test the implementation of all I/O methods.
<<EIO checkpoints: execute tests>>=
call test (eio_checkpoints_1, "eio_checkpoints_1", &
"read and write event contents", &
u, results)
<<EIO checkpoints: test declarations>>=
public :: eio_checkpoints_1
<<EIO checkpoints: tests>>=
subroutine eio_checkpoints_1 (u)
integer, intent(in) :: u
class(generic_event_t), pointer :: event
class(eio_t), allocatable :: eio
type(event_sample_data_t) :: data
type(string_t) :: sample
integer :: i, n_events
write (u, "(A)") "* Test output: eio_checkpoints_1"
write (u, "(A)") "* Purpose: generate a number of events &
&with screen output"
write (u, "(A)")
write (u, "(A)") "* Initialize test process"
call eio_prepare_test (event)
write (u, "(A)")
write (u, "(A)") "* Generate events"
write (u, "(A)")
sample = "eio_checkpoints_1"
allocate (eio_checkpoints_t :: eio)
n_events = 10
call data%init (1, 0)
data%n_evt = n_events
select type (eio)
type is (eio_checkpoints_t)
call eio%set_parameters (checkpoint = 4)
end select
call eio%init_out (sample, data)
do i = 1, n_events
call event%generate (1, [0._default, 0._default])
call eio%output (event, i_prc = 0)
end do
write (u, "(A)") "* Checkpointing status"
write (u, "(A)")
call eio%write (u)
call eio%final ()
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call eio_cleanup_test (event)
write (u, "(A)")
write (u, "(A)") "* Test output end: eio_checkpoints_1"
end subroutine eio_checkpoints_1
@ %def eio_checkpoints_1
@
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{Event Generation Callback}
This is an output-only format. Its only use is to write screen
messages every $n$ events, to inform the user about progress.
<<[[eio_callback.f90]]>>=
<<File header>>
module eio_callback
use kinds, only: i64
<<Use strings>>
use io_units
use diagnostics
use cputime
use event_base
use event_handles, only: event_handle_t
use eio_data
use eio_base
<<Standard module head>>
<<EIO callback: public>>
<<EIO callback: types>>
contains
<<EIO callback: procedures>>
end module eio_callback
@ %def eio_callback
@
\subsection{Type}
<<EIO callback: public>>=
public :: eio_callback_t
<<EIO callback: types>>=
type, extends (eio_t) :: eio_callback_t
class(event_callback_t), allocatable :: callback
integer(i64) :: i_evt = 0
integer :: i_interval = 0
integer :: n_interval = 0
! type(timer_t) :: timer
contains
<<EIO callback: eio callback: TBP>>
end type eio_callback_t
@ %def eio_callback_t
@
\subsection{Specific Methods}
Set parameters that are specifically used for callback: the procedure
and the number of events to wait until the procedure is called (again).
<<EIO callback: eio callback: TBP>>=
procedure :: set_parameters => eio_callback_set_parameters
<<EIO callback: procedures>>=
subroutine eio_callback_set_parameters (eio, callback, count_interval)
class(eio_callback_t), intent(inout) :: eio
class(event_callback_t), intent(in) :: callback
integer, intent(in) :: count_interval
allocate (eio%callback, source = callback)
eio%n_interval = count_interval
end subroutine eio_callback_set_parameters
@ %def eio_callback_set_parameters
@
\subsection{Common Methods}
Output. This is not the actual event format, but a readable account
of the current status.
<<EIO callback: eio callback: TBP>>=
procedure :: write => eio_callback_write
<<EIO callback: procedures>>=
subroutine eio_callback_write (object, unit)
class(eio_callback_t), intent(in) :: object
integer, intent(in), optional :: unit
integer :: u
u = given_output_unit (unit)
write (u, "(1x,A)") "Event-sample callback:"
write (u, "(3x,A,I0)") "interval = ", object%n_interval
write (u, "(3x,A,I0)") "evt count = ", object%i_evt
! call object%timer%write (u)
end subroutine eio_callback_write
@ %def eio_callback_write
@ Finalizer: trivial.
<<EIO callback: eio callback: TBP>>=
procedure :: final => eio_callback_final
<<EIO callback: procedures>>=
subroutine eio_callback_final (object)
class(eio_callback_t), intent(inout) :: object
end subroutine eio_callback_final
@ %def eio_callback_final
@ Activate checkpointing for event generation or writing.
<<EIO callback: eio callback: TBP>>=
procedure :: init_out => eio_callback_init_out
<<EIO callback: procedures>>=
subroutine eio_callback_init_out (eio, sample, data, success, extension)
class(eio_callback_t), intent(inout) :: eio
type(string_t), intent(in) :: sample
type(string_t), intent(in), optional :: extension
type(event_sample_data_t), intent(in), optional :: data
logical, intent(out), optional :: success
eio%i_evt = 0
eiO%i_interval = 0
if (present (success)) success = .true.
end subroutine eio_callback_init_out
@ %def eio_callback_init_out
@ No callback for event reading.
<<EIO callback: eio callback: TBP>>=
procedure :: init_in => eio_callback_init_in
<<EIO callback: procedures>>=
subroutine eio_callback_init_in (eio, sample, data, success, extension)
class(eio_callback_t), intent(inout) :: eio
type(string_t), intent(in) :: sample
type(string_t), intent(in), optional :: extension
type(event_sample_data_t), intent(inout), optional :: data
logical, intent(out), optional :: success
call msg_bug ("Event callback: event input not supported")
if (present (success)) success = .false.
end subroutine eio_callback_init_in
@ %def eio_callback_init_in
@ Switch from input to output: also not supported.
<<EIO callback: eio callback: TBP>>=
procedure :: switch_inout => eio_callback_switch_inout
<<EIO callback: procedures>>=
subroutine eio_callback_switch_inout (eio, success)
class(eio_callback_t), intent(inout) :: eio
logical, intent(out), optional :: success
call msg_bug ("Event callback: in-out switch not supported")
if (present (success)) success = .false.
end subroutine eio_callback_switch_inout
@ %def eio_callback_switch_inout
@ The actual callback. First increment counters, then call the
procedure if the counter hits the interval.
<<EIO callback: eio callback: TBP>>=
procedure :: output => eio_callback_output
<<EIO callback: procedures>>=
subroutine eio_callback_output &
(eio, event, i_prc, reading, passed, pacify, event_handle)
class(eio_callback_t), intent(inout) :: eio
class(generic_event_t), intent(in), target :: event
integer, intent(in) :: i_prc
logical, intent(in), optional :: reading, passed, pacify
class(event_handle_t), intent(inout), optional :: event_handle
eio%i_evt = eio%i_evt + 1
if (eio%n_interval > 0) then
eio%i_interval = eio%i_interval + 1
if (eio%i_interval >= eio%n_interval) then
call eio%callback%proc (eio%i_evt, event)
eio%i_interval = 0
end if
end if
end subroutine eio_callback_output
@ %def eio_callback_output
@ No input.
<<EIO callback: eio callback: TBP>>=
procedure :: input_i_prc => eio_callback_input_i_prc
procedure :: input_event => eio_callback_input_event
<<EIO callback: procedures>>=
subroutine eio_callback_input_i_prc (eio, i_prc, iostat)
class(eio_callback_t), intent(inout) :: eio
integer, intent(out) :: i_prc
integer, intent(out) :: iostat
call msg_bug ("Event callback: event input not supported")
i_prc = 0
iostat = 1
end subroutine eio_callback_input_i_prc
subroutine eio_callback_input_event (eio, event, iostat, event_handle)
class(eio_callback_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
call msg_bug ("Event callback: event input not supported")
iostat = 1
end subroutine eio_callback_input_event
@ %def eio_callback_input_i_prc
@ %def eio_callback_input_event
@
<<EIO callback: eio callback: TBP>>=
procedure :: skip => eio_callback_skip
<<EIO callback: procedures>>=
subroutine eio_callback_skip (eio, iostat)
class(eio_callback_t), intent(inout) :: eio
integer, intent(out) :: iostat
iostat = 0
end subroutine eio_callback_skip
@ %def eio_callback_skip
@
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{Event Weight Output}
This is an output-only format. For each event, we print the indices
that identify process, process part (MCI group), and term. As
numerical information we print the squared matrix element (trace) and
the event weight.
<<[[eio_weights.f90]]>>=
<<File header>>
module eio_weights
<<Use kinds>>
<<Use strings>>
use io_units
use diagnostics
use event_base
use event_handles, only: event_handle_t
use eio_data
use eio_base
<<Standard module head>>
<<EIO weights: public>>
<<EIO weights: types>>
contains
<<EIO weights: procedures>>
end module eio_weights
@ %def eio_weights
@
\subsection{Type}
<<EIO weights: public>>=
public :: eio_weights_t
<<EIO weights: types>>=
type, extends (eio_t) :: eio_weights_t
logical :: writing = .false.
integer :: unit = 0
logical :: pacify = .false.
contains
<<EIO weights: eio weights: TBP>>
end type eio_weights_t
@ %def eio_weights_t
@
\subsection{Specific Methods}
Set pacify flags.
<<EIO weights: eio weights: TBP>>=
procedure :: set_parameters => eio_weights_set_parameters
<<EIO weights: procedures>>=
subroutine eio_weights_set_parameters (eio, pacify)
class(eio_weights_t), intent(inout) :: eio
logical, intent(in), optional :: pacify
if (present (pacify)) eio%pacify = pacify
eio%extension = "weights.dat"
end subroutine eio_weights_set_parameters
@ %def eio_weights_set_parameters
@
\subsection{Common Methods}
@ Output. This is not the actual event format, but a readable account
of the current object status.
<<EIO weights: eio weights: TBP>>=
procedure :: write => eio_weights_write
<<EIO weights: procedures>>=
subroutine eio_weights_write (object, unit)
class(eio_weights_t), intent(in) :: object
integer, intent(in), optional :: unit
integer :: u
u = given_output_unit (unit)
write (u, "(1x,A)") "Weight stream:"
if (object%writing) then
write (u, "(3x,A,A)") "Writing to file = ", char (object%filename)
write (u, "(3x,A,L1)") "Reduced I/O prec. = ", object%pacify
else
write (u, "(3x,A)") "[closed]"
end if
end subroutine eio_weights_write
@ %def eio_weights_write
@ Finalizer: close any open file.
<<EIO weights: eio weights: TBP>>=
procedure :: final => eio_weights_final
<<EIO weights: procedures>>=
subroutine eio_weights_final (object)
class(eio_weights_t), intent(inout) :: object
if (object%writing) then
write (msg_buffer, "(A,A,A)") "Events: closing weight stream file '", &
char (object%filename), "'"
call msg_message ()
close (object%unit)
object%writing = .false.
end if
end subroutine eio_weights_final
@ %def eio_weights_final
@ Initialize event writing.
<<EIO weights: eio weights: TBP>>=
procedure :: init_out => eio_weights_init_out
<<EIO weights: procedures>>=
subroutine eio_weights_init_out (eio, sample, data, success, extension)
class(eio_weights_t), intent(inout) :: eio
type(string_t), intent(in) :: sample
type(string_t), intent(in), optional :: extension
type(event_sample_data_t), intent(in), optional :: data
logical, intent(out), optional :: success
if (present(extension)) then
eio%extension = extension
else
eio%extension = "weights.dat"
end if
eio%filename = sample // "." // eio%extension
eio%unit = free_unit ()
write (msg_buffer, "(A,A,A)") "Events: writing to weight stream file '", &
char (eio%filename), "'"
call msg_message ()
eio%writing = .true.
open (eio%unit, file = char (eio%filename), &
action = "write", status = "replace")
if (present (success)) success = .true.
end subroutine eio_weights_init_out
@ %def eio_weights_init_out
@ Initialize event reading.
<<EIO weights: eio weights: TBP>>=
procedure :: init_in => eio_weights_init_in
<<EIO weights: procedures>>=
subroutine eio_weights_init_in (eio, sample, data, success, extension)
class(eio_weights_t), intent(inout) :: eio
type(string_t), intent(in) :: sample
type(string_t), intent(in), optional :: extension
type(event_sample_data_t), intent(inout), optional :: data
logical, intent(out), optional :: success
call msg_bug ("Weight stream: event input not supported")
if (present (success)) success = .false.
end subroutine eio_weights_init_in
@ %def eio_weights_init_in
@ Switch from input to output: reopen the file for reading.
<<EIO weights: eio weights: TBP>>=
procedure :: switch_inout => eio_weights_switch_inout
<<EIO weights: procedures>>=
subroutine eio_weights_switch_inout (eio, success)
class(eio_weights_t), intent(inout) :: eio
logical, intent(out), optional :: success
call msg_bug ("Weight stream: in-out switch not supported")
if (present (success)) success = .false.
end subroutine eio_weights_switch_inout
@ %def eio_weights_switch_inout
@ Output an event. Write first the event indices, then weight and two
values of the squared matrix element: [[sqme_ref]] is the value stored
in the event record, and [[sqme_prc]] is the one stored in the process
instance. (They can differ: when recalculating, the former is read
from file and the latter is the result of the new calculation.)
For the alternative entries, the [[sqme]] value is always obtained by
a new calculation, and thus qualifies as [[sqme_prc]].
Don't write the file if the [[passed]] flag is set and false.
<<EIO weights: eio weights: TBP>>=
procedure :: output => eio_weights_output
<<EIO weights: procedures>>=
subroutine eio_weights_output &
(eio, event, i_prc, reading, passed, pacify, event_handle)
class(eio_weights_t), intent(inout) :: eio
class(generic_event_t), intent(in), target :: event
integer, intent(in) :: i_prc
logical, intent(in), optional :: reading, passed, pacify
class(event_handle_t), intent(inout), optional :: event_handle
integer :: n_alt, i
real(default) :: weight, sqme_ref, sqme_prc
logical :: evt_pacify, evt_passed
evt_pacify = eio%pacify; if (present (pacify)) evt_pacify = pacify
evt_passed = .true.; if (present (passed)) evt_passed = passed
if (eio%writing) then
if (evt_passed) then
weight = event%get_weight_prc ()
sqme_ref = event%get_sqme_ref ()
sqme_prc = event%get_sqme_prc ()
n_alt = event%get_n_alt ()
1 format (I0,3(1x,ES17.10),3(1x,I0))
2 format (I0,3(1x,ES15.8),3(1x,I0))
if (evt_pacify) then
write (eio%unit, 2) 0, weight, sqme_prc, sqme_ref, &
i_prc
else
write (eio%unit, 1) 0, weight, sqme_prc, sqme_ref, &
i_prc
end if
do i = 1, n_alt
weight = event%get_weight_alt(i)
sqme_prc = event%get_sqme_alt(i)
if (evt_pacify) then
write (eio%unit, 2) i, weight, sqme_prc
else
write (eio%unit, 1) i, weight, sqme_prc
end if
end do
end if
else
call eio%write ()
call msg_fatal ("Weight stream file is not open for writing")
end if
end subroutine eio_weights_output
@ %def eio_weights_output
@ Input an event.
<<EIO weights: eio weights: TBP>>=
procedure :: input_i_prc => eio_weights_input_i_prc
procedure :: input_event => eio_weights_input_event
<<EIO weights: procedures>>=
subroutine eio_weights_input_i_prc (eio, i_prc, iostat)
class(eio_weights_t), intent(inout) :: eio
integer, intent(out) :: i_prc
integer, intent(out) :: iostat
call msg_bug ("Weight stream: event input not supported")
i_prc = 0
iostat = 1
end subroutine eio_weights_input_i_prc
subroutine eio_weights_input_event (eio, event, iostat, event_handle)
class(eio_weights_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
call msg_bug ("Weight stream: event input not supported")
iostat = 1
end subroutine eio_weights_input_event
@ %def eio_weights_input_i_prc
@ %def eio_weights_input_event
@
<<EIO weights: eio weights: TBP>>=
procedure :: skip => eio_weights_skip
<<EIO weights: procedures>>=
subroutine eio_weights_skip (eio, iostat)
class(eio_weights_t), intent(inout) :: eio
integer, intent(out) :: iostat
iostat = 0
end subroutine eio_weights_skip
@ %def eio_weights_skip
@
\subsection{Unit tests}
Test module, followed by the corresponding implementation module.
<<[[eio_weights_ut.f90]]>>=
<<File header>>
module eio_weights_ut
use unit_tests
use eio_weights_uti
<<Standard module head>>
<<EIO weights: public test>>
contains
<<EIO weights: test driver>>
end module eio_weights_ut
@ %def eio_weights_ut
@
<<[[eio_weights_uti.f90]]>>=
<<File header>>
module eio_weights_uti
<<Use kinds>>
<<Use strings>>
use io_units
use event_base
use eio_data
use eio_base
use eio_weights
use eio_base_ut, only: eio_prepare_test, eio_cleanup_test
<<Standard module head>>
<<EIO weights: test declarations>>
contains
<<EIO weights: tests>>
end module eio_weights_uti
@ %def eio_weights_ut
@ API: driver for the unit tests below.
<<EIO weights: public test>>=
public :: eio_weights_test
<<EIO weights: test driver>>=
subroutine eio_weights_test (u, results)
integer, intent(in) :: u
type(test_results_t), intent(inout) :: results
<<EIO weights: execute tests>>
end subroutine eio_weights_test
@ %def eio_weights_test
@
\subsubsection{Simple event}
We test the implementation of all I/O methods.
<<EIO weights: execute tests>>=
call test (eio_weights_1, "eio_weights_1", &
"read and write event contents", &
u, results)
<<EIO weights: test declarations>>=
public :: eio_weights_1
<<EIO weights: tests>>=
subroutine eio_weights_1 (u)
integer, intent(in) :: u
class(generic_event_t), pointer :: event
class(eio_t), allocatable :: eio
type(string_t) :: sample
integer :: u_file
character(80) :: buffer
write (u, "(A)") "* Test output: eio_weights_1"
write (u, "(A)") "* Purpose: generate an event and write weight to file"
write (u, "(A)")
write (u, "(A)") "* Initialize test process"
call eio_prepare_test (event, unweighted = .false.)
write (u, "(A)")
write (u, "(A)") "* Generate and write an event"
write (u, "(A)")
sample = "eio_weights_1"
allocate (eio_weights_t :: eio)
call eio%init_out (sample)
call event%generate (1, [0._default, 0._default])
call eio%output (event, i_prc = 42)
call eio%write (u)
call eio%final ()
write (u, "(A)")
write (u, "(A)") "* File contents: &
&(weight, sqme(evt), sqme(prc), i_prc)"
write (u, "(A)")
u_file = free_unit ()
open (u_file, file = "eio_weights_1.weights.dat", &
action = "read", status = "old")
read (u_file, "(A)") buffer
write (u, "(A)") trim (buffer)
close (u_file)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call eio_cleanup_test (event)
write (u, "(A)")
write (u, "(A)") "* Test output end: eio_weights_1"
end subroutine eio_weights_1
@ %def eio_weights_1
@
\subsubsection{Multiple weights}
Event with several weight entries set.
<<EIO weights: execute tests>>=
call test (eio_weights_2, "eio_weights_2", &
"multiple weights", &
u, results)
<<EIO weights: test declarations>>=
public :: eio_weights_2
<<EIO weights: tests>>=
subroutine eio_weights_2 (u)
integer, intent(in) :: u
class(generic_event_t), pointer :: event
class(eio_t), allocatable :: eio
type(string_t) :: sample
integer :: u_file, i
character(80) :: buffer
write (u, "(A)") "* Test output: eio_weights_2"
write (u, "(A)") "* Purpose: generate an event and write weight to file"
write (u, "(A)")
write (u, "(A)") "* Initialize test process"
call eio_prepare_test (event, unweighted = .false., n_alt = 2)
write (u, "(A)")
write (u, "(A)") "* Generate and write an event"
write (u, "(A)")
sample = "eio_weights_2"
allocate (eio_weights_t :: eio)
call eio%init_out (sample)
select type (eio)
type is (eio_weights_t)
call eio%set_parameters (pacify = .true.)
end select
call event%generate (1, [0._default, 0._default])
call event%set (sqme_alt = [2._default, 3._default])
call event%set (weight_alt = &
[2 * event%get_weight_prc (), 3 * event%get_weight_prc ()])
call eio%output (event, i_prc = 42)
call eio%write (u)
call eio%final ()
write (u, "(A)")
write (u, "(A)") "* File contents: &
&(weight, sqme(evt), sqme(prc), i_prc)"
write (u, "(A)")
u_file = free_unit ()
open (u_file, file = "eio_weights_2.weights.dat", &
action = "read", status = "old")
do i = 1, 3
read (u_file, "(A)") buffer
write (u, "(A)") trim (buffer)
end do
close (u_file)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call eio_cleanup_test (event)
write (u, "(A)")
write (u, "(A)") "* Test output end: eio_weights_2"
end subroutine eio_weights_2
@ %def eio_weights_2
@
\subsubsection{Multiple events}
Events with [[passed]] flag switched on/off.
<<EIO weights: execute tests>>=
call test (eio_weights_3, "eio_weights_3", &
"check passed-flag", &
u, results)
<<EIO weights: test declarations>>=
public :: eio_weights_3
<<EIO weights: tests>>=
subroutine eio_weights_3 (u)
integer, intent(in) :: u
class(generic_event_t), pointer :: event
class(eio_t), allocatable :: eio
type(string_t) :: sample
integer :: u_file, iostat
character(80) :: buffer
write (u, "(A)") "* Test output: eio_weights_3"
write (u, "(A)") "* Purpose: generate three events and write to file"
write (u, "(A)")
write (u, "(A)") "* Initialize test process"
call eio_prepare_test (event, unweighted = .false.)
write (u, "(A)")
write (u, "(A)") "* Generate and write events"
write (u, "(A)")
sample = "eio_weights_3"
allocate (eio_weights_t :: eio)
select type (eio)
type is (eio_weights_t)
call eio%set_parameters (pacify = .true.)
end select
call eio%init_out (sample)
call event%generate (1, [0._default, 0._default])
call eio%output (event, i_prc = 1)
call event%generate (1, [0.1_default, 0._default])
call eio%output (event, i_prc = 1, passed = .false.)
call event%generate (1, [0.2_default, 0._default])
call eio%output (event, i_prc = 1, passed = .true.)
call eio%write (u)
call eio%final ()
write (u, "(A)")
write (u, "(A)") "* File contents: &
&(weight, sqme(evt), sqme(prc), i_prc), should be just two entries"
write (u, "(A)")
u_file = free_unit ()
open (u_file, file = "eio_weights_3.weights.dat", &
action = "read", status = "old")
do
read (u_file, "(A)", iostat=iostat) buffer
if (iostat /= 0) exit
write (u, "(A)") trim (buffer)
end do
close (u_file)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call eio_cleanup_test (event)
write (u, "(A)")
write (u, "(A)") "* Test output end: eio_weights_3"
end subroutine eio_weights_3
@ %def eio_weights_3
@
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{Event Dump Output}
This is an output-only format. We simply dump the contents of the
[[particle_set]], using the [[write]] method of that type. The
event-format options are the options of that procedure.
<<[[eio_dump.f90]]>>=
<<File header>>
module eio_dump
use, intrinsic :: iso_fortran_env, only: output_unit
use kinds, only: i64
<<Use strings>>
use format_utils, only: write_separator
use format_utils, only: pac_fmt
use format_defs, only: FMT_16, FMT_19
use io_units
use diagnostics
use event_base
use event_handles, only: event_handle_t
use eio_data
use eio_base
<<Standard module head>>
<<EIO dump: public>>
<<EIO dump: types>>
contains
<<EIO dump: procedures>>
end module eio_dump
@ %def eio_dump
@
\subsection{Type}
<<EIO dump: public>>=
public :: eio_dump_t
<<EIO dump: types>>=
type, extends (eio_t) :: eio_dump_t
integer(i64) :: count = 0
integer :: unit = 0
logical :: writing = .false.
logical :: screen = .false.
logical :: pacify = .false.
logical :: weights = .false.
logical :: compressed = .false.
logical :: summary = .false.
contains
<<EIO dump: eio dump: TBP>>
end type eio_dump_t
@ %def eio_dump_t
@
\subsection{Specific Methods}
Set control parameters. We may provide a [[unit]] for input or output; this
will be taken if the sample file name is empty. In that case, the unit is
assumed to be open and will be kept open; no messages will be issued.
<<EIO dump: eio dump: TBP>>=
procedure :: set_parameters => eio_dump_set_parameters
<<EIO dump: procedures>>=
subroutine eio_dump_set_parameters (eio, extension, &
pacify, weights, compressed, summary, screen, unit)
class(eio_dump_t), intent(inout) :: eio
type(string_t), intent(in), optional :: extension
logical, intent(in), optional :: pacify
logical, intent(in), optional :: weights
logical, intent(in), optional :: compressed
logical, intent(in), optional :: summary
logical, intent(in), optional :: screen
integer, intent(in), optional :: unit
if (present (pacify)) eio%pacify = pacify
if (present (weights)) eio%weights = weights
if (present (compressed)) eio%compressed = compressed
if (present (summary)) eio%summary = summary
if (present (screen)) eio%screen = screen
if (present (unit)) eio%unit = unit
eio%extension = "pset.dat"
if (present (extension)) eio%extension = extension
end subroutine eio_dump_set_parameters
@ %def eio_dump_set_parameters
@
\subsection{Common Methods}
@ Output. This is not the actual event format, but a readable account
of the current object status.
<<EIO dump: eio dump: TBP>>=
procedure :: write => eio_dump_write
<<EIO dump: procedures>>=
subroutine eio_dump_write (object, unit)
class(eio_dump_t), intent(in) :: object
integer, intent(in), optional :: unit
integer :: u
u = given_output_unit (unit)
write (u, "(1x,A)") "Dump event stream:"
if (object%writing) then
write (u, "(3x,A,L1)") "Screen output = ", object%screen
write (u, "(3x,A,A,A)") "Writing to file = '", char (object%filename), "'"
write (u, "(3x,A,L1)") "Reduced I/O prec. = ", object%pacify
write (u, "(3x,A,L1)") "Show weights/sqme = ", object%weights
write (u, "(3x,A,L1)") "Compressed = ", object%compressed
write (u, "(3x,A,L1)") "Summary = ", object%summary
else
write (u, "(3x,A)") "[closed]"
end if
end subroutine eio_dump_write
@ %def eio_dump_write
@ Finalizer: close any open file.
<<EIO dump: eio dump: TBP>>=
procedure :: final => eio_dump_final
<<EIO dump: procedures>>=
subroutine eio_dump_final (object)
class(eio_dump_t), intent(inout) :: object
if (object%screen) then
write (msg_buffer, "(A,A,A)") "Events: display complete"
call msg_message ()
object%screen = .false.
end if
if (object%writing) then
if (object%filename /= "") then
write (msg_buffer, "(A,A,A)") "Events: closing event dump file '", &
char (object%filename), "'"
call msg_message ()
close (object%unit)
end if
object%writing = .false.
end if
end subroutine eio_dump_final
@ %def eio_dump_final
@ Initialize event writing.
<<EIO dump: eio dump: TBP>>=
procedure :: init_out => eio_dump_init_out
<<EIO dump: procedures>>=
subroutine eio_dump_init_out (eio, sample, data, success, extension)
class(eio_dump_t), intent(inout) :: eio
type(string_t), intent(in) :: sample
type(string_t), intent(in), optional :: extension
type(event_sample_data_t), intent(in), optional :: data
logical, intent(out), optional :: success
if (present(extension)) then
eio%extension = extension
else
eio%extension = "pset.dat"
end if
if (sample == "" .and. eio%unit /= 0) then
eio%filename = ""
eio%writing = .true.
else if (sample /= "") then
eio%filename = sample // "." // eio%extension
eio%unit = free_unit ()
write (msg_buffer, "(A,A,A)") "Events: writing to event dump file '", &
char (eio%filename), "'"
call msg_message ()
eio%writing = .true.
open (eio%unit, file = char (eio%filename), &
action = "write", status = "replace")
end if
if (eio%screen) then
write (msg_buffer, "(A,A,A)") "Events: display on standard output"
call msg_message ()
end if
eio%count = 0
if (present (success)) success = .true.
end subroutine eio_dump_init_out
@ %def eio_dump_init_out
@ Initialize event reading.
<<EIO dump: eio dump: TBP>>=
procedure :: init_in => eio_dump_init_in
<<EIO dump: procedures>>=
subroutine eio_dump_init_in (eio, sample, data, success, extension)
class(eio_dump_t), intent(inout) :: eio
type(string_t), intent(in) :: sample
type(string_t), intent(in), optional :: extension
type(event_sample_data_t), intent(inout), optional :: data
logical, intent(out), optional :: success
call msg_bug ("Event dump: event input not supported")
if (present (success)) success = .false.
end subroutine eio_dump_init_in
@ %def eio_dump_init_in
@ Switch from input to output: reopen the file for reading.
<<EIO dump: eio dump: TBP>>=
procedure :: switch_inout => eio_dump_switch_inout
<<EIO dump: procedures>>=
subroutine eio_dump_switch_inout (eio, success)
class(eio_dump_t), intent(inout) :: eio
logical, intent(out), optional :: success
call msg_bug ("Event dump: in-out switch not supported")
if (present (success)) success = .false.
end subroutine eio_dump_switch_inout
@ %def eio_dump_switch_inout
@ Output an event. Delegate the output call to the [[write]] method
of the current particle set, if valid. Output both to file (if defined)
and to screen (if requested).
<<EIO dump: eio dump: TBP>>=
procedure :: output => eio_dump_output
<<EIO dump: procedures>>=
subroutine eio_dump_output &
(eio, event, i_prc, reading, passed, pacify, event_handle)
class(eio_dump_t), intent(inout) :: eio
class(generic_event_t), intent(in), target :: event
integer, intent(in) :: i_prc
logical, intent(in), optional :: reading, passed, pacify
class(event_handle_t), intent(inout), optional :: event_handle
character(len=7) :: fmt
eio%count = eio%count + 1
if (present (pacify)) then
call pac_fmt (fmt, FMT_19, FMT_16, pacify)
else
call pac_fmt (fmt, FMT_19, FMT_16, eio%pacify)
end if
if (eio%writing) call dump (eio%unit)
if (eio%screen) then
call dump (output_unit)
if (logfile_unit () > 0) call dump (logfile_unit ())
end if
contains
subroutine dump (u)
integer, intent(in) :: u
integer :: i
call write_separator (u, 2)
write (u, "(1x,A,I0)", advance="no") "Event"
if (event%has_index ()) then
write (u, "(1x,'#',I0)") event%get_index ()
else
write (u, *)
end if
call write_separator (u, 2)
write (u, "(1x,A,1x,I0)") "count =", eio%count
if (present (passed)) then
write (u, "(1x,A,1x,L1)") "passed =", passed
else
write (u, "(1x,A)") "passed = [N/A]"
end if
write (u, "(1x,A,1x,I0)") "prc id =", i_prc
if (eio%weights) then
call write_separator (u)
if (event%sqme_ref_known) then
write (u, "(1x,A," // fmt // ")") "sqme (ref) = ", &
event%sqme_ref
else
write (u, "(1x,A)") "sqme (ref) = [undefined]"
end if
if (event%sqme_prc_known) then
write (u, "(1x,A," // fmt // ")") "sqme (prc) = ", &
event%sqme_prc
else
write (u, "(1x,A)") "sqme (prc) = [undefined]"
end if
if (event%weight_ref_known) then
write (u, "(1x,A," // fmt // ")") "weight (ref) = ", &
event%weight_ref
else
write (u, "(1x,A)") "weight (ref) = [undefined]"
end if
if (event%weight_prc_known) then
write (u, "(1x,A," // fmt // ")") "weight (prc) = ", &
event%weight_prc
else
write (u, "(1x,A)") "weight (prc) = [undefined]"
end if
if (event%excess_prc_known) then
write (u, "(1x,A," // fmt // ")") "excess (prc) = ", &
event%excess_prc
else
write (u, "(1x,A)") "excess (prc) = [undefined]"
end if
do i = 1, event%n_alt
if (event%sqme_ref_known) then
write (u, "(1x,A,I0,A," // fmt // ")") "sqme (", i, ") = ",&
event%sqme_prc
else
write (u, "(1x,A,I0,A)") "sqme (", i, ") = [undefined]"
end if
if (event%weight_prc_known) then
write (u, "(1x,A,I0,A," // fmt // ")") "weight (", i, ") = ",&
event%weight_prc
else
write (u, "(1x,A,I0,A)") "weight (", i, ") = [undefined]"
end if
end do
end if
call write_separator (u)
if (event%particle_set_is_valid) then
call event%particle_set%write (unit = u, &
summary = eio%summary, compressed = eio%compressed, &
testflag = eio%pacify)
else
write (u, "(1x,A)") "Particle set: [invalid]"
end if
end subroutine dump
end subroutine eio_dump_output
@ %def eio_dump_output
@ Input an event.
<<EIO dump: eio dump: TBP>>=
procedure :: input_i_prc => eio_dump_input_i_prc
procedure :: input_event => eio_dump_input_event
<<EIO dump: procedures>>=
subroutine eio_dump_input_i_prc (eio, i_prc, iostat)
class(eio_dump_t), intent(inout) :: eio
integer, intent(out) :: i_prc
integer, intent(out) :: iostat
call msg_bug ("Dump stream: event input not supported")
i_prc = 0
iostat = 1
end subroutine eio_dump_input_i_prc
subroutine eio_dump_input_event (eio, event, iostat, event_handle)
class(eio_dump_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
call msg_bug ("Dump stream: event input not supported")
iostat = 1
end subroutine eio_dump_input_event
@ %def eio_dump_input_i_prc
@ %def eio_dump_input_event
@
<<EIO dump: eio dump: TBP>>=
procedure :: skip => eio_dump_skip
<<EIO dump: procedures>>=
subroutine eio_dump_skip (eio, iostat)
class(eio_dump_t), intent(inout) :: eio
integer, intent(out) :: iostat
iostat = 0
end subroutine eio_dump_skip
@ %def eio_dump_skip
@
\subsection{Unit tests}
Test module, followed by the corresponding implementation module.
<<[[eio_dump_ut.f90]]>>=
<<File header>>
module eio_dump_ut
use unit_tests
use eio_dump_uti
<<Standard module head>>
<<EIO dump: public test>>
contains
<<EIO dump: test driver>>
end module eio_dump_ut
@ %def eio_dump_ut
@
<<[[eio_dump_uti.f90]]>>=
<<File header>>
module eio_dump_uti
<<Use kinds>>
<<Use strings>>
use io_units
use event_base
use eio_data
use eio_base
use eio_dump
use eio_base_ut, only: eio_prepare_test, eio_cleanup_test
<<Standard module head>>
<<EIO dump: test declarations>>
contains
<<EIO dump: tests>>
end module eio_dump_uti
@ %def eio_dump_ut
@ API: driver for the unit tests below.
<<EIO dump: public test>>=
public :: eio_dump_test
<<EIO dump: test driver>>=
subroutine eio_dump_test (u, results)
integer, intent(in) :: u
type(test_results_t), intent(inout) :: results
<<EIO dump: execute tests>>
end subroutine eio_dump_test
@ %def eio_dump_test
@
\subsubsection{Test I/O methods}
We test the implementation of all I/O methods.
<<EIO dump: execute tests>>=
call test (eio_dump_1, "eio_dump_1", &
"write event contents", &
u, results)
<<EIO dump: test declarations>>=
public :: eio_dump_1
<<EIO dump: tests>>=
subroutine eio_dump_1 (u)
integer, intent(in) :: u
class(generic_event_t), pointer :: event
class(eio_t), allocatable :: eio
integer :: i_prc
integer :: u_file
write (u, "(A)") "* Test output: eio_dump_1"
write (u, "(A)") "* Purpose: generate events and write essentials to output"
write (u, "(A)")
write (u, "(A)") "* Initialize test process"
call eio_prepare_test (event, unweighted = .false.)
write (u, "(A)")
write (u, "(A)") "* Generate and write three events (two passed)"
write (u, "(A)")
allocate (eio_dump_t :: eio)
select type (eio)
type is (eio_dump_t)
call eio%set_parameters (unit = u, weights = .true., pacify = .true.)
end select
i_prc = 42
call eio%init_out (var_str (""))
call event%generate (1, [0._default, 0._default])
call eio%output (event, i_prc = i_prc)
call event%generate (1, [0.1_default, 0._default])
call event%set_index (99)
call eio%output (event, i_prc = i_prc, passed = .false.)
call event%generate (1, [0.2_default, 0._default])
call event%increment_index ()
call eio%output (event, i_prc = i_prc, passed = .true.)
write (u, "(A)")
write (u, "(A)") "* Contents of eio_dump object"
write (u, "(A)")
call eio%write (u)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
select type (eio)
type is (eio_dump_t)
eio%writing = .false.
end select
call eio%final ()
call eio_cleanup_test (event)
write (u, "(A)")
write (u, "(A)") "* Test output end: eio_dump_1"
end subroutine eio_dump_1
@ %def eio_dump_1
@
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{ASCII File Formats}
Here, we implement several ASCII file formats. It is possible to
switch between them using flags.
<<[[eio_ascii.f90]]>>=
<<File header>>
module eio_ascii
<<Use strings>>
use io_units
use diagnostics
use event_base
use event_handles, only: event_handle_t
use eio_data
use eio_base
use hep_common
use hep_events
<<Standard module head>>
<<EIO ascii: public>>
<<EIO ascii: types>>
contains
<<EIO ascii: procedures>>
end module eio_ascii
@ %def eio_ascii
@
\subsection{Type}
<<EIO ascii: public>>=
public :: eio_ascii_t
<<EIO ascii: types>>=
type, abstract, extends (eio_t) :: eio_ascii_t
logical :: writing = .false.
integer :: unit = 0
logical :: keep_beams = .false.
logical :: keep_remnants = .true.
logical :: ensure_order = .false.
contains
<<EIO ascii: eio ascii: TBP>>
end type eio_ascii_t
@ %def eio_ascii_t
@
<<EIO ascii: public>>=
public :: eio_ascii_ascii_t
<<EIO ascii: types>>=
type, extends (eio_ascii_t) :: eio_ascii_ascii_t
end type eio_ascii_ascii_t
@ %def eio_ascii_ascii_t
@
<<EIO ascii: public>>=
public :: eio_ascii_athena_t
<<EIO ascii: types>>=
type, extends (eio_ascii_t) :: eio_ascii_athena_t
end type eio_ascii_athena_t
@ %def eio_ascii_athena_t
@ The debug format has a few options that can be controlled by
Sindarin variables.
<<EIO ascii: public>>=
public :: eio_ascii_debug_t
<<EIO ascii: types>>=
type, extends (eio_ascii_t) :: eio_ascii_debug_t
logical :: show_process = .true.
logical :: show_transforms = .true.
logical :: show_decay = .true.
logical :: verbose = .true.
end type eio_ascii_debug_t
@ %def eio_ascii_debug_t
@
<<EIO ascii: public>>=
public :: eio_ascii_hepevt_t
<<EIO ascii: types>>=
type, extends (eio_ascii_t) :: eio_ascii_hepevt_t
end type eio_ascii_hepevt_t
@ %def eio_ascii_hepevt_t
@
<<EIO ascii: public>>=
public :: eio_ascii_hepevt_verb_t
<<EIO ascii: types>>=
type, extends (eio_ascii_t) :: eio_ascii_hepevt_verb_t
end type eio_ascii_hepevt_verb_t
@ %def eio_ascii_hepevt_verb_t
@
<<EIO ascii: public>>=
public :: eio_ascii_lha_t
<<EIO ascii: types>>=
type, extends (eio_ascii_t) :: eio_ascii_lha_t
end type eio_ascii_lha_t
@ %def eio_ascii_lha_t
@
<<EIO ascii: public>>=
public :: eio_ascii_lha_verb_t
<<EIO ascii: types>>=
type, extends (eio_ascii_t) :: eio_ascii_lha_verb_t
end type eio_ascii_lha_verb_t
@ %def eio_ascii_lha_verb_t
@
<<EIO ascii: public>>=
public :: eio_ascii_long_t
<<EIO ascii: types>>=
type, extends (eio_ascii_t) :: eio_ascii_long_t
end type eio_ascii_long_t
@ %def eio_ascii_long_t
@
<<EIO ascii: public>>=
public :: eio_ascii_mokka_t
<<EIO ascii: types>>=
type, extends (eio_ascii_t) :: eio_ascii_mokka_t
end type eio_ascii_mokka_t
@ %def eio_ascii_mokka_t
@
<<EIO ascii: public>>=
public :: eio_ascii_short_t
<<EIO ascii: types>>=
type, extends (eio_ascii_t) :: eio_ascii_short_t
end type eio_ascii_short_t
@ %def eio_ascii_short_t
@
\subsection{Specific Methods}
Set parameters that are specifically used with ASCII file formats. In
particular, this is the file extension.
<<EIO ascii: eio ascii: TBP>>=
procedure :: set_parameters => eio_ascii_set_parameters
<<EIO ascii: procedures>>=
subroutine eio_ascii_set_parameters (eio, &
keep_beams, keep_remnants, ensure_order, extension, &
show_process, show_transforms, show_decay, verbose)
class(eio_ascii_t), intent(inout) :: eio
logical, intent(in), optional :: keep_beams
logical, intent(in), optional :: keep_remnants
logical, intent(in), optional :: ensure_order
type(string_t), intent(in), optional :: extension
logical, intent(in), optional :: show_process, show_transforms, show_decay
logical, intent(in), optional :: verbose
if (present (keep_beams)) eio%keep_beams = keep_beams
if (present (keep_remnants)) eio%keep_remnants = keep_remnants
if (present (ensure_order)) eio%ensure_order = ensure_order
if (present (extension)) then
eio%extension = extension
else
select type (eio)
type is (eio_ascii_ascii_t)
eio%extension = "evt"
type is (eio_ascii_athena_t)
eio%extension = "athena.evt"
type is (eio_ascii_debug_t)
eio%extension = "debug"
type is (eio_ascii_hepevt_t)
eio%extension = "hepevt"
type is (eio_ascii_hepevt_verb_t)
eio%extension = "hepevt.verb"
type is (eio_ascii_lha_t)
eio%extension = "lha"
type is (eio_ascii_lha_verb_t)
eio%extension = "lha.verb"
type is (eio_ascii_long_t)
eio%extension = "long.evt"
type is (eio_ascii_mokka_t)
eio%extension = "mokka.evt"
type is (eio_ascii_short_t)
eio%extension = "short.evt"
end select
end if
select type (eio)
type is (eio_ascii_debug_t)
if (present (show_process)) eio%show_process = show_process
if (present (show_transforms)) eio%show_transforms = show_transforms
if (present (show_decay)) eio%show_decay = show_decay
if (present (verbose)) eio%verbose = verbose
end select
end subroutine eio_ascii_set_parameters
@ %def eio_ascii_set_parameters
@
\subsection{Common Methods}
Output. This is not the actual event format, but a readable account
of the current object status.
<<EIO ascii: eio ascii: TBP>>=
procedure :: write => eio_ascii_write
<<EIO ascii: procedures>>=
subroutine eio_ascii_write (object, unit)
class(eio_ascii_t), intent(in) :: object
integer, intent(in), optional :: unit
integer :: u
u = given_output_unit (unit)
select type (object)
type is (eio_ascii_ascii_t)
write (u, "(1x,A)") "ASCII event stream (default format):"
type is (eio_ascii_athena_t)
write (u, "(1x,A)") "ASCII event stream (ATHENA format):"
type is (eio_ascii_debug_t)
write (u, "(1x,A)") "ASCII event stream (Debugging format):"
type is (eio_ascii_hepevt_t)
write (u, "(1x,A)") "ASCII event stream (HEPEVT format):"
type is (eio_ascii_hepevt_verb_t)
write (u, "(1x,A)") "ASCII event stream (verbose HEPEVT format):"
type is (eio_ascii_lha_t)
write (u, "(1x,A)") "ASCII event stream (LHA format):"
type is (eio_ascii_lha_verb_t)
write (u, "(1x,A)") "ASCII event stream (verbose LHA format):"
type is (eio_ascii_long_t)
write (u, "(1x,A)") "ASCII event stream (long format):"
type is (eio_ascii_mokka_t)
write (u, "(1x,A)") "ASCII event stream (MOKKA format):"
type is (eio_ascii_short_t)
write (u, "(1x,A)") "ASCII event stream (short format):"
end select
if (object%writing) then
write (u, "(3x,A,A)") "Writing to file = ", char (object%filename)
else
write (u, "(3x,A)") "[closed]"
end if
write (u, "(3x,A,L1)") "Keep beams = ", object%keep_beams
write (u, "(3x,A,L1)") "Keep remnants = ", object%keep_remnants
select type (object)
type is (eio_ascii_debug_t)
write (u, "(3x,A,L1)") "Show process = ", object%show_process
write (u, "(3x,A,L1)") "Show transforms = ", object%show_transforms
write (u, "(3x,A,L1)") "Show decay tree = ", object%show_decay
write (u, "(3x,A,L1)") "Verbose output = ", object%verbose
end select
end subroutine eio_ascii_write
@ %def eio_ascii_write
@ Finalizer: close any open file.
<<EIO ascii: eio ascii: TBP>>=
procedure :: final => eio_ascii_final
<<EIO ascii: procedures>>=
subroutine eio_ascii_final (object)
class(eio_ascii_t), intent(inout) :: object
if (object%writing) then
write (msg_buffer, "(A,A,A)") "Events: closing ASCII file '", &
char (object%filename), "'"
call msg_message ()
close (object%unit)
object%writing = .false.
end if
end subroutine eio_ascii_final
@ %def eio_ascii_final
@ Initialize event writing.
Check weight normalization. This applies to all ASCII-type files that
use the HEPRUP common block. We can't allow normalization conventions
that are not covered by the HEPRUP definition.
<<EIO ascii: eio ascii: TBP>>=
procedure :: init_out => eio_ascii_init_out
<<EIO ascii: procedures>>=
subroutine eio_ascii_init_out (eio, sample, data, success, extension)
class(eio_ascii_t), intent(inout) :: eio
type(string_t), intent(in) :: sample
type(string_t), intent(in), optional :: extension
type(event_sample_data_t), intent(in), optional :: data
logical, intent(out), optional :: success
integer :: i
if (.not. present (data)) &
call msg_bug ("ASCII initialization: missing data")
if (data%n_beam /= 2) &
call msg_fatal ("ASCII: defined for scattering processes only")
eio%sample = sample
call eio%check_normalization (data)
call eio%set_splitting (data)
call eio%set_filename ()
eio%unit = free_unit ()
write (msg_buffer, "(A,A,A)") "Events: writing to ASCII file '", &
char (eio%filename), "'"
call msg_message ()
eio%writing = .true.
open (eio%unit, file = char (eio%filename), &
action = "write", status = "replace")
select type (eio)
type is (eio_ascii_lha_t)
call heprup_init( &
data%pdg_beam, &
data%energy_beam, &
n_processes = data%n_proc, &
unweighted = data%unweighted, &
negative_weights = data%negative_weights)
do i = 1, data%n_proc
call heprup_set_process_parameters (i = i, &
process_id = data%proc_num_id(i), &
cross_section = data%cross_section(i), &
error = data%error(i))
end do
call heprup_write_ascii (eio%unit)
type is (eio_ascii_lha_verb_t)
call heprup_init( &
data%pdg_beam, &
data%energy_beam, &
n_processes = data%n_proc, &
unweighted = data%unweighted, &
negative_weights = data%negative_weights)
do i = 1, data%n_proc
call heprup_set_process_parameters (i = i, &
process_id = data%proc_num_id(i), &
cross_section = data%cross_section(i), &
error = data%error(i))
end do
call heprup_write_verbose (eio%unit)
end select
if (present (success)) success = .true.
end subroutine eio_ascii_init_out
@ %def eio_ascii_init_out
@ Some event properties do not go well with some output formats. In
particular, many formats require unweighted events.
<<EIO ascii: eio ascii: TBP>>=
procedure :: check_normalization => eio_ascii_check_normalization
<<EIO ascii: procedures>>=
subroutine eio_ascii_check_normalization (eio, data)
class(eio_ascii_t), intent(in) :: eio
type(event_sample_data_t), intent(in) :: data
if (data%unweighted) then
else
select type (eio)
type is (eio_ascii_athena_t); call msg_fatal &
("Event output (Athena format): events must be unweighted.")
type is (eio_ascii_hepevt_t); call msg_fatal &
("Event output (HEPEVT format): events must be unweighted.")
type is (eio_ascii_hepevt_verb_t); call msg_fatal &
("Event output (HEPEVT format): events must be unweighted.")
end select
select case (data%norm_mode)
case (NORM_SIGMA)
case default
select type (eio)
type is (eio_ascii_lha_t)
call msg_fatal &
("Event output (LHA): normalization for weighted events &
&must be 'sigma'")
type is (eio_ascii_lha_verb_t)
call msg_fatal &
("Event output (LHA): normalization for weighted events &
&must be 'sigma'")
end select
end select
end if
end subroutine eio_ascii_check_normalization
@ %def check_normalization
@ Initialize event reading.
<<EIO ascii: eio ascii: TBP>>=
procedure :: init_in => eio_ascii_init_in
<<EIO ascii: procedures>>=
subroutine eio_ascii_init_in (eio, sample, data, success, extension)
class(eio_ascii_t), intent(inout) :: eio
type(string_t), intent(in) :: sample
type(string_t), intent(in), optional :: extension
type(event_sample_data_t), intent(inout), optional :: data
logical, intent(out), optional :: success
call msg_bug ("ASCII: event input not supported")
if (present (success)) success = .false.
end subroutine eio_ascii_init_in
@ %def eio_ascii_init_in
@ Switch from input to output: reopen the file for reading.
<<EIO ascii: eio ascii: TBP>>=
procedure :: switch_inout => eio_ascii_switch_inout
<<EIO ascii: procedures>>=
subroutine eio_ascii_switch_inout (eio, success)
class(eio_ascii_t), intent(inout) :: eio
logical, intent(out), optional :: success
call msg_bug ("ASCII: in-out switch not supported")
if (present (success)) success = .false.
end subroutine eio_ascii_switch_inout
@ %def eio_ascii_switch_inout
@ Split event file: increment the counter, close the current file, open a new
one. If the file needs a header, repeat it for the new file. (We assume that
the common block contents are still intact.)
<<EIO ascii: eio ascii: TBP>>=
procedure :: split_out => eio_ascii_split_out
<<EIO ascii: procedures>>=
subroutine eio_ascii_split_out (eio)
class(eio_ascii_t), intent(inout) :: eio
if (eio%split) then
eio%split_index = eio%split_index + 1
call eio%set_filename ()
write (msg_buffer, "(A,A,A)") "Events: writing to ASCII file '", &
char (eio%filename), "'"
call msg_message ()
close (eio%unit)
open (eio%unit, file = char (eio%filename), &
action = "write", status = "replace")
select type (eio)
type is (eio_ascii_lha_t)
call heprup_write_ascii (eio%unit)
type is (eio_ascii_lha_verb_t)
call heprup_write_verbose (eio%unit)
end select
end if
end subroutine eio_ascii_split_out
@ %def eio_ascii_split_out
@ Output an event. Write first the event indices, then weight and
squared matrix element, then the particle set.
Events that did not pass the selection are skipped. The exceptions are
the [[ascii]] and [[debug]] formats. These are the formats that
contain the [[passed]] flag in their output, and should be most useful
for debugging purposes.
<<EIO ascii: eio ascii: TBP>>=
procedure :: output => eio_ascii_output
<<EIO ascii: procedures>>=
subroutine eio_ascii_output &
(eio, event, i_prc, reading, passed, pacify, event_handle)
class(eio_ascii_t), intent(inout) :: eio
class(generic_event_t), intent(in), target :: event
integer, intent(in) :: i_prc
logical, intent(in), optional :: reading, passed, pacify
class(event_handle_t), intent(inout), optional :: event_handle
if (present (passed)) then
if (.not. passed) then
select type (eio)
type is (eio_ascii_debug_t)
type is (eio_ascii_ascii_t)
class default
return
end select
end if
end if
if (eio%writing) then
select type (eio)
type is (eio_ascii_lha_t)
call hepeup_from_event (event, &
process_index = i_prc, &
keep_beams = eio%keep_beams, &
keep_remnants = eio%keep_remnants)
call hepeup_write_lha (eio%unit)
type is (eio_ascii_lha_verb_t)
call hepeup_from_event (event, &
process_index = i_prc, &
keep_beams = eio%keep_beams, &
keep_remnants = eio%keep_remnants)
call hepeup_write_verbose (eio%unit)
type is (eio_ascii_ascii_t)
call event%write (eio%unit, &
show_process = .false., &
show_transforms = .false., &
show_decay = .false., &
verbose = .false., testflag = pacify)
type is (eio_ascii_athena_t)
call hepevt_from_event (event, &
keep_beams = eio%keep_beams, &
keep_remnants = eio%keep_remnants, &
ensure_order = eio%ensure_order)
call hepevt_write_athena (eio%unit)
type is (eio_ascii_debug_t)
call event%write (eio%unit, &
show_process = eio%show_process, &
show_transforms = eio%show_transforms, &
show_decay = eio%show_decay, &
verbose = eio%verbose, &
testflag = pacify)
type is (eio_ascii_hepevt_t)
call hepevt_from_event (event, &
keep_beams = eio%keep_beams, &
keep_remnants = eio%keep_remnants, &
ensure_order = eio%ensure_order)
call hepevt_write_hepevt (eio%unit)
type is (eio_ascii_hepevt_verb_t)
call hepevt_from_event (event, &
keep_beams = eio%keep_beams, &
keep_remnants = eio%keep_remnants, &
ensure_order = eio%ensure_order)
call hepevt_write_verbose (eio%unit)
type is (eio_ascii_long_t)
call hepevt_from_event (event, &
keep_beams = eio%keep_beams, &
keep_remnants = eio%keep_remnants, &
ensure_order = eio%ensure_order)
call hepevt_write_ascii (eio%unit, .true.)
type is (eio_ascii_mokka_t)
call hepevt_from_event (event, &
keep_beams = eio%keep_beams, &
keep_remnants = eio%keep_remnants, &
ensure_order = eio%ensure_order)
call hepevt_write_mokka (eio%unit)
type is (eio_ascii_short_t)
call hepevt_from_event (event, &
keep_beams = eio%keep_beams, &
keep_remnants = eio%keep_remnants, &
ensure_order = eio%ensure_order)
call hepevt_write_ascii (eio%unit, .false.)
end select
else
call eio%write ()
call msg_fatal ("ASCII file is not open for writing")
end if
end subroutine eio_ascii_output
@ %def eio_ascii_output
@ Input an event.
<<EIO ascii: eio ascii: TBP>>=
procedure :: input_i_prc => eio_ascii_input_i_prc
procedure :: input_event => eio_ascii_input_event
<<EIO ascii: procedures>>=
subroutine eio_ascii_input_i_prc (eio, i_prc, iostat)
class(eio_ascii_t), intent(inout) :: eio
integer, intent(out) :: i_prc
integer, intent(out) :: iostat
call msg_bug ("ASCII: event input not supported")
i_prc = 0
iostat = 1
end subroutine eio_ascii_input_i_prc
subroutine eio_ascii_input_event (eio, event, iostat, event_handle)
class(eio_ascii_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
call msg_bug ("ASCII: event input not supported")
iostat = 1
end subroutine eio_ascii_input_event
@ %def eio_ascii_input_i_prc
@ %def eio_ascii_input_event
@
<<EIO ascii: eio ascii: TBP>>=
procedure :: skip => eio_ascii_skip
<<EIO ascii: procedures>>=
subroutine eio_ascii_skip (eio, iostat)
class(eio_ascii_t), intent(inout) :: eio
integer, intent(out) :: iostat
iostat = 0
end subroutine eio_ascii_skip
@ %def eio_asciii_skip
@
\subsection{Unit tests}
Test module, followed by the corresponding implementation module.
<<[[eio_ascii_ut.f90]]>>=
<<File header>>
module eio_ascii_ut
use unit_tests
use eio_ascii_uti
<<Standard module head>>
<<EIO ascii: public test>>
contains
<<EIO ascii: test driver>>
end module eio_ascii_ut
@ %def eio_ascii_ut
@
<<[[eio_ascii_uti.f90]]>>=
<<File header>>
module eio_ascii_uti
<<Use kinds>>
<<Use strings>>
use io_units
use lorentz
use model_data
use event_base
use particles
use eio_data
use eio_base
use eio_ascii
use eio_base_ut, only: eio_prepare_test, eio_cleanup_test
<<Standard module head>>
<<EIO ascii: test declarations>>
contains
<<EIO ascii: tests>>
end module eio_ascii_uti
@ %def eio_ascii_uti
@ API: driver for the unit tests below.
<<EIO ascii: public test>>=
public :: eio_ascii_test
<<EIO ascii: test driver>>=
subroutine eio_ascii_test (u, results)
integer, intent(in) :: u
type(test_results_t), intent(inout) :: results
<<EIO ascii: execute tests>>
end subroutine eio_ascii_test
@ %def eio_ascii_test
@
\subsubsection{Test I/O methods}
We test the implementation of all I/O methods, method [[ascii]]:
<<EIO ascii: execute tests>>=
call test (eio_ascii_1, "eio_ascii_1", &
"read and write event contents, format [ascii]", &
u, results)
<<EIO ascii: test declarations>>=
public :: eio_ascii_1
<<EIO ascii: tests>>=
subroutine eio_ascii_1 (u)
integer, intent(in) :: u
class(generic_event_t), pointer :: event
type(event_sample_data_t) :: data
class(eio_t), allocatable :: eio
type(string_t) :: sample
integer :: u_file, iostat
character(80) :: buffer
write (u, "(A)") "* Test output: eio_ascii_1"
write (u, "(A)") "* Purpose: generate an event in ASCII ascii format"
write (u, "(A)") "* and write weight to file"
write (u, "(A)")
write (u, "(A)") "* Initialize test process"
call eio_prepare_test (event, unweighted = .false.)
call data%init (1)
data%n_evt = 1
data%n_beam = 2
data%pdg_beam = 25
data%energy_beam = 500
data%proc_num_id = [42]
data%cross_section(1) = 100
data%error(1) = 1
data%total_cross_section = sum (data%cross_section)
write (u, "(A)")
write (u, "(A)") "* Generate and write an event"
write (u, "(A)")
sample = "eio_ascii_1"
allocate (eio_ascii_ascii_t :: eio)
select type (eio)
class is (eio_ascii_t); call eio%set_parameters ()
end select
call eio%init_out (sample, data)
call event%generate (1, [0._default, 0._default])
call event%set_index (42)
call event%evaluate_expressions ()
call eio%output (event, i_prc = 1)
call eio%write (u)
call eio%final ()
write (u, "(A)")
write (u, "(A)") "* File contents:"
write (u, "(A)")
u_file = free_unit ()
open (u_file, file = char (sample // ".evt"), &
action = "read", status = "old")
do
read (u_file, "(A)", iostat = iostat) buffer
if (buffer(1:21) == " <generator_version>") buffer = "[...]"
if (iostat /= 0) exit
write (u, "(A)") trim (buffer)
end do
close (u_file)
write (u, "(A)")
write (u, "(A)") "* Reset data"
write (u, "(A)")
deallocate (eio)
allocate (eio_ascii_ascii_t :: eio)
select type (eio)
type is (eio_ascii_ascii_t)
call eio%set_parameters (keep_beams = .true.)
end select
call eio%write (u)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call eio_cleanup_test (event)
write (u, "(A)")
write (u, "(A)") "* Test output end: eio_ascii_1"
end subroutine eio_ascii_1
@ %def eio_ascii_1
@
We test the implementation of all I/O methods, method [[athena]]:
<<EIO ascii: execute tests>>=
call test (eio_ascii_2, "eio_ascii_2", &
"read and write event contents, format [athena]", &
u, results)
<<EIO ascii: test declarations>>=
public :: eio_ascii_2
<<EIO ascii: tests>>=
subroutine eio_ascii_2 (u)
integer, intent(in) :: u
class(generic_event_t), pointer :: event
type(event_sample_data_t) :: data
class(eio_t), allocatable :: eio
type(string_t) :: sample
integer :: u_file, iostat
character(80) :: buffer
write (u, "(A)") "* Test output: eio_ascii_2"
write (u, "(A)") "* Purpose: generate an event in ASCII athena format"
write (u, "(A)") "* and write weight to file"
write (u, "(A)")
write (u, "(A)") "* Initialize test process"
call eio_prepare_test (event, unweighted = .false.)
call data%init (1)
data%n_evt = 1
data%n_beam = 2
data%pdg_beam = 25
data%energy_beam = 500
data%proc_num_id = [42]
data%cross_section(1) = 100
data%error(1) = 1
data%total_cross_section = sum (data%cross_section)
write (u, "(A)")
write (u, "(A)") "* Generate and write an event"
write (u, "(A)")
sample = "eio_ascii_2"
allocate (eio_ascii_athena_t :: eio)
select type (eio)
class is (eio_ascii_t); call eio%set_parameters ()
end select
call eio%init_out (sample, data)
call event%generate (1, [0._default, 0._default])
call event%set_index (42)
call event%evaluate_expressions ()
call eio%output (event, i_prc = 1)
call eio%write (u)
call eio%final ()
write (u, "(A)")
write (u, "(A)") "* File contents:"
write (u, "(A)")
u_file = free_unit ()
open (u_file, file = char(sample // ".athena.evt"), &
action = "read", status = "old")
do
read (u_file, "(A)", iostat = iostat) buffer
if (buffer(1:21) == " <generator_version>") buffer = "[...]"
if (iostat /= 0) exit
write (u, "(A)") trim (buffer)
end do
close (u_file)
write (u, "(A)")
write (u, "(A)") "* Reset data"
write (u, "(A)")
deallocate (eio)
allocate (eio_ascii_athena_t :: eio)
select type (eio)
type is (eio_ascii_athena_t)
call eio%set_parameters (keep_beams = .true.)
end select
call eio%write (u)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call eio_cleanup_test (event)
write (u, "(A)")
write (u, "(A)") "* Test output end: eio_ascii_2"
end subroutine eio_ascii_2
@ %def eio_ascii_2
@
We test the implementation of all I/O methods, method [[debug]]:
<<EIO ascii: execute tests>>=
call test (eio_ascii_3, "eio_ascii_3", &
"read and write event contents, format [debug]", &
u, results)
<<EIO ascii: test declarations>>=
public :: eio_ascii_3
<<EIO ascii: tests>>=
subroutine eio_ascii_3 (u)
integer, intent(in) :: u
class(generic_event_t), pointer :: event
type(event_sample_data_t) :: data
class(eio_t), allocatable :: eio
type(string_t) :: sample
integer :: u_file, iostat
character(80) :: buffer
write (u, "(A)") "* Test output: eio_ascii_3"
write (u, "(A)") "* Purpose: generate an event in ASCII debug format"
write (u, "(A)") "* and write weight to file"
write (u, "(A)")
write (u, "(A)") "* Initialize test process"
call eio_prepare_test (event, unweighted = .false.)
call data%init (1)
data%n_evt = 1
data%n_beam = 2
data%pdg_beam = 25
data%energy_beam = 500
data%proc_num_id = [42]
data%cross_section(1) = 100
data%error(1) = 1
data%total_cross_section = sum (data%cross_section)
write (u, "(A)")
write (u, "(A)") "* Generate and write an event"
write (u, "(A)")
sample = "eio_ascii_3"
allocate (eio_ascii_debug_t :: eio)
select type (eio)
class is (eio_ascii_t); call eio%set_parameters ()
end select
call eio%init_out (sample, data)
call event%generate (1, [0._default, 0._default])
call event%increment_index ()
call event%evaluate_expressions ()
call eio%output (event, i_prc = 1)
call eio%write (u)
call eio%final ()
write (u, "(A)")
write (u, "(A)") "* File contents:"
write (u, "(A)")
u_file = free_unit ()
open (u_file, file = char (sample // ".debug"), &
action = "read", status = "old")
do
read (u_file, "(A)", iostat = iostat) buffer
if (buffer(1:21) == " <generator_version>") buffer = "[...]"
if (iostat /= 0) exit
write (u, "(A)") trim (buffer)
end do
close (u_file)
write (u, "(A)")
write (u, "(A)") "* Reset data"
write (u, "(A)")
deallocate (eio)
allocate (eio_ascii_debug_t :: eio)
select type (eio)
type is (eio_ascii_debug_t)
call eio%set_parameters (keep_beams = .true.)
end select
call eio%write (u)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call eio_cleanup_test (event)
write (u, "(A)")
write (u, "(A)") "* Test output end: eio_ascii_3"
end subroutine eio_ascii_3
@ %def eio_ascii_3
@
We test the implementation of all I/O methods, method [[hepevt]]:
<<EIO ascii: execute tests>>=
call test (eio_ascii_4, "eio_ascii_4", &
"read and write event contents, format [hepevt]", &
u, results)
<<EIO ascii: test declarations>>=
public :: eio_ascii_4
<<EIO ascii: tests>>=
subroutine eio_ascii_4 (u)
integer, intent(in) :: u
class(generic_event_t), pointer :: event
type(event_sample_data_t) :: data
class(eio_t), allocatable :: eio
type(string_t) :: sample
integer :: u_file, iostat
character(80) :: buffer
write (u, "(A)") "* Test output: eio_ascii_4"
write (u, "(A)") "* Purpose: generate an event in ASCII hepevt format"
write (u, "(A)") "* and write weight to file"
write (u, "(A)")
write (u, "(A)") "* Initialize test process"
call eio_prepare_test (event, unweighted = .false.)
call data%init (1)
data%n_evt = 1
data%n_beam = 2
data%pdg_beam = 25
data%energy_beam = 500
data%proc_num_id = [42]
data%cross_section(1) = 100
data%error(1) = 1
data%total_cross_section = sum (data%cross_section)
write (u, "(A)")
write (u, "(A)") "* Generate and write an event"
write (u, "(A)")
sample = "eio_ascii_4"
allocate (eio_ascii_hepevt_t :: eio)
select type (eio)
class is (eio_ascii_t); call eio%set_parameters ()
end select
call eio%init_out (sample, data)
call event%generate (1, [0._default, 0._default])
call event%increment_index ()
call event%evaluate_expressions ()
call eio%output (event, i_prc = 1)
call eio%write (u)
call eio%final ()
write (u, "(A)")
write (u, "(A)") "* File contents:"
write (u, "(A)")
u_file = free_unit ()
open (u_file, file = char (sample // ".hepevt"), &
action = "read", status = "old")
do
read (u_file, "(A)", iostat = iostat) buffer
if (buffer(1:21) == " <generator_version>") buffer = "[...]"
if (iostat /= 0) exit
write (u, "(A)") trim (buffer)
end do
close (u_file)
write (u, "(A)")
write (u, "(A)") "* Reset data"
write (u, "(A)")
deallocate (eio)
allocate (eio_ascii_hepevt_t :: eio)
select type (eio)
type is (eio_ascii_hepevt_t)
call eio%set_parameters (keep_beams = .true.)
end select
call eio%write (u)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call eio_cleanup_test (event)
write (u, "(A)")
write (u, "(A)") "* Test output end: eio_ascii_4"
end subroutine eio_ascii_4
@ %def eio_ascii_4
@
We test the implementation of all I/O methods, method [[lha]] (old LHA):
<<EIO ascii: execute tests>>=
call test (eio_ascii_5, "eio_ascii_5", &
"read and write event contents, format [lha]", &
u, results)
<<EIO ascii: test declarations>>=
public :: eio_ascii_5
<<EIO ascii: tests>>=
subroutine eio_ascii_5 (u)
integer, intent(in) :: u
class(generic_event_t), pointer :: event
type(event_sample_data_t) :: data
class(eio_t), allocatable :: eio
type(string_t) :: sample
integer :: u_file, iostat
character(80) :: buffer
write (u, "(A)") "* Test output: eio_ascii_5"
write (u, "(A)") "* Purpose: generate an event in ASCII LHA format"
write (u, "(A)") "* and write weight to file"
write (u, "(A)")
write (u, "(A)") "* Initialize test process"
call eio_prepare_test (event, unweighted = .false.)
call data%init (1)
data%n_evt = 1
data%n_beam = 2
data%pdg_beam = 25
data%energy_beam = 500
data%proc_num_id = [42]
data%cross_section(1) = 100
data%error(1) = 1
data%total_cross_section = sum (data%cross_section)
write (u, "(A)")
write (u, "(A)") "* Generate and write an event"
write (u, "(A)")
sample = "eio_ascii_5"
allocate (eio_ascii_lha_t :: eio)
select type (eio)
class is (eio_ascii_t); call eio%set_parameters ()
end select
call eio%init_out (sample, data)
call event%generate (1, [0._default, 0._default])
call event%increment_index ()
call event%evaluate_expressions ()
call eio%output (event, i_prc = 1)
call eio%write (u)
call eio%final ()
write (u, "(A)")
write (u, "(A)") "* File contents:"
write (u, "(A)")
u_file = free_unit ()
open (u_file, file = char (sample // ".lha"), &
action = "read", status = "old")
do
read (u_file, "(A)", iostat = iostat) buffer
if (buffer(1:21) == " <generator_version>") buffer = "[...]"
if (iostat /= 0) exit
write (u, "(A)") trim (buffer)
end do
close (u_file)
write (u, "(A)")
write (u, "(A)") "* Reset data"
write (u, "(A)")
deallocate (eio)
allocate (eio_ascii_lha_t :: eio)
select type (eio)
type is (eio_ascii_lha_t)
call eio%set_parameters (keep_beams = .true.)
end select
call eio%write (u)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call eio_cleanup_test (event)
write (u, "(A)")
write (u, "(A)") "* Test output end: eio_ascii_5"
end subroutine eio_ascii_5
@ %def eio_ascii_5
@
We test the implementation of all I/O methods, method [[long]]:
<<EIO ascii: execute tests>>=
call test (eio_ascii_6, "eio_ascii_6", &
"read and write event contents, format [long]", &
u, results)
<<EIO ascii: test declarations>>=
public :: eio_ascii_6
<<EIO ascii: tests>>=
subroutine eio_ascii_6 (u)
integer, intent(in) :: u
class(generic_event_t), pointer :: event
type(event_sample_data_t) :: data
class(eio_t), allocatable :: eio
type(string_t) :: sample
integer :: u_file, iostat
character(80) :: buffer
write (u, "(A)") "* Test output: eio_ascii_6"
write (u, "(A)") "* Purpose: generate an event in ASCII long format"
write (u, "(A)") "* and write weight to file"
write (u, "(A)")
write (u, "(A)") "* Initialize test process"
call eio_prepare_test (event, unweighted = .false.)
call data%init (1)
data%n_evt = 1
data%n_beam = 2
data%pdg_beam = 25
data%energy_beam = 500
data%proc_num_id = [42]
data%cross_section(1) = 100
data%error(1) = 1
data%total_cross_section = sum (data%cross_section)
write (u, "(A)")
write (u, "(A)") "* Generate and write an event"
write (u, "(A)")
sample = "eio_ascii_6"
allocate (eio_ascii_long_t :: eio)
select type (eio)
class is (eio_ascii_t); call eio%set_parameters ()
end select
call eio%init_out (sample, data)
call event%generate (1, [0._default, 0._default])
call event%increment_index ()
call event%evaluate_expressions ()
call eio%output (event, i_prc = 1)
call eio%write (u)
call eio%final ()
write (u, "(A)")
write (u, "(A)") "* File contents:"
write (u, "(A)")
u_file = free_unit ()
open (u_file, file = char (sample // ".long.evt"), &
action = "read", status = "old")
do
read (u_file, "(A)", iostat = iostat) buffer
if (buffer(1:21) == " <generator_version>") buffer = "[...]"
if (iostat /= 0) exit
write (u, "(A)") trim (buffer)
end do
close (u_file)
write (u, "(A)")
write (u, "(A)") "* Reset data"
write (u, "(A)")
deallocate (eio)
allocate (eio_ascii_long_t :: eio)
select type (eio)
type is (eio_ascii_long_t)
call eio%set_parameters (keep_beams = .true.)
end select
call eio%write (u)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call eio_cleanup_test (event)
write (u, "(A)")
write (u, "(A)") "* Test output end: eio_ascii_6"
end subroutine eio_ascii_6
@ %def eio_ascii_6
@
We test the implementation of all I/O methods, method [[mokka]]:
<<EIO ascii: execute tests>>=
call test (eio_ascii_7, "eio_ascii_7", &
"read and write event contents, format [mokka]", &
u, results)
<<EIO ascii: test declarations>>=
public :: eio_ascii_7
<<EIO ascii: tests>>=
subroutine eio_ascii_7 (u)
integer, intent(in) :: u
class(generic_event_t), pointer :: event
type(event_sample_data_t) :: data
class(eio_t), allocatable :: eio
type(string_t) :: sample
integer :: u_file, iostat
character(80) :: buffer
write (u, "(A)") "* Test output: eio_ascii_7"
write (u, "(A)") "* Purpose: generate an event in ASCII mokka format"
write (u, "(A)") "* and write weight to file"
write (u, "(A)")
write (u, "(A)") "* Initialize test process"
call eio_prepare_test (event, unweighted = .false.)
call data%init (1)
data%n_evt = 1
data%n_beam = 2
data%pdg_beam = 25
data%energy_beam = 500
data%proc_num_id = [42]
data%cross_section(1) = 100
data%error(1) = 1
data%total_cross_section = sum (data%cross_section)
write (u, "(A)")
write (u, "(A)") "* Generate and write an event"
write (u, "(A)")
sample = "eio_ascii_7"
allocate (eio_ascii_mokka_t :: eio)
select type (eio)
class is (eio_ascii_t); call eio%set_parameters ()
end select
call eio%init_out (sample, data)
call event%generate (1, [0._default, 0._default])
call event%increment_index ()
call event%evaluate_expressions ()
call eio%output (event, i_prc = 1)
call eio%write (u)
call eio%final ()
write (u, "(A)")
write (u, "(A)") "* File contents:"
write (u, "(A)")
u_file = free_unit ()
open (u_file, file = char (sample // ".mokka.evt"), &
action = "read", status = "old")
do
read (u_file, "(A)", iostat = iostat) buffer
if (buffer(1:21) == " <generator_version>") buffer = "[...]"
if (iostat /= 0) exit
write (u, "(A)") trim (buffer)
end do
close (u_file)
write (u, "(A)")
write (u, "(A)") "* Reset data"
write (u, "(A)")
deallocate (eio)
allocate (eio_ascii_mokka_t :: eio)
select type (eio)
type is (eio_ascii_mokka_t)
call eio%set_parameters (keep_beams = .true.)
end select
call eio%write (u)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call eio_cleanup_test (event)
write (u, "(A)")
write (u, "(A)") "* Test output end: eio_ascii_7"
end subroutine eio_ascii_7
@ %def eio_ascii_7
@
We test the implementation of all I/O methods, method [[short]]:
<<EIO ascii: execute tests>>=
call test (eio_ascii_8, "eio_ascii_8", &
"read and write event contents, format [short]", &
u, results)
<<EIO ascii: test declarations>>=
public :: eio_ascii_8
<<EIO ascii: tests>>=
subroutine eio_ascii_8 (u)
integer, intent(in) :: u
class(generic_event_t), pointer :: event
type(event_sample_data_t) :: data
class(eio_t), allocatable :: eio
type(string_t) :: sample
integer :: u_file, iostat
character(80) :: buffer
write (u, "(A)") "* Test output: eio_ascii_8"
write (u, "(A)") "* Purpose: generate an event in ASCII short format"
write (u, "(A)") "* and write weight to file"
write (u, "(A)")
write (u, "(A)") "* Initialize test process"
call eio_prepare_test (event, unweighted = .false.)
call data%init (1)
data%n_evt = 1
data%n_beam = 2
data%pdg_beam = 25
data%energy_beam = 500
data%proc_num_id = [42]
data%cross_section(1) = 100
data%error(1) = 1
data%total_cross_section = sum (data%cross_section)
write (u, "(A)")
write (u, "(A)") "* Generate and write an event"
write (u, "(A)")
sample = "eio_ascii_8"
allocate (eio_ascii_short_t :: eio)
select type (eio)
class is (eio_ascii_t); call eio%set_parameters ()
end select
call eio%init_out (sample, data)
call event%generate (1, [0._default, 0._default])
call event%increment_index ()
call event%evaluate_expressions ()
call eio%output (event, i_prc = 1)
call eio%write (u)
call eio%final ()
write (u, "(A)")
write (u, "(A)") "* File contents:"
write (u, "(A)")
u_file = free_unit ()
open (u_file, file = char (sample // ".short.evt"), &
action = "read", status = "old")
do
read (u_file, "(A)", iostat = iostat) buffer
if (buffer(1:21) == " <generator_version>") buffer = "[...]"
if (iostat /= 0) exit
write (u, "(A)") trim (buffer)
end do
close (u_file)
write (u, "(A)")
write (u, "(A)") "* Reset data"
write (u, "(A)")
deallocate (eio)
allocate (eio_ascii_short_t :: eio)
select type (eio)
type is (eio_ascii_short_t)
call eio%set_parameters (keep_beams = .true.)
end select
call eio%write (u)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call eio_cleanup_test (event)
write (u, "(A)")
write (u, "(A)") "* Test output end: eio_ascii_8"
end subroutine eio_ascii_8
@ %def eio_ascii_8
@
We test the implementation of all I/O methods, method [[lha]] (old
LHA) in verbose version:
<<EIO ascii: execute tests>>=
call test (eio_ascii_9, "eio_ascii_9", &
"read and write event contents, format [lha_verb]", &
u, results)
<<EIO ascii: test declarations>>=
public :: eio_ascii_9
<<EIO ascii: tests>>=
subroutine eio_ascii_9 (u)
integer, intent(in) :: u
class(generic_event_t), pointer :: event
type(event_sample_data_t) :: data
class(eio_t), allocatable :: eio
type(string_t) :: sample
integer :: u_file, iostat
character(80) :: buffer
write (u, "(A)") "* Test output: eio_ascii_9"
write (u, "(A)") "* Purpose: generate an event in ASCII LHA verbose format"
write (u, "(A)") "* and write weight to file"
write (u, "(A)")
write (u, "(A)") "* Initialize test process"
call eio_prepare_test (event, unweighted = .false.)
call data%init (1)
data%n_evt = 1
data%n_beam = 2
data%pdg_beam = 25
data%energy_beam = 500
data%proc_num_id = [42]
data%cross_section(1) = 100
data%error(1) = 1
data%total_cross_section = sum (data%cross_section)
write (u, "(A)")
write (u, "(A)") "* Generate and write an event"
write (u, "(A)")
sample = "eio_ascii_9"
allocate (eio_ascii_lha_verb_t :: eio)
select type (eio)
class is (eio_ascii_t); call eio%set_parameters ()
end select
call eio%init_out (sample, data)
call event%generate (1, [0._default, 0._default])
call event%increment_index ()
call event%evaluate_expressions ()
call eio%output (event, i_prc = 1)
call eio%write (u)
call eio%final ()
write (u, "(A)")
write (u, "(A)") "* File contents:"
write (u, "(A)")
u_file = free_unit ()
open (u_file, file = char (sample // ".lha.verb"), &
action = "read", status = "old")
do
read (u_file, "(A)", iostat = iostat) buffer
if (buffer(1:21) == " <generator_version>") buffer = "[...]"
if (iostat /= 0) exit
write (u, "(A)") trim (buffer)
end do
close (u_file)
write (u, "(A)")
write (u, "(A)") "* Reset data"
write (u, "(A)")
deallocate (eio)
allocate (eio_ascii_lha_verb_t :: eio)
select type (eio)
type is (eio_ascii_lha_verb_t)
call eio%set_parameters (keep_beams = .true.)
end select
call eio%write (u)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call eio_cleanup_test (event)
write (u, "(A)")
write (u, "(A)") "* Test output end: eio_ascii_9"
end subroutine eio_ascii_9
@ %def eio_ascii_9
@
We test the implementation of all I/O methods, method [[hepevt_verb]]:
<<EIO ascii: execute tests>>=
call test (eio_ascii_10, "eio_ascii_10", &
"read and write event contents, format [hepevt_verb]", &
u, results)
<<EIO ascii: test declarations>>=
public :: eio_ascii_10
<<EIO ascii: tests>>=
subroutine eio_ascii_10 (u)
integer, intent(in) :: u
class(generic_event_t), pointer :: event
type(event_sample_data_t) :: data
class(eio_t), allocatable :: eio
type(string_t) :: sample
integer :: u_file, iostat
character(80) :: buffer
write (u, "(A)") "* Test output: eio_ascii_10"
write (u, "(A)") "* Purpose: generate an event in ASCII hepevt verbose format"
write (u, "(A)") "* and write weight to file"
write (u, "(A)")
write (u, "(A)") "* Initialize test process"
call eio_prepare_test (event, unweighted = .false.)
call data%init (1)
data%n_evt = 1
data%n_beam = 2
data%pdg_beam = 25
data%energy_beam = 500
data%proc_num_id = [42]
data%cross_section(1) = 100
data%error(1) = 1
data%total_cross_section = sum (data%cross_section)
write (u, "(A)")
write (u, "(A)") "* Generate and write an event"
write (u, "(A)")
sample = "eio_ascii_10"
allocate (eio_ascii_hepevt_verb_t :: eio)
select type (eio)
class is (eio_ascii_t); call eio%set_parameters ()
end select
call eio%init_out (sample, data)
call event%generate (1, [0._default, 0._default])
call event%increment_index ()
call event%evaluate_expressions ()
call eio%output (event, i_prc = 1)
call eio%write (u)
call eio%final ()
write (u, "(A)")
write (u, "(A)") "* File contents:"
write (u, "(A)")
u_file = free_unit ()
open (u_file, file = char (sample // ".hepevt.verb"), &
action = "read", status = "old")
do
read (u_file, "(A)", iostat = iostat) buffer
if (buffer(1:21) == " <generator_version>") buffer = "[...]"
if (iostat /= 0) exit
write (u, "(A)") trim (buffer)
end do
close (u_file)
write (u, "(A)")
write (u, "(A)") "* Reset data"
write (u, "(A)")
deallocate (eio)
allocate (eio_ascii_hepevt_verb_t :: eio)
select type (eio)
type is (eio_ascii_hepevt_verb_t)
call eio%set_parameters (keep_beams = .true.)
end select
call eio%write (u)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call eio_cleanup_test (event)
write (u, "(A)")
write (u, "(A)") "* Test output end: eio_ascii_10"
end subroutine eio_ascii_10
@ %def eio_ascii_10
@
We test the implementation of all I/O methods, method [[mokka]]:
<<EIO ascii: execute tests>>=
call test (eio_ascii_11, "eio_ascii_11", &
"read and write event contents, format [mokka], tiny value", &
u, results)
<<EIO ascii: test declarations>>=
public :: eio_ascii_11
<<EIO ascii: tests>>=
subroutine eio_ascii_11 (u)
integer, intent(in) :: u
class(generic_event_t), pointer :: event
type(particle_set_t), pointer :: pset
type(vector4_t) :: pnew
type(event_sample_data_t) :: data
class(eio_t), allocatable :: eio
type(string_t) :: sample
integer :: u_file, iostat
character(128) :: buffer
real(default), parameter :: tval = 1.e-111_default
write (u, "(A)") "* Test output: eio_ascii_11"
write (u, "(A)") "* Purpose: generate an event in ASCII mokka format"
write (u, "(A)") "* and write weight to file"
write (u, "(A)") "* with low-value cutoff"
write (u, "(A)")
write (u, "(A)") "* Initialize test process"
call eio_prepare_test (event, unweighted = .false.)
call data%init (1)
data%n_evt = 1
data%n_beam = 2
data%pdg_beam = 25
data%energy_beam = 500
data%proc_num_id = [42]
data%cross_section(1) = 100
data%error(1) = 1
data%total_cross_section = sum (data%cross_section)
write (u, "(A)")
write (u, "(A)") "* Generate and write an event"
write (u, "(A)")
sample = "eio_ascii_11"
allocate (eio_ascii_mokka_t :: eio)
select type (eio)
class is (eio_ascii_t); call eio%set_parameters ()
end select
call eio%init_out (sample, data)
call event%generate (1, [0._default, 0._default])
call event%increment_index ()
call event%evaluate_expressions ()
! Manipulate values in the event record
pset => event%get_particle_set_ptr ()
call pset%set_momentum (3, &
vector4_moving (-tval, vector3_moving ([-tval, -tval, -tval])), &
-tval**2)
call pset%set_momentum (4, &
vector4_moving (tval, vector3_moving ([tval, tval, tval])), &
tval**2)
call eio%output (event, i_prc = 1)
call eio%write (u)
call eio%final ()
write (u, "(A)")
write (u, "(A)") "* File contents:"
write (u, "(A)")
u_file = free_unit ()
open (u_file, file = char (sample // ".mokka.evt"), &
action = "read", status = "old")
do
read (u_file, "(A)", iostat = iostat) buffer
if (buffer(1:21) == " <generator_version>") buffer = "[...]"
if (iostat /= 0) exit
write (u, "(A)") trim (buffer)
end do
close (u_file)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call eio_cleanup_test (event)
write (u, "(A)")
write (u, "(A)") "* Test output end: eio_ascii_11"
end subroutine eio_ascii_11
@ %def eio_ascii_11
@
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{HEP Common Blocks}
Long ago, to transfer data between programs one had to set up a common
block and link both programs as libraries to the main executable. The
HEP community standardizes several of those common blocks.
The modern way of data exchange uses data files with standard
formats. However, the LHEF standard data format derives from a common
block (actually, two).
\whizard\ used to support those common blocks, and LHEF was
implemented via writing/reading blocks. We still keep this
convention, but intend to eliminate common blocks (or any other static
storage) from the workflow in the future. This will gain flexibility
towards concurrent running of program images.
We encapsulate everything here in a module. The module holds the
variables which are part of the common block. To access the common
block variables, we just have to [[use]] this module. (They are
nevertheless in the common block, since external software may access
it in this way.)
Note: This code is taken essentially unchanged from \whizard\ 2.1 and
does not (yet) provide unit tests.
<<[[hep_common.f90]]>>=
<<File header>>
module hep_common
<<Use kinds>>
use kinds, only: double
use constants
<<Use strings>>
<<Use debug>>
use io_units
use diagnostics
use numeric_utils
use format_utils, only: refmt_tiny
use physics_defs, only: HADRON_REMNANT
use physics_defs, only: HADRON_REMNANT_SINGLET
use physics_defs, only: HADRON_REMNANT_TRIPLET
use physics_defs, only: HADRON_REMNANT_OCTET
use physics_defs, only: pb_per_fb
use xml
use lorentz
use flavors
use colors
use polarizations
use model_data
use particles
use subevents, only: PRT_BEAM, PRT_INCOMING, PRT_OUTGOING
use subevents, only: PRT_UNDEFINED
use subevents, only: PRT_VIRTUAL, PRT_RESONANT, PRT_BEAM_REMNANT
<<Standard module head>>
<<HEP common: public>>
<<HEP common: interfaces>>
<<HEP common: parameters>>
<<HEP common: variables>>
<<HEP common: common blocks>>
contains
<<HEP common: procedures>>
end module hep_common
@ %def hep_common
@
\subsection{Event characteristics}
The maximal number of particles in an event record.
<<HEP common: parameters>>=
integer, parameter, public :: MAXNUP = 500
@ %def MAXNUP
@ The number of particles in this event.
<<HEP common: variables>>=
integer, public :: NUP
@ %def NUP
@ The process ID for this event.
<<HEP common: variables>>=
integer, public :: IDPRUP
@ %def IDPRUP
@ The weight of this event ($\pm 1$ for unweighted events).
<<HEP common: variables>>=
double precision, public :: XWGTUP
@ %def XWGTUP
@ The factorization scale that is used for PDF calculation ($-1$ if
undefined).
<<HEP common: variables>>=
double precision, public :: SCALUP
@ %def SCALUP
@ The QED and QCD couplings $\alpha$ used for this event ($-1$ if
undefined).
<<HEP common: variables>>=
double precision, public :: AQEDUP
double precision, public :: AQCDUP
@ %def AQEDUP AQCDUP
@
\subsection{Particle characteristics}
The PDG code:
<<HEP common: variables>>=
integer, dimension(MAXNUP), public :: IDUP
@ %def IDUP
@ The status code. Incoming: $-1$, outgoing: $+1$. Intermediate
t-channel propagator: $-2$ (currently not used by WHIZARD).
Intermediate resonance whose mass should be preserved: $2$.
Intermediate resonance for documentation: $3$ (currently not used).
Beam particles: $-9$.
<<HEP common: variables>>=
integer, dimension(MAXNUP), public :: ISTUP
@ %def ISTUP
@ Index of first and last mother.
<<HEP common: variables>>=
integer, dimension(2,MAXNUP), public :: MOTHUP
@ %def MOTHUP
@ Color line index of the color and anticolor entry for the particle.
The standard recommends using large numbers; we start from MAXNUP+1.
<<HEP common: variables>>=
integer, dimension(2,MAXNUP), public :: ICOLUP
@ %def ICOLUP
@ Momentum, energy, and invariant mass: $(p_x,p_y,p_z,E,M)$. For
space-like particles, $M$ is the negative square root of the absolute
value of the invariant mass.
<<HEP common: variables>>=
double precision, dimension(5,MAXNUP), public :: PUP
@ %def PUP
@ Invariant lifetime (distance) from production to decay in mm.
<<HEP common: variables>>=
double precision, dimension(MAXNUP), public :: VTIMUP
@ %def VTIMUP
@ Cosine of the angle between the spin-vector and a particle and the
3-momentum of its mother, given in the lab frame. If
undefined/unpolarized: $9$.
<<HEP common: variables>>=
double precision, dimension(MAXNUP), public :: SPINUP
@ %def SPINUP
@
\subsection{The HEPRUP common block}
This common block is filled once per run.
\subsubsection{Run characteristics}
The maximal number of different processes.
<<HEP common: parameters>>=
integer, parameter, public :: MAXPUP = 100
@ %def MAXPUP
@ The beam PDG codes.
<<HEP common: variables>>=
integer, dimension(2), public :: IDBMUP
@ %def IDBMUP
@ The beam energies in GeV.
<<HEP common: variables>>=
double precision, dimension(2), public :: EBMUP
@ %def EBMUP
@ The PDF group and set for the two beams. (Undefined: use $-1$;
LHAPDF: use group = $0$).
<<HEP common: variables>>=
integer, dimension(2), public :: PDFGUP
integer, dimension(2), public :: PDFSUP
@ %def PDFGUP PDFSUP
@ The (re)weighting model. 1: events are weighted, the shower
generator (SHG) selects processes according to the maximum weight (in
pb) and unweights events. 2: events are weighted, the SHG selects
processes according to their cross section (in pb) and unweights
events. 3: events are unweighted and simply run through the SHG. 4:
events are weighted, and the SHG keeps the weight. Negative numbers:
negative weights are allowed (and are reweighted to $\pm 1$ by the
SHG, if allowed).
\whizard\ only supports modes 3 and 4, as the SHG is not given control
over process selection. This is consistent with writing events to
file, for offline showering.
<<HEP common: variables>>=
integer, public :: IDWTUP
@ %def IDWTUP
@ The number of different processes.
<<HEP common: variables>>=
integer, public :: NPRUP
@ %def NPRUP
@
\subsubsection{Process characteristics}
Cross section and error in pb. (Cross section is needed only for
$[[IDWTUP]] = 2$, so here both values are given for informational
purposes only.)
<<HEP common: variables>>=
double precision, dimension(MAXPUP), public :: XSECUP
double precision, dimension(MAXPUP), public :: XERRUP
@ %def XSECUP XERRUP
@ Maximum weight, i.e., the maximum value that [[XWGTUP]] can take.
Also unused for the supported weighting models. It is $\pm 1$ for
unweighted events.
<<HEP common: variables>>=
double precision, dimension(MAXPUP), public :: XMAXUP
@ %def XMAXUP
@ Internal ID of the selected process, matches [[IDPRUP]] below.
<<HEP common: variables>>=
integer, dimension(MAXPUP), public :: LPRUP
@ %def LPRUP
@
\subsubsection{The common block}
<<HEP common: common blocks>>=
common /HEPRUP/ &
IDBMUP, EBMUP, PDFGUP, PDFSUP, IDWTUP, NPRUP, &
XSECUP, XERRUP, XMAXUP, LPRUP
save /HEPRUP/
@ %def HEPRUP
@ Fill the run characteristics of the common block. The
initialization sets the beam properties, number of processes, and
weighting model.
<<HEP common: public>>=
public :: heprup_init
<<HEP common: procedures>>=
subroutine heprup_init &
(beam_pdg, beam_energy, n_processes, unweighted, negative_weights)
integer, dimension(2), intent(in) :: beam_pdg
real(default), dimension(2), intent(in) :: beam_energy
integer, intent(in) :: n_processes
logical, intent(in) :: unweighted
logical, intent(in) :: negative_weights
IDBMUP = beam_pdg
EBMUP = beam_energy
PDFGUP = -1
PDFSUP = -1
if (unweighted) then
IDWTUP = 3
else
IDWTUP = 4
end if
if (negative_weights) IDWTUP = - IDWTUP
NPRUP = n_processes
end subroutine heprup_init
@ %def heprup_init
The HEPRUP (event) common block is needed for the interface to the shower.
Filling of it is triggered by some output file formats. If these are not
present, the common block is filled with some dummy information. Be generous
with the number of processes in HEPRUP so that PYTHIA only rarely needs to be
reinitialized in case events with higher process ids are generated.
<<HEP common: public>>=
public :: assure_heprup
<<HEP common: procedures>>=
subroutine assure_heprup (pset)
type(particle_set_t), intent(in) :: pset
integer :: i, num_id
integer, parameter :: min_processes = 10
num_id = 1
if (LPRUP (num_id) /= 0) return
call heprup_init ( &
[pset%prt(1)%get_pdg (), pset%prt(2)%get_pdg ()] , &
[pset%prt(1)%p%p(0), pset%prt(2)%p%p(0)], &
num_id, .false., .false.)
do i = 1, (num_id / min_processes + 1) * min_processes
call heprup_set_process_parameters (i = i, process_id = &
i, cross_section = 1._default, error = 1._default)
end do
end subroutine assure_heprup
@ %def assure_heprup
@ Read in the LHE file opened in unit [[u]] and add the final
particles to the [[particle_set]], the outgoing particles of the existing
[[particle_set]] are compared to the particles that are read in. When
they are equal in flavor and momenta, they are erased and their
mother-daughter relations are transferred to the existing particles.
<<HEP common: public>>=
public :: combine_lhef_with_particle_set
<<HEP common: procedures>>=
subroutine combine_lhef_with_particle_set &
(particle_set, u, model_in, model_hadrons)
type(particle_set_t), intent(inout) :: particle_set
integer, intent(in) :: u
class(model_data_t), intent(in), target :: model_in
class(model_data_t), intent(in), target :: model_hadrons
type(flavor_t) :: flv
type(color_t) :: col
class(model_data_t), pointer :: model
type(particle_t), dimension(:), allocatable :: prt_tmp, prt
integer :: i, j
type(vector4_t) :: mom, d_mom
integer, PARAMETER :: MAXLEN=200
character(len=maxlen) :: string
integer :: ibeg, n_tot, n_entries
integer, dimension(:), allocatable :: relations, mothers, tbd
INTEGER :: NUP,IDPRUP,IDUP,ISTUP
real(kind=double) :: XWGTUP,SCALUP,AQEDUP,AQCDUP,VTIMUP,SPINUP
integer :: MOTHUP(1:2), ICOLUP(1:2)
real(kind=double) :: PUP(1:5)
real(kind=default) :: pup_dum(1:5)
character(len=5) :: buffer
character(len=6) :: strfmt
logical :: not_found
logical :: debug_lhef = .false.
STRFMT='(A000)'
WRITE (STRFMT(3:5),'(I3)') MAXLEN
if (debug_lhef) call particle_set%write ()
rewind (u)
do
read (u,*, END=501, ERR=502) STRING
IBEG = 0
do
if (signal_is_pending ()) return
IBEG = IBEG + 1
! Allow indentation.
IF (STRING (IBEG:IBEG) .EQ. ' ' .and. IBEG < MAXLEN-6) cycle
exit
end do
IF (string(IBEG:IBEG+6) /= '<event>' .and. &
string(IBEG:IBEG+6) /= '<event ') cycle
exit
end do
!!! Read first line of event info -> number of entries
read (u, *, END=503, ERR=504) NUP, IDPRUP, XWGTUP, SCALUP, AQEDUP, AQCDUP
n_tot = particle_set%get_n_tot ()
allocate (prt_tmp (1:n_tot+NUP))
allocate (relations (1:NUP), mothers (1:NUP), tbd(1:NUP))
do i = 1, n_tot
if (signal_is_pending ()) return
prt_tmp (i) = particle_set%get_particle (i)
end do
!!! transfer particles from lhef to particle_set
!!!...Read NUP subsequent lines with information on each particle.
n_entries = 1
mothers = 0
relations = 0
PARTICLE_LOOP: do I = 1, NUP
read (u,*, END=200, ERR=505) IDUP, ISTUP, MOTHUP(1), MOTHUP(2), &
ICOLUP(1), ICOLUP(2), (PUP (J),J=1,5), VTIMUP, SPINUP
if (model_in%test_field (IDUP)) then
model => model_in
else if (model_hadrons%test_field (IDUP)) then
model => model_hadrons
else
write (buffer, "(I5)") IDUP
call msg_error ("Parton " // buffer // &
" found neither in given model file nor in SM_hadrons")
return
end if
if (debug_lhef) then
print *, "IDUP, ISTUP, MOTHUP, PUP = ", IDUP, ISTUP, MOTHUP(1), &
MOTHUP(2), PUP
end if
call flv%init (IDUP, model)
if (IABS(IDUP) == 2212 .or. IABS(IDUP) == 2112) then
! PYTHIA sometimes sets color indices for protons and neutrons (?)
ICOLUP (1) = 0
ICOLUP (2) = 0
end if
call col%init_col_acl (ICOLUP (1), ICOLUP (2))
!!! Settings for unpolarized particles
! particle_set%prt (oldsize+i)%hel = ??
! particle_set%prt (oldsize+i)%pol = ??
if (MOTHUP(1) /= 0) then
mothers(i) = MOTHUP(1)
end if
pup_dum = PUP
if (pup_dum(4) < 1E-10_default) cycle
mom = vector4_moving (pup_dum (4), &
vector3_moving ([pup_dum (1), pup_dum (2), pup_dum (3)]))
not_found = .true.
SCAN_PARTICLES: do j = 1, n_tot
d_mom = prt_tmp(j)%get_momentum ()
if (all (nearly_equal &
(mom%p, d_mom%p, abs_smallness = 1.E-4_default)) .and. &
(prt_tmp(j)%get_pdg () == IDUP)) then
if (.not. prt_tmp(j)%get_status () == PRT_BEAM .or. &
.not. prt_tmp(j)%get_status () == PRT_BEAM_REMNANT) &
relations(i) = j
not_found = .false.
end if
end do SCAN_PARTICLES
if (not_found) then
if (debug_lhef) &
print *, "Not found: adding particle"
call prt_tmp(n_tot+n_entries)%set_flavor (flv)
call prt_tmp(n_tot+n_entries)%set_color (col)
call prt_tmp(n_tot+n_entries)%set_momentum (mom)
if (MOTHUP(1) /= 0) then
if (relations(MOTHUP(1)) /= 0) then
call prt_tmp(n_tot+n_entries)%set_parents &
([relations(MOTHUP(1))])
call prt_tmp(relations(MOTHUP(1)))%add_child (n_tot+n_entries)
if (prt_tmp(relations(MOTHUP(1)))%get_status () &
== PRT_OUTGOING) &
call prt_tmp(relations(MOTHUP(1)))%reset_status &
(PRT_VIRTUAL)
end if
end if
call prt_tmp(n_tot+n_entries)%set_status (PRT_OUTGOING)
if (debug_lhef) call prt_tmp(n_tot+n_entries)%write ()
n_entries = n_entries + 1
end if
end do PARTICLE_LOOP
do i = 1, n_tot
if (prt_tmp(i)%get_status () == PRT_OUTGOING .and. &
prt_tmp(i)%get_n_children () /= 0) then
call prt_tmp(i)%reset_status (PRT_VIRTUAL)
end if
end do
allocate (prt (1:n_tot+n_entries-1))
prt = prt_tmp (1:n_tot+n_entries-1)
! transfer to particle_set
call particle_set%replace (prt)
deallocate (prt, prt_tmp)
if (debug_lhef) then
call particle_set%write ()
print *, "combine_lhef_with_particle_set"
! stop
end if
200 continue
return
501 write(*,*) "READING LHEF failed 501"
return
502 write(*,*) "READING LHEF failed 502"
return
503 write(*,*) "READING LHEF failed 503"
return
504 write(*,*) "READING LHEF failed 504"
return
505 write(*,*) "READING LHEF failed 505"
return
end subroutine combine_lhef_with_particle_set
@ %def combine_lhef_with_particle_set
@
<<HEP common: public>>=
public :: w2p_write_lhef_event
<<HEP common: procedures>>=
subroutine w2p_write_lhef_event (unit)
integer, intent(in) :: unit
type(xml_tag_t), allocatable :: tag_lhef, tag_head, tag_init, &
tag_event, tag_gen_n, tag_gen_v
if (debug_on) call msg_debug (D_EVENTS, "w2p_write_lhef_event")
allocate (tag_lhef, tag_head, tag_init, tag_event, &
tag_gen_n, tag_gen_v)
call tag_lhef%init (var_str ("LesHouchesEvents"), &
[xml_attribute (var_str ("version"), var_str ("1.0"))], .true.)
call tag_head%init (var_str ("header"), .true.)
call tag_init%init (var_str ("init"), .true.)
call tag_event%init (var_str ("event"), .true.)
call tag_gen_n%init (var_str ("generator_name"), .true.)
call tag_gen_v%init (var_str ("generator_version"), .true.)
call tag_lhef%write (unit); write (unit, *)
call tag_head%write (unit); write (unit, *)
write (unit, "(2x)", advance = "no")
call tag_gen_n%write (var_str ("WHIZARD"), unit)
write (unit, *)
write (unit, "(2x)", advance = "no")
call tag_gen_v%write (var_str ("<<Version>>"), unit)
write (unit, *)
call tag_head%close (unit); write (unit, *)
call tag_init%write (unit); write (unit, *)
call heprup_write_lhef (unit)
call tag_init%close (unit); write (unit, *)
call tag_event%write (unit); write (unit, *)
call hepeup_write_lhef (unit)
call tag_event%close (unit); write (unit, *)
call tag_lhef%close (unit); write (unit, *)
deallocate (tag_lhef, tag_head, tag_init, tag_event, &
tag_gen_n, tag_gen_v)
end subroutine w2p_write_lhef_event
@ %def w2p_write_lhef_event
@ Extract parameters from the common block. We leave it to the caller
to specify which parameters it actually needs.
[[PDFGUP]] and [[PDFSUP]] are not extracted. [[IDWTUP=1,2]] are not
supported by \whizard, but correspond to weighted events.
<<HEP common: public>>=
public :: heprup_get_run_parameters
<<HEP common: procedures>>=
subroutine heprup_get_run_parameters &
(beam_pdg, beam_energy, n_processes, unweighted, negative_weights)
integer, dimension(2), intent(out), optional :: beam_pdg
real(default), dimension(2), intent(out), optional :: beam_energy
integer, intent(out), optional :: n_processes
logical, intent(out), optional :: unweighted
logical, intent(out), optional :: negative_weights
if (present (beam_pdg)) beam_pdg = IDBMUP
if (present (beam_energy)) beam_energy = EBMUP
if (present (n_processes)) n_processes = NPRUP
if (present (unweighted)) then
select case (abs (IDWTUP))
case (3)
unweighted = .true.
case (4)
unweighted = .false.
case (1,2) !!! not supported by WHIZARD
unweighted = .false.
case default
call msg_fatal ("HEPRUP: unsupported IDWTUP value")
end select
end if
if (present (negative_weights)) then
negative_weights = IDWTUP < 0
end if
end subroutine heprup_get_run_parameters
@ %def heprup_get_run_parameters
@ Specify PDF set info. Since we support only LHAPDF, the group entry
is zero.
<<HEP common: public>>=
public :: heprup_set_lhapdf_id
<<HEP common: procedures>>=
subroutine heprup_set_lhapdf_id (i_beam, pdf_id)
integer, intent(in) :: i_beam, pdf_id
PDFGUP(i_beam) = 0
PDFSUP(i_beam) = pdf_id
end subroutine heprup_set_lhapdf_id
@ %def heprup_set_lhapdf_id
@ Fill the characteristics for a particular process. Only the process
ID is mandatory. Note that \whizard\ computes cross sections in fb,
so we have to rescale to pb. The maximum weight is meaningless for
unweighted events.
<<HEP common: public>>=
public :: heprup_set_process_parameters
<<HEP common: procedures>>=
subroutine heprup_set_process_parameters &
(i, process_id, cross_section, error, max_weight)
integer, intent(in) :: i, process_id
real(default), intent(in), optional :: cross_section, error, max_weight
LPRUP(i) = process_id
if (present (cross_section)) then
XSECUP(i) = cross_section * pb_per_fb
else
XSECUP(i) = 0
end if
if (present (error)) then
XERRUP(i) = error * pb_per_fb
else
XERRUP(i) = 0
end if
select case (IDWTUP)
case (3); XMAXUP(i) = 1
case (4)
if (present (max_weight)) then
XMAXUP(i) = max_weight * pb_per_fb
else
XMAXUP(i) = 0
end if
end select
end subroutine heprup_set_process_parameters
@ %def heprup_set_process_parameters
@ Extract the process parameters, as far as needed.
<<HEP common: public>>=
public :: heprup_get_process_parameters
<<HEP common: procedures>>=
subroutine heprup_get_process_parameters &
(i, process_id, cross_section, error, max_weight)
integer, intent(in) :: i
integer, intent(out), optional :: process_id
real(default), intent(out), optional :: cross_section, error, max_weight
if (present (process_id)) process_id = LPRUP(i)
if (present (cross_section)) then
cross_section = XSECUP(i) / pb_per_fb
end if
if (present (error)) then
error = XERRUP(i) / pb_per_fb
end if
if (present (max_weight)) then
select case (IDWTUP)
case (3)
max_weight = 1
case (4)
max_weight = XMAXUP(i) / pb_per_fb
case (1,2) !!! not supported by WHIZARD
max_weight = 0
case default
call msg_fatal ("HEPRUP: unsupported IDWTUP value")
end select
end if
end subroutine heprup_get_process_parameters
@ %def heprup_get_process_parameters
@
\subsection{Run parameter output (verbose)}
This is a verbose output of the HEPRUP block.
<<HEP common: public>>=
public :: heprup_write_verbose
<<HEP common: procedures>>=
subroutine heprup_write_verbose (unit)
integer, intent(in), optional :: unit
integer :: u, i
u = given_output_unit (unit); if (u < 0) return
write (u, "(A)") "HEPRUP Common Block"
write (u, "(3x,A6,' = ',I9,3x,1x,I9,3x,8x,A)") "IDBMUP", IDBMUP, &
"PDG code of beams"
write (u, "(3x,A6,' = ',G12.5,1x,G12.5,8x,A)") "EBMUP ", EBMUP, &
"Energy of beams in GeV"
write (u, "(3x,A6,' = ',I9,3x,1x,I9,3x,8x,A)") "PDFGUP", PDFGUP, &
"PDF author group [-1 = undefined]"
write (u, "(3x,A6,' = ',I9,3x,1x,I9,3x,8x,A)") "PDFSUP", PDFSUP, &
"PDF set ID [-1 = undefined]"
write (u, "(3x,A6,' = ',I9,3x,1x,9x,3x,8x,A)") "IDWTUP", IDWTUP, &
"LHA code for event weight mode"
write (u, "(3x,A6,' = ',I9,3x,1x,9x,3x,8x,A)") "NPRUP ", NPRUP, &
"Number of user subprocesses"
do i = 1, NPRUP
write (u, "(1x,A,I0)") "Subprocess #", i
write (u, "(3x,A6,' = ',ES12.5,1x,12x,8x,A)") "XSECUP", XSECUP(i), &
"Cross section in pb"
write (u, "(3x,A6,' = ',ES12.5,1x,12x,8x,A)") "XERRUP", XERRUP(i), &
"Cross section error in pb"
write (u, "(3x,A6,' = ',ES12.5,1x,12x,8x,A)") "XMAXUP", XMAXUP(i), &
"Maximum event weight (cf. IDWTUP)"
write (u, "(3x,A6,' = ',I9,3x,1x,12x,8x,A)") "LPRUP ", LPRUP(i), &
"Subprocess ID"
end do
end subroutine heprup_write_verbose
@ %def heprup_write_verbose
@
\subsection{Run parameter output (other formats)}
This routine writes the initialization block according to the LHEF
standard. It uses the current contents of the HEPRUP block.
<<HEP common: public>>=
public :: heprup_write_lhef
<<HEP common: procedures>>=
subroutine heprup_write_lhef (unit)
integer, intent(in), optional :: unit
integer :: u, i
u = given_output_unit (unit); if (u < 0) return
write (u, "(2(1x,I0),2(1x,ES17.10),6(1x,I0))") &
IDBMUP, EBMUP, PDFGUP, PDFSUP, IDWTUP, NPRUP
do i = 1, NPRUP
write (u, "(3(1x,ES17.10),1x,I0)") &
XSECUP(i), XERRUP(i), XMAXUP(i), LPRUP(i)
end do
end subroutine heprup_write_lhef
@ %def heprup_write_lhef
@
This routine is a complete dummy at the moment. It uses the current
contents of the HEPRUP block. At the end, it should depend on certain
input flags for the different ASCII event formats.
<<HEP common: public>>=
public :: heprup_write_ascii
<<HEP common: procedures>>=
subroutine heprup_write_ascii (unit)
integer, intent(in), optional :: unit
integer :: u, i
u = given_output_unit (unit); if (u < 0) return
write (u, "(2(1x,I0),2(1x,ES17.10),6(1x,I0))") &
IDBMUP, EBMUP, PDFGUP, PDFSUP, IDWTUP, NPRUP
do i = 1, NPRUP
write (u, "(3(1x,ES17.10),1x,I0)") &
XSECUP(i), XERRUP(i), XMAXUP(i), LPRUP(i)
end do
end subroutine heprup_write_ascii
@ %def heprup_write_ascii
@
\subsubsection{Run parameter input (LHEF)}
In a LHEF file, the parameters are written in correct order on
separate lines, but we should not count on the precise format.
List-directed input should just work.
<<HEP common: public>>=
public :: heprup_read_lhef
<<HEP common: procedures>>=
subroutine heprup_read_lhef (u)
integer, intent(in) :: u
integer :: i
read (u, *) &
IDBMUP, EBMUP, PDFGUP, PDFSUP, IDWTUP, NPRUP
do i = 1, NPRUP
read (u, *) &
XSECUP(i), XERRUP(i), XMAXUP(i), LPRUP(i)
end do
end subroutine heprup_read_lhef
@ %def heprup_read_lhef
@
\subsection{The HEPEUP common block}
<<HEP common: common blocks>>=
common /HEPEUP/ &
NUP, IDPRUP, XWGTUP, SCALUP, AQEDUP, AQCDUP, &
IDUP, ISTUP, MOTHUP, ICOLUP, PUP, VTIMUP, SPINUP
save /HEPEUP/
@ %def HEPEUP
@
\subsubsection{Initialization}
Fill the event characteristics of the common block. The
initialization sets only the number of particles and initializes the
rest with default values. The other routine sets the optional
parameters.
<<HEP common: public>>=
public :: hepeup_init
public :: hepeup_set_event_parameters
<<HEP common: procedures>>=
subroutine hepeup_init (n_tot)
integer, intent(in) :: n_tot
NUP = n_tot
IDPRUP = 0
XWGTUP = 1
SCALUP = -1
AQEDUP = -1
AQCDUP = -1
end subroutine hepeup_init
subroutine hepeup_set_event_parameters &
(proc_id, weight, scale, alpha_qed, alpha_qcd)
integer, intent(in), optional :: proc_id
real(default), intent(in), optional :: weight, scale, alpha_qed, alpha_qcd
if (present (proc_id)) IDPRUP = proc_id
if (present (weight)) XWGTUP = weight
if (present (scale)) SCALUP = scale
if (present (alpha_qed)) AQEDUP = alpha_qed
if (present (alpha_qcd)) AQCDUP = alpha_qcd
end subroutine hepeup_set_event_parameters
@ %def hepeup_init hepeup_set_event_parameters
@ Extract event information. The caller determines the parameters.
<<HEP common: public>>=
public :: hepeup_get_event_parameters
<<HEP common: procedures>>=
subroutine hepeup_get_event_parameters &
(proc_id, weight, scale, alpha_qed, alpha_qcd)
integer, intent(out), optional :: proc_id
real(default), intent(out), optional :: weight, scale, alpha_qed, alpha_qcd
if (present (proc_id)) proc_id = IDPRUP
if (present (weight)) weight = XWGTUP
if (present (scale)) scale = SCALUP
if (present (alpha_qed)) alpha_qed = AQEDUP
if (present (alpha_qcd)) alpha_qcd = AQCDUP
end subroutine hepeup_get_event_parameters
@ %def hepeup_get_event_parameters
@
\subsubsection{Particle data}
Below we need the particle status codes which are actually defined
in the [[subevents]] module.
Set the entry for a specific particle. All parameters are set with
the exception of lifetime and spin, where default values are stored.
<<HEP common: public>>=
public :: hepeup_set_particle
<<HEP common: procedures>>=
subroutine hepeup_set_particle (i, pdg, status, parent, col, p, m2)
integer, intent(in) :: i
integer, intent(in) :: pdg, status
integer, dimension(:), intent(in) :: parent
type(vector4_t), intent(in) :: p
integer, dimension(2), intent(in) :: col
real(default), intent(in) :: m2
if (i > MAXNUP) then
call msg_error (arr=[ &
var_str ("Too many particles in HEPEUP common block. " // &
"If this happened "), &
var_str ("during event output, your events will be " // &
"invalid; please consider "), &
var_str ("switching to a modern event format like HEPMC. " // &
"If you are not "), &
var_str ("using an old, HEPEUP based format and " // &
"nevertheless get this error,"), &
var_str ("please notify the WHIZARD developers,") ])
return
end if
IDUP(i) = pdg
select case (status)
case (PRT_BEAM); ISTUP(i) = -9
case (PRT_INCOMING); ISTUP(i) = -1
case (PRT_BEAM_REMNANT); ISTUP(i) = 3
case (PRT_OUTGOING); ISTUP(i) = 1
case (PRT_RESONANT); ISTUP(i) = 2
case (PRT_VIRTUAL); ISTUP(i) = 3
case default; ISTUP(i) = 0
end select
select case (size (parent))
case (0); MOTHUP(:,i) = 0
case (1); MOTHUP(1,i) = parent(1); MOTHUP(2,i) = 0
case default; MOTHUP(:,i) = [ parent(1), parent(size (parent)) ]
end select
if (col(1) > 0) then
ICOLUP(1,i) = 500 + col(1)
else
ICOLUP(1,i) = 0
end if
if (col(2) > 0) then
ICOLUP(2,i) = 500 + col(2)
else
ICOLUP(2,i) = 0
end if
PUP(1:3,i) = refmt_tiny (vector3_get_components (space_part (p)))
PUP(4,i) = refmt_tiny (energy (p))
PUP(5,i) = refmt_tiny (sign (sqrt (abs (m2)), m2))
VTIMUP(i) = 0
SPINUP(i) = 9
end subroutine hepeup_set_particle
@ %def hepeup_set_particle
@ Set the lifetime, actually $c\tau$ measured im mm, where $\tau$ is
the invariant lifetime.
<<HEP common: public>>=
public :: hepeup_set_particle_lifetime
<<HEP common: procedures>>=
subroutine hepeup_set_particle_lifetime (i, lifetime)
integer, intent(in) :: i
real(default), intent(in) :: lifetime
VTIMUP(i) = lifetime
end subroutine hepeup_set_particle_lifetime
@ %def hepeup_set_particle_lifetime
@ Set the particle spin entry. We need the cosine of the angle of the
spin axis with respect to the three-momentum of the parent particle.
If the particle has a full polarization density matrix given, we need
the particle momentum and polarization as well as the mother-particle
momentum. The polarization is transformed into a spin vector (which
is sensible only for spin-1/2 or massless particles), which then is
transformed into the lab frame (by a rotation of the 3-axis to the
particle momentum axis). Finally, we compute the scalar product of
this vector with the mother-particle three-momentum.
This puts severe restrictions on the applicability of this definition,
and Lorentz invariance is lost. Unfortunately, the Les Houches Accord
requires this computation.
<<HEP common: public>>=
public :: hepeup_set_particle_spin
<<HEP common: interfaces>>=
interface hepeup_set_particle_spin
module procedure hepeup_set_particle_spin_pol
end interface
<<HEP common: procedures>>=
subroutine hepeup_set_particle_spin_pol (i, p, pol, p_mother)
integer, intent(in) :: i
type(vector4_t), intent(in) :: p
type(polarization_t), intent(in) :: pol
type(vector4_t), intent(in) :: p_mother
type(vector3_t) :: s3, p3
type(vector4_t) :: s4
s3 = vector3_moving (pol%get_axis ())
p3 = space_part (p)
s4 = rotation_to_2nd (3, p3) * vector4_moving (0._default, s3)
SPINUP(i) = enclosed_angle_ct (s4, p_mother)
end subroutine hepeup_set_particle_spin_pol
@ %def hepeup_set_particle_spin
@
Extract particle data. The caller decides which ones to retrieve.
Status codes: beam remnants share the status code with virtual particles.
However, for the purpose of WHIZARD we should identify them. We
use the PDG code for this.
<<HEP common: public>>=
public :: hepeup_get_particle
<<HEP common: procedures>>=
subroutine hepeup_get_particle (i, pdg, status, parent, col, p, m2)
integer, intent(in) :: i
integer, intent(out), optional :: pdg, status
integer, dimension(:), intent(out), optional :: parent
type(vector4_t), intent(out), optional :: p
integer, dimension(2), intent(out), optional :: col
real(default), dimension(5,MAXNUP) :: pup_def
real(default), intent(out), optional :: m2
if (present (pdg)) pdg = IDUP(i)
if (present (status)) then
select case (ISTUP(i))
case (-9); status = PRT_BEAM
case (-1); status = PRT_INCOMING
case (1); status = PRT_OUTGOING
case (2); status = PRT_RESONANT
case (3);
select case (abs (IDUP(i)))
case (HADRON_REMNANT, HADRON_REMNANT_SINGLET, &
HADRON_REMNANT_TRIPLET, HADRON_REMNANT_OCTET)
status = PRT_BEAM_REMNANT
case default
status = PRT_VIRTUAL
end select
case default
status = PRT_UNDEFINED
end select
end if
if (present (parent)) then
select case (size (parent))
case (0)
case (1); parent(1) = MOTHUP(1,i)
case (2); parent = MOTHUP(:,i)
end select
end if
if (present (col)) then
col = ICOLUP(:,i)
end if
if (present (p)) then
pup_def = PUP
p = vector4_moving (pup_def(4,i), vector3_moving (pup_def(1:3,i)))
end if
if (present (m2)) then
m2 = sign (PUP(5,i) ** 2, PUP(5,i))
end if
end subroutine hepeup_get_particle
@ %def hepeup_get_particle
@
\subsection{The HEPEVT and HEPEV4 common block}
For the LEP Monte Carlos, a standard common block has been proposed
in AKV89. We strongly recommend its use. (The description is an
abbreviated transcription of AKV89, Vol. 3, pp. 327-330).
[[NMXHEP]] is the maximum number of entries:
<<HEP common: variables>>=
integer, parameter :: NMXHEP = 4000
@ %def NMXHEP
@ [[NEVHEP]] is normally the event number, but may take special
values as follows:
0 the program does not keep track of event numbers.
-1 a special initialization record.
-2 a special final record.
<<HEP common: variables>>=
integer :: NEVHEP
@ %def NEVHEP
@ [[NHEP]] holds the number of entries for this event.
<<HEP common: variables>>=
integer, public :: NHEP
@ %def NHEP
@ The entry [[ISTHEP(N)]] gives the status code for the [[N]]th entry,
with the following semantics:
0 a null entry.
1 an existing entry, which has not decayed or fragmented.
2 a decayed or fragmented entry, which is retained for
event history information.
3 documentation line.
4- 10 reserved for future standards.
11-200 at the disposal of each model builder.
201- at the disposal of users.
<<HEP common: variables>>=
integer, dimension(NMXHEP), public :: ISTHEP
@ %def ISTHEP
@
The Particle Data Group has proposed standard particle codes,
which are to be stored in [[IDHEP(N)]].
<<HEP common: variables>>=
integer, dimension(NMXHEP), public :: IDHEP
@ %def IDHEP
@ [[JMOHEP(1,N)]] points to the mother of the [[N]]th entry, if any.
It is set to zero for initial entries.
[[JMOHEP(2,N)]] points to the second mother, if any.
<<HEP common: variables>>=
integer, dimension(2, NMXHEP), public :: JMOHEP
@ %def JMOHEP
@ [[JDAHEP(1,N)]] and [[JDAHEP(2,N)]] point to the first and last daughter
of the [[N]]th entry, if any. These are zero for entries which have not
yet decayed. The other daughters are stored in between these two.
<<HEP common: variables>>=
integer, dimension(2, NMXHEP), public :: JDAHEP
@ %def JDAHEP
@ In [[PHEP]] we store the momentum of the particle, more specifically
this means that [[PHEP(1,N)]], [[PHEP(2,N)]], and [[PHEP(3,N)]] contain the
momentum in the $x$, $y$, and $z$ direction (as defined by the machine
people), measured in GeV/c. [[PHEP(4,N)]] contains the energy in GeV
and [[PHEP(5,N)]] the mass in GeV$/c^2$. The latter may be negative for
spacelike partons.
<<HEP common: variables>>=
double precision, dimension(5, NMXHEP), public :: PHEP
@ %def PHEP
@ Finally [[VHEP]] is the place to store the position of the production
vertex. [[VHEP(1,N)]], [[VHEP(2,N)]], and [[VHEP(3,N)]] contain the $x$, $y$,
and $z$ coordinate (as defined by the machine people), measured in mm.
[[VHEP(4,N)]] contains the production time in mm/c.
<<HEP common: variables>>=
double precision, dimension(4, NMXHEP) :: VHEP
@ %def VHEP
@ As an amendment to the proposed standard common block HEPEVT, we
also have a polarisation common block HEPSPN, as described in
AKV89. [[SHEP(1,N)]], [[SHEP(2,N)]], and [[SHEP(3,N)]] give the $x$, $y$, and $z$
component of the spinvector $s$ of a fermion in the fermions restframe.
Furthermore, we add the polarization of the corresponding outgoing
particles:
<<HEP common: variables>>=
integer, dimension(NMXHEP) :: hepevt_pol
@ %def hepevt_pol
@
By this variable the identity of the current process is given, defined
via the LPRUP codes.
<<HEP common: variables>>=
integer, public :: idruplh
@ %def idruplh
This is the event weight, i.e. the cross section divided by the total
number of generated events for the output of the parton shower programs.
<<HEP common: variables>>=
double precision, public :: eventweightlh
@ %def eventweightlh
@ There are the values for the electromagnetic and the strong coupling
constants, $\alpha_{em}$ and $\alpha_s$.
<<HEP common: variables>>=
double precision, public :: alphaqedlh, alphaqcdlh
@ %def alphaqedlh, alphaqcdlh
@ This is the squared scale $Q$ of the event.
<<HEP common: variables>>=
double precision, dimension(10), public :: scalelh
@ %def scalelh
@ Finally, these variables contain the spin information and the
color/anticolor flow of the particles.
<<HEP common: variables>>=
double precision, dimension (3,NMXHEP), public :: spinlh
integer, dimension (2,NMXHEP), public :: icolorflowlh
@ %def spinlh icolorflowlh
By convention, [[SHEP(4,N)]] is always 1. All this is taken from StdHep
4.06 manual and written using Fortran90 conventions.
<<HEP common: common blocks>>=
common /HEPEVT/ &
NEVHEP, NHEP, ISTHEP, IDHEP, &
JMOHEP, JDAHEP, PHEP, VHEP
save /HEPEVT/
@ %def HEPEVT
@ Here we store HEPEVT parameters of the WHIZARD 1 realization which
are not part of the HEPEVT common block.
<<HEP common: variables>>=
integer :: hepevt_n_out, hepevt_n_remnants
@ %def hepevt_n_out, hepevt_n_remnants
@
<<HEP common: variables>>=
double precision :: hepevt_weight, hepevt_function_value
double precision :: hepevt_function_ratio
@ %def hepevt_weight hepevt_function_value
@ The HEPEV4 common block is an extension of the HEPEVT common block
to allow for partonic colored events, including especially the color
flow etc.
<<HEP common: common blocks>>=
common /HEPEV4/ &
eventweightlh, alphaqedlh, alphaqcdlh, scalelh, &
spinlh, icolorflowlh, idruplh
save /HEPEV4/
@ %def HEPEV4
@ Filling HEPEVT: If the event count is not provided, set [[NEVHEP]]
to zero. If the event count is [[-1]] or [[-2]], the record
corresponds to initialization and finalization, and the event is
irrelevant.
Note that the event count may be larger than $2^{31}$ (2 GEvents). In
that case, cut off the upper bits since [[NEVHEP]] is probably limited
to default integer.
For the HEPEV4 common block, it is unclear why the [[scalelh]] variable
is 10-dimensional. We choose to only set the first value of the array.
<<HEP common: public>>=
public :: hepevt_init
public :: hepevt_set_event_parameters
<<HEP common: procedures>>=
subroutine hepevt_init (n_tot, n_out)
integer, intent(in) :: n_tot, n_out
NHEP = n_tot
NEVHEP = 0
idruplh = 0
hepevt_n_out = n_out
hepevt_n_remnants = 0
hepevt_weight = 1
eventweightlh = 1
hepevt_function_value = 0
hepevt_function_ratio = 1
alphaqcdlh = -1
alphaqedlh = -1
scalelh = -1
end subroutine hepevt_init
subroutine hepevt_set_event_parameters &
(proc_id, weight, function_value, function_ratio, &
alpha_qcd, alpha_qed, scale, i_evt)
integer, intent(in), optional :: proc_id
integer, intent(in), optional :: i_evt
real(default), intent(in), optional :: weight, function_value, &
function_ratio, alpha_qcd, alpha_qed, scale
if (present (proc_id)) idruplh = proc_id
if (present (i_evt)) NEVHEP = i_evt
if (present (weight)) then
hepevt_weight = weight
eventweightlh = weight
end if
if (present (function_value)) hepevt_function_value = &
function_value
if (present (function_ratio)) hepevt_function_ratio = &
function_ratio
if (present (alpha_qcd)) alphaqcdlh = alpha_qcd
if (present (alpha_qed)) alphaqedlh = alpha_qed
if (present (scale)) scalelh(1) = scale
if (present (i_evt)) NEVHEP = i_evt
end subroutine hepevt_set_event_parameters
@ %def hepevt_init hepevt_set_event_parameters
@ Set the entry for a specific particle. All parameters are set with
the exception of lifetime and spin, where default values are stored.
<<HEP common: public>>=
public :: hepevt_set_particle
<<HEP common: procedures>>=
subroutine hepevt_set_particle &
(i, pdg, status, parent, child, p, m2, hel, vtx, &
col, pol_status, pol, fill_hepev4)
integer, intent(in) :: i
integer, intent(in) :: pdg, status
integer, dimension(:), intent(in) :: parent
integer, dimension(:), intent(in) :: child
logical, intent(in), optional :: fill_hepev4
type(vector4_t), intent(in) :: p
real(default), intent(in) :: m2
integer, dimension(2), intent(in) :: col
integer, intent(in) :: pol_status
integer, intent(in) :: hel
type(polarization_t), intent(in), optional :: pol
type(vector4_t), intent(in) :: vtx
logical :: hepev4
hepev4 = .false.; if (present (fill_hepev4)) hepev4 = fill_hepev4
IDHEP(i) = pdg
select case (status)
case (PRT_BEAM); ISTHEP(i) = 2
case (PRT_INCOMING); ISTHEP(i) = 2
case (PRT_OUTGOING); ISTHEP(i) = 1
case (PRT_VIRTUAL); ISTHEP(i) = 2
case (PRT_RESONANT); ISTHEP(i) = 2
case default; ISTHEP(i) = 0
end select
select case (size (parent))
case (0); JMOHEP(:,i) = 0
case (1); JMOHEP(1,i) = parent(1); JMOHEP(2,i) = 0
case default; JMOHEP(:,i) = [ parent(1), parent(size (parent)) ]
end select
select case (size (child))
case (0); JDAHEP(:,i) = 0
case (1); JDAHEP(:,i) = child(1)
case default; JDAHEP(:,i) = [ child(1), child(size (child)) ]
end select
PHEP(1:3,i) = refmt_tiny (vector3_get_components (space_part (p)))
PHEP(4,i) = refmt_tiny (energy (p))
PHEP(5,i) = refmt_tiny (sign (sqrt (abs (m2)), m2))
VHEP(1:3,i) = vtx%p(1:3)
VHEP(4,i) = vtx%p(0)
hepevt_pol(i) = hel
if (hepev4) then
if (col(1) > 0) then
icolorflowlh(1,i) = 500 + col(1)
else
icolorflowlh(1,i) = 0
end if
if (col(2) > 0) then
icolorflowlh(2,i) = 500 + col(2)
else
icolorflowlh(2,i) = 0
end if
if (present (pol) .and. &
pol_status == PRT_GENERIC_POLARIZATION) then
if (pol%is_polarized ()) &
spinlh(:,i) = pol%get_axis ()
else
spinlh(:,i) = zero
spinlh(3,i) = hel
end if
end if
end subroutine hepevt_set_particle
@ %def hepevt_set_particle
@
\subsection{Event output}
This is a verbose output of the HEPEVT block.
<<HEP common: public>>=
public :: hepevt_write_verbose
<<HEP common: procedures>>=
subroutine hepevt_write_verbose (unit)
integer, intent(in), optional :: unit
integer :: u, i
u = given_output_unit (unit); if (u < 0) return
write (u, "(A)") "HEPEVT Common Block"
write (u, "(3x,A6,' = ',I9,3x,1x,20x,A)") "NEVHEP", NEVHEP, &
"Event number"
write (u, "(3x,A6,' = ',I9,3x,1x,20x,A)") "NHEP ", NHEP, &
"Number of particles in event"
do i = 1, NHEP
write (u, "(1x,A,I0)") "Particle #", i
write (u, "(3x,A6,' = ',I9,3x,1x,20x,A)", advance="no") &
"ISTHEP", ISTHEP(i), "Status code: "
select case (ISTHEP(i))
case ( 0); write (u, "(A)") "null entry"
case ( 1); write (u, "(A)") "outgoing"
case ( 2); write (u, "(A)") "decayed"
case ( 3); write (u, "(A)") "documentation"
case (4:10); write (u, "(A)") "[unspecified]"
case (11:200); write (u, "(A)") "[model-specific]"
case (201:); write (u, "(A)") "[user-defined]"
case default; write (u, "(A)") "[undefined]"
end select
write (u, "(3x,A6,' = ',I9,3x,1x,20x,A)") "IDHEP ", IDHEP(i), &
"PDG code of particle"
write (u, "(3x,A6,' = ',I9,3x,1x,I9,3x,8x,A)") "JMOHEP", JMOHEP(:,i), &
"Index of first/second mother"
write (u, "(3x,A6,' = ',I9,3x,1x,I9,3x,8x,A)") "JDAHEP", JDAHEP(:,i), &
"Index of first/last daughter"
write (u, "(3x,A6,' = ',ES12.5,1x,ES12.5,8x,A)") "PHEP12", &
PHEP(1:2,i), "Transversal momentum (x/y) in GeV"
write (u, "(3x,A6,' = ',ES12.5,1x,12x,8x,A)") "PHEP3 ", PHEP(3,i), &
"Longitudinal momentum (z) in GeV"
write (u, "(3x,A6,' = ',ES12.5,1x,12x,8x,A)") "PHEP4 ", PHEP(4,i), &
"Energy in GeV"
write (u, "(3x,A6,' = ',ES12.5,1x,12x,8x,A)") "PHEP5 ", PHEP(5,i), &
"Invariant mass in GeV"
write (u, "(3x,A6,' = ',ES12.5,1x,ES12.5,8x,A)") "VHEP12", VHEP(1:2,i), &
"Transversal displacement (xy) in mm"
write (u, "(3x,A6,' = ',ES12.5,1x,12x,8x,A)") "VHEP3 ", VHEP(3,i), &
"Longitudinal displacement (z) in mm"
write (u, "(3x,A6,' = ',ES12.5,1x,12x,8x,A)") "VHEP4 ", VHEP(4,i), &
"Production time in mm"
end do
end subroutine hepevt_write_verbose
@ %def hepevt_write_verbose
@
This is a verbose output of the HEPEUP block.
<<HEP common: public>>=
public :: hepeup_write_verbose
<<HEP common: procedures>>=
subroutine hepeup_write_verbose (unit)
integer, intent(in), optional :: unit
integer :: u, i
u = given_output_unit (unit); if (u < 0) return
write (u, "(A)") "HEPEUP Common Block"
write (u, "(3x,A6,' = ',I9,3x,1x,20x,A)") "NUP ", NUP, &
"Number of particles in event"
write (u, "(3x,A6,' = ',I9,3x,1x,20x,A)") "IDPRUP", IDPRUP, &
"Subprocess ID"
write (u, "(3x,A6,' = ',ES12.5,1x,20x,A)") "XWGTUP", XWGTUP, &
"Event weight"
write (u, "(3x,A6,' = ',ES12.5,1x,20x,A)") "SCALUP", SCALUP, &
"Event energy scale in GeV"
write (u, "(3x,A6,' = ',ES12.5,1x,20x,A)") "AQEDUP", AQEDUP, &
"QED coupling [-1 = undefined]"
write (u, "(3x,A6,' = ',ES12.5,1x,20x,A)") "AQCDUP", AQCDUP, &
"QCD coupling [-1 = undefined]"
do i = 1, NUP
write (u, "(1x,A,I0)") "Particle #", i
write (u, "(3x,A6,' = ',I9,3x,1x,20x,A)") "IDUP ", IDUP(i), &
"PDG code of particle"
write (u, "(3x,A6,' = ',I9,3x,1x,20x,A)", advance="no") &
"ISTUP ", ISTUP(i), "Status code: "
select case (ISTUP(i))
case (-1); write (u, "(A)") "incoming"
case ( 1); write (u, "(A)") "outgoing"
case (-2); write (u, "(A)") "spacelike"
case ( 2); write (u, "(A)") "resonance"
case ( 3); write (u, "(A)") "resonance (doc)"
case (-9); write (u, "(A)") "beam"
case default; write (u, "(A)") "[undefined]"
end select
write (u, "(3x,A6,' = ',I9,3x,1x,I9,3x,8x,A)") "MOTHUP", MOTHUP(:,i), &
"Index of first/last mother"
write (u, "(3x,A6,' = ',I9,3x,1x,I9,3x,8x,A)") "ICOLUP", ICOLUP(:,i), &
"Color/anticolor flow index"
write (u, "(3x,A6,' = ',ES12.5,1x,ES12.5,8x,A)") "PUP1/2", PUP(1:2,i), &
"Transversal momentum (x/y) in GeV"
write (u, "(3x,A6,' = ',ES12.5,1x,12x,8x,A)") "PUP3 ", PUP(3,i), &
"Longitudinal momentum (z) in GeV"
write (u, "(3x,A6,' = ',ES12.5,1x,12x,8x,A)") "PUP4 ", PUP(4,i), &
"Energy in GeV"
write (u, "(3x,A6,' = ',ES12.5,1x,12x,8x,A)") "PUP5 ", PUP(5,i), &
"Invariant mass in GeV"
write (u, "(3x,A6,' = ',ES12.5,1x,12x,8x,A)") "VTIMUP", VTIMUP(i), &
"Invariant lifetime in mm"
write (u, "(3x,A6,' = ',ES12.5,1x,12x,8x,A)") "SPINUP", SPINUP(i), &
"cos(spin angle) [9 = undefined]"
end do
end subroutine hepeup_write_verbose
@ %def hepeup_write_verbose
@
\subsection{Event output in various formats}
This routine writes event output according to the LHEF standard. It
uses the current contents of the HEPEUP block.
<<HEP common: public>>=
public :: hepeup_write_lhef
public :: hepeup_write_lha
<<HEP common: procedures>>=
subroutine hepeup_write_lhef (unit)
integer, intent(in), optional :: unit
integer :: u, i
u = given_output_unit (unit); if (u < 0) return
if (debug_on) call msg_debug (D_EVENTS, "hepeup_write_lhef")
if (debug_on) call msg_debug2 (D_EVENTS, "ID IST MOTH ICOL P VTIM SPIN")
write (u, "(2(1x,I0),4(1x,ES17.10))") &
NUP, IDPRUP, XWGTUP, SCALUP, AQEDUP, AQCDUP
do i = 1, NUP
write (u, "(6(1x,I0),7(1x,ES17.10))") &
IDUP(i), ISTUP(i), MOTHUP(:,i), ICOLUP(:,i), &
PUP(:,i), VTIMUP(i), SPINUP(i)
if (debug2_active (D_EVENTS)) then
write (msg_buffer, "(6(1x,I0),7(1x,ES17.10))") &
IDUP(i), ISTUP(i), MOTHUP(:,i), ICOLUP(:,i), &
PUP(:,i), VTIMUP(i), SPINUP(i)
call msg_message ()
end if
end do
end subroutine hepeup_write_lhef
subroutine hepeup_write_lha (unit)
integer, intent(in), optional :: unit
integer :: u, i
integer, dimension(MAXNUP) :: spin_up
spin_up = int(SPINUP)
u = given_output_unit (unit); if (u < 0) return
write (u, "(2(1x,I5),1x,ES17.10,3(1x,ES13.6))") &
NUP, IDPRUP, XWGTUP, SCALUP, AQEDUP, AQCDUP
write (u, "(500(1x,I5))") IDUP(:NUP)
write (u, "(500(1x,I5))") MOTHUP(1,:NUP)
write (u, "(500(1x,I5))") MOTHUP(2,:NUP)
write (u, "(500(1x,I5))") ICOLUP(1,:NUP)
write (u, "(500(1x,I5))") ICOLUP(2,:NUP)
write (u, "(500(1x,I5))") ISTUP(:NUP)
write (u, "(500(1x,I5))") spin_up(:NUP)
do i = 1, NUP
write (u, "(1x,I5,4(1x,ES17.10))") i, PUP([ 4,1,2,3 ], i)
end do
end subroutine hepeup_write_lha
@ %def hepeup_write_lhef hepeup_write_lha
@ This routine writes event output according to the HEPEVT standard. It
uses the current contents of the HEPEVT block and some additional
parameters according to the standard in WHIZARD 1. For the long ASCII
format, the value of the sample function (i.e. the product of squared
matrix element, structure functions and phase space factor is printed out).
The option of reweighting matrix elements with respect to some
reference cross section is not implemented in WHIZARD 2 for this event
format, therefore the second entry in the long ASCII format (the
function ratio) is always one. The ATHENA format is an implementation
of the HEPEVT format that is readable by the ATLAS ATHENA software
framework. It is very similar to the WHIZARD 1 HEPEVT format, except
that it contains an event counter, a particle counter inside the
event, and has the HEPEVT [[ISTHEP]] status before the PDG code. The
MOKKA format is a special ASCII format that contains the information
to be parsed to the MOKKA LC fast simulation software.
<<HEP common: public>>=
public :: hepevt_write_hepevt
public :: hepevt_write_ascii
public :: hepevt_write_athena
public :: hepevt_write_mokka
<<HEP common: procedures>>=
subroutine hepevt_write_hepevt (unit)
integer, intent(in), optional :: unit
integer :: u, i
u = given_output_unit (unit); if (u < 0) return
write (u, "(3(1x,I0),(1x,ES17.10))") &
NHEP, hepevt_n_out, hepevt_n_remnants, hepevt_weight
do i = 1, NHEP
write (u, "(7(1x,I0))") &
ISTHEP(i), IDHEP(i), JMOHEP(:,i), JDAHEP(:,i), hepevt_pol(i)
write (u, "(5(1x,ES17.10))") PHEP(:,i)
write (u, "(5(1x,ES17.10))") VHEP(:,i), 0.d0
end do
end subroutine hepevt_write_hepevt
subroutine hepevt_write_ascii (unit, long)
integer, intent(in), optional :: unit
logical, intent(in) :: long
integer :: u, i
u = given_output_unit (unit); if (u < 0) return
write (u, "(3(1x,I0),(1x,ES17.10))") &
NHEP, hepevt_n_out, hepevt_n_remnants, hepevt_weight
do i = 1, NHEP
if (ISTHEP(i) /= 1) cycle
write (u, "(2(1x,I0))") IDHEP(i), hepevt_pol(i)
write (u, "(5(1x,ES17.10))") PHEP(:,i)
end do
if (long) then
write (u, "(2(1x,ES17.10))") &
hepevt_function_value, hepevt_function_ratio
end if
end subroutine hepevt_write_ascii
subroutine hepevt_write_athena (unit)
integer, intent(in), optional :: unit
integer :: u, i, num_event
num_event = 0
u = given_output_unit (unit); if (u < 0) return
write (u, "(2(1x,I0))") NEVHEP, NHEP
do i = 1, NHEP
write (u, "(7(1x,I0))") &
i, ISTHEP(i), IDHEP(i), JMOHEP(:,i), JDAHEP(:,i)
write (u, "(5(1x,ES17.10))") PHEP(:,i)
write (u, "(5(1x,ES17.10))") VHEP(1:4,i)
end do
end subroutine hepevt_write_athena
subroutine hepevt_write_mokka (unit)
integer, intent(in), optional :: unit
integer :: u, i
u = given_output_unit (unit); if (u < 0) return
write (u, "(3(1x,I0),(1x,ES17.10))") &
NHEP, hepevt_n_out, hepevt_n_remnants, hepevt_weight
do i = 1, NHEP
write (u, "(4(1x,I0),4(1x,ES17.10))") &
ISTHEP(i), IDHEP(i), JDAHEP(1,i), JDAHEP(2,i), &
PHEP(1:3,i), PHEP(5,i)
end do
end subroutine hepevt_write_mokka
@ %def hepevt_write_hepevt hepevt_write_ascii
@ %def hepevt_write_athena
@
\subsection{Event input in various formats}
This routine writes event output according to the LHEF standard. It
uses the current contents of the HEPEUP block.
<<HEP common: public>>=
public :: hepeup_read_lhef
<<HEP common: procedures>>=
subroutine hepeup_read_lhef (u)
integer, intent(in) :: u
integer :: i
read (u, *) &
NUP, IDPRUP, XWGTUP, SCALUP, AQEDUP, AQCDUP
do i = 1, NUP
read (u, *) &
IDUP(i), ISTUP(i), MOTHUP(:,i), ICOLUP(:,i), &
PUP(:,i), VTIMUP(i), SPINUP(i)
end do
end subroutine hepeup_read_lhef
@ %def hepeup_read_lhef
@
\subsection{Data Transfer: particle sets}
The \whizard\ format for handling particle data in events is
[[particle_set_t]]. We have to interface this to the common blocks.
We first create a new particle set that contains only the particles
that are supported by the LHEF format. These are: beam, incoming,
resonant, outgoing. We drop particles with unknown, virtual or
beam-remnant status.
From this set we fill the common block. Event information such as
process ID and weight is not transferred here; this has to be done by
the caller. The spin information is set only if the particle has a
unique mother, and if its polarization is fully defined.
We use this routine also to hand over information to Pythia which lets
Tauola access SPINUP. Tauola expects in SPINUP the helicity and not the
LHA convention. We switch to this mode with [[tauola_convention]].
<<HEP common: public>>=
public :: hepeup_from_particle_set
<<HEP common: procedures>>=
subroutine hepeup_from_particle_set (pset_in, &
keep_beams, keep_remnants, tauola_convention)
type(particle_set_t), intent(in) :: pset_in
type(particle_set_t), target :: pset
logical, intent(in), optional :: keep_beams
logical, intent(in), optional :: keep_remnants
logical, intent(in), optional :: tauola_convention
integer :: i, n_parents, status, n_tot
integer, dimension(1) :: i_mother
logical :: kr, tc
kr = .true.; if (present (keep_remnants)) kr = keep_remnants
tc = .false.; if (present (tauola_convention)) tc = tauola_convention
call pset_in%filter_particles (pset, real_parents = .true. , &
keep_beams = keep_beams, keep_virtuals = .false.)
n_tot = pset%get_n_tot ()
call hepeup_init (n_tot)
do i = 1, n_tot
associate (prt => pset%prt(i))
status = prt%get_status ()
if (kr .and. status == PRT_BEAM_REMNANT &
.and. prt%get_n_children () == 0) &
status = PRT_OUTGOING
call hepeup_set_particle (i, &
prt%get_pdg (), &
status, &
prt%get_parents (), &
prt%get_color (), &
prt%get_momentum (), &
prt%get_p2 ())
n_parents = prt%get_n_parents ()
call hepeup_set_particle_lifetime (i, &
prt%get_lifetime ())
if (.not. tc) then
if (n_parents == 1) then
i_mother = prt%get_parents ()
select case (prt%get_polarization_status ())
case (PRT_GENERIC_POLARIZATION)
call hepeup_set_particle_spin (i, &
prt%get_momentum (), &
prt%get_polarization (), &
pset%prt(i_mother(1))%get_momentum ())
end select
end if
else
select case (prt%get_polarization_status ())
case (PRT_DEFINITE_HELICITY)
SPINUP(i) = prt%get_helicity()
end select
end if
end associate
end do
end subroutine hepeup_from_particle_set
@ %def hepeup_from_particle_set
@ Input. The particle set should be allocated properly, but we
replace the particle contents.
If there are no beam particles in the event, we try to reconstruct beam
particles and beam remnants. We assume for simplicity that the beam
particles, if any, are the first two particles. If they are absent, the first
two particles should be the incoming partons.
<<HEP common: public>>=
public :: hepeup_to_particle_set
<<HEP common: procedures>>=
subroutine hepeup_to_particle_set &
(particle_set, recover_beams, model, alt_model)
type(particle_set_t), intent(inout), target :: particle_set
logical, intent(in), optional :: recover_beams
class(model_data_t), intent(in), target :: model, alt_model
type(particle_t), dimension(:), allocatable :: prt
integer, dimension(2) :: parent
integer, dimension(:), allocatable :: child
integer :: i, j, k, pdg, status
type(flavor_t) :: flv
type(color_t) :: col
integer, dimension(2) :: c
type(vector4_t) :: p
real(default) :: p2
logical :: reconstruct
integer :: off
if (present (recover_beams)) then
reconstruct = recover_beams .and. .not. all (ISTUP(1:2) == PRT_BEAM)
else
reconstruct = .false.
end if
if (reconstruct) then
off = 4
else
off = 0
end if
allocate (prt (NUP + off), child (NUP + off))
do i = 1, NUP
k = i + off
call hepeup_get_particle (i, pdg, status, col = c, p = p, m2 = p2)
call flv%init (pdg, model, alt_model)
call prt(k)%set_flavor (flv)
call prt(k)%reset_status (status)
call col%init (c)
call prt(k)%set_color (col)
call prt(k)%set_momentum (p, p2)
where (MOTHUP(:,i) /= 0)
parent = MOTHUP(:,i) + off
elsewhere
parent = 0
end where
call prt(k)%set_parents (parent)
child = [(j, j = 1 + off, NUP + off)]
where (MOTHUP(1,:NUP) /= i .and. MOTHUP(2,:NUP) /= i) child = 0
call prt(k)%set_children (child)
end do
if (reconstruct) then
do k = 1, 2
call prt(k)%reset_status (PRT_BEAM)
call prt(k)%set_children ([k+2,k+4])
end do
do k = 3, 4
call prt(k)%reset_status (PRT_BEAM_REMNANT)
call prt(k)%set_parents ([k-2])
end do
do k = 5, 6
call prt(k)%set_parents ([k-4])
end do
end if
call particle_set%replace (prt)
end subroutine hepeup_to_particle_set
@ %def hepeup_to_particle_set
@
The HEPEVT common block is quite similar, but does contain less
information, e.g. no color flows (it was LEP time). The spin
information is set only if the particle has a unique mother, and if
its polarization is fully defined.
<<HEP common: public>>=
public :: hepevt_from_particle_set
<<HEP common: procedures>>=
subroutine hepevt_from_particle_set &
(particle_set, keep_beams, keep_remnants, ensure_order, fill_hepev4)
type(particle_set_t), intent(in) :: particle_set
type(particle_set_t), target :: pset_hepevt, pset_tmp
logical, intent(in), optional :: keep_beams
logical, intent(in), optional :: keep_remnants
logical, intent(in), optional :: ensure_order
logical, intent(in), optional :: fill_hepev4
integer :: i, status, n_tot
logical :: activate_remnants, ensure
activate_remnants = .true.
if (present (keep_remnants)) activate_remnants = keep_remnants
ensure = .false.
if (present (ensure_order)) ensure = ensure_order
call particle_set%filter_particles (pset_tmp, real_parents = .true., &
keep_virtuals = .false., keep_beams = keep_beams)
if (ensure) then
call pset_tmp%to_hepevt_form (pset_hepevt)
else
pset_hepevt = pset_tmp
end if
n_tot = pset_hepevt%get_n_tot ()
call hepevt_init (n_tot, pset_hepevt%get_n_out ())
do i = 1, n_tot
associate (prt => pset_hepevt%prt(i))
status = prt%get_status ()
if (activate_remnants &
.and. status == PRT_BEAM_REMNANT &
.and. prt%get_n_children () == 0) &
status = PRT_OUTGOING
select case (prt%get_polarization_status ())
case (PRT_GENERIC_POLARIZATION)
call hepevt_set_particle (i, &
prt%get_pdg (), status, &
prt%get_parents (), &
prt%get_children (), &
prt%get_momentum (), &
prt%get_p2 (), &
prt%get_helicity (), &
prt%get_vertex (), &
prt%get_color (), &
prt%get_polarization_status (), &
pol = prt%get_polarization (), &
fill_hepev4 = fill_hepev4)
case default
call hepevt_set_particle (i, &
prt%get_pdg (), status, &
prt%get_parents (), &
prt%get_children (), &
prt%get_momentum (), &
prt%get_p2 (), &
prt%get_helicity (), &
prt%get_vertex (), &
prt%get_color (), &
prt%get_polarization_status (), &
fill_hepev4 = fill_hepev4)
end select
end associate
end do
call pset_hepevt%final ()
end subroutine hepevt_from_particle_set
@ %def hepevt_from_particle_set
@
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{HepMC events}
This section provides the interface to the HepMC C++ library for handling
Monte-Carlo events.
Each C++ class of HepMC that we use is mirrored by a Fortran type,
which contains as its only component the C pointer to the C++ object.
Each C++ method of HepMC that we use has a C wrapper function. This
function takes a pointer to the host object as its first argument.
Further arguments are either C pointers, or in the case of simple
types (integer, real), interoperable C/Fortran objects.
The C wrapper functions have explicit interfaces in the Fortran
module. They are called by Fortran wrapper procedures. These are
treated as methods of the corresponding Fortran type.
<<[[hepmc_interface.f90]]>>=
<<File header>>
module hepmc_interface
use, intrinsic :: iso_c_binding !NODEP!
<<Use kinds>>
<<Use strings>>
use constants, only: PI
use physics_defs, only: pb_per_fb
use system_dependencies, only: HEPMC2_AVAILABLE
use system_dependencies, only: HEPMC3_AVAILABLE
use diagnostics
use lorentz
use flavors
use colors
use helicities
use polarizations
use event_handles, only: event_handle_t
<<Standard module head>>
<<HepMC interface: public>>
<<HepMC interface: types>>
<<HepMC interface: parameters>>
<<HepMC interface: interfaces>>
contains
<<HepMC interface: procedures>>
end module hepmc_interface
@ %def hepmc_interface
@
\subsection{Interface check}
This function can be called in order to verify that we are using the
actual HepMC library, and not the dummy version.
<<HepMC interface: interfaces>>=
interface
logical(c_bool) function hepmc_available () bind(C)
import
end function hepmc_available
end interface
<<HepMC interface: public>>=
public :: hepmc_is_available
<<HepMC interface: procedures>>=
function hepmc_is_available () result (flag)
logical :: flag
flag = hepmc_available ()
end function hepmc_is_available
@ %def hepmc_is_available
@
\subsection{FourVector}
The C version of four-vectors is often transferred by value, and the
associated procedures are all inlined. The wrapper needs to transfer
by reference, so we create FourVector objects on the heap which have
to be deleted explicitly. The input is a [[vector4_t]] or
[[vector3_t]] object from the [[lorentz]] module.
<<HepMC interface: public>>=
public :: hepmc_four_vector_t
<<HepMC interface: types>>=
type :: hepmc_four_vector_t
private
type(c_ptr) :: obj
end type hepmc_four_vector_t
@ %def hepmc_four_vector_t
@ In the C constructor, the zero-component (fourth argument) is
optional; if missing, it is set to zero. The Fortran version has
initializer form and takes either a three-vector or a four-vector.
A further version extracts the four-vector from a HepMC particle
object.
<<HepMC interface: interfaces>>=
interface
type(c_ptr) function new_four_vector_xyz (x, y, z) bind(C)
import
real(c_double), value :: x, y, z
end function new_four_vector_xyz
end interface
interface
type(c_ptr) function new_four_vector_xyzt (x, y, z, t) bind(C)
import
real(c_double), value :: x, y, z, t
end function new_four_vector_xyzt
end interface
@ %def new_four_vector_xyz new_four_vector_xyzt
<<HepMC interface: public>>=
public :: hepmc_four_vector_init
<<HepMC interface: interfaces>>=
interface hepmc_four_vector_init
module procedure hepmc_four_vector_init_v4
module procedure hepmc_four_vector_init_v3
module procedure hepmc_four_vector_init_hepmc_prt
end interface
<<HepMC interface: procedures>>=
subroutine hepmc_four_vector_init_v4 (pp, p)
type(hepmc_four_vector_t), intent(out) :: pp
type(vector4_t), intent(in) :: p
real(default), dimension(0:3) :: pa
pa = vector4_get_components (p)
pp%obj = new_four_vector_xyzt &
(real (pa(1), c_double), &
real (pa(2), c_double), &
real (pa(3), c_double), &
real (pa(0), c_double))
end subroutine hepmc_four_vector_init_v4
subroutine hepmc_four_vector_init_v3 (pp, p)
type(hepmc_four_vector_t), intent(out) :: pp
type(vector3_t), intent(in) :: p
real(default), dimension(3) :: pa
pa = vector3_get_components (p)
pp%obj = new_four_vector_xyz &
(real (pa(1), c_double), &
real (pa(2), c_double), &
real (pa(3), c_double))
end subroutine hepmc_four_vector_init_v3
subroutine hepmc_four_vector_init_hepmc_prt (pp, prt)
type(hepmc_four_vector_t), intent(out) :: pp
type(hepmc_particle_t), intent(in) :: prt
pp%obj = gen_particle_momentum (prt%obj)
end subroutine hepmc_four_vector_init_hepmc_prt
@ %def hepmc_four_vector_init
@ Here, the destructor is explicitly needed.
<<HepMC interface: interfaces>>=
interface
subroutine four_vector_delete (p_obj) bind(C)
import
type(c_ptr), value :: p_obj
end subroutine four_vector_delete
end interface
@ %def four_vector_delete
<<HepMC interface: public>>=
public :: hepmc_four_vector_final
<<HepMC interface: procedures>>=
subroutine hepmc_four_vector_final (p)
type(hepmc_four_vector_t), intent(inout) :: p
call four_vector_delete (p%obj)
end subroutine hepmc_four_vector_final
@ %def hepmc_four_vector_final
@ Convert to a Lorentz vector.
<<HepMC interface: interfaces>>=
interface
function four_vector_px (p_obj) result (px) bind(C)
import
real(c_double) :: px
type(c_ptr), value :: p_obj
end function four_vector_px
end interface
interface
function four_vector_py (p_obj) result (py) bind(C)
import
real(c_double) :: py
type(c_ptr), value :: p_obj
end function four_vector_py
end interface
interface
function four_vector_pz (p_obj) result (pz) bind(C)
import
real(c_double) :: pz
type(c_ptr), value :: p_obj
end function four_vector_pz
end interface
interface
function four_vector_e (p_obj) result (e) bind(C)
import
real(c_double) :: e
type(c_ptr), value :: p_obj
end function four_vector_e
end interface
@ %def four_vector_px four_vector_py four_vector_pz four_vector_e
<<HepMC interface: public>>=
public :: hepmc_four_vector_to_vector4
<<HepMC interface: procedures>>=
subroutine hepmc_four_vector_to_vector4 (pp, p)
type(hepmc_four_vector_t), intent(in) :: pp
type(vector4_t), intent(out) :: p
real(default) :: E
real(default), dimension(3) :: p3
E = four_vector_e (pp%obj)
p3(1) = four_vector_px (pp%obj)
p3(2) = four_vector_py (pp%obj)
p3(3) = four_vector_pz (pp%obj)
p = vector4_moving (E, vector3_moving (p3))
end subroutine hepmc_four_vector_to_vector4
@ %def hepmc_four_vector_to_vector4
@
\subsection{Polarization}
Polarization objects are temporarily used for assigning particle
polarization. We add a flag [[polarized]]. If this is false, the
polarization is not set and should not be transferred to
[[hepmc_particle]] objects.
<<HepMC interface: public>>=
public :: hepmc_polarization_t
<<HepMC interface: types>>=
type :: hepmc_polarization_t
private
logical :: polarized = .false.
type(c_ptr) :: obj
end type hepmc_polarization_t
@ %def hepmc_polarization_t
@ Constructor. The C wrapper takes polar and azimuthal angle as
arguments. The Fortran version allows for either a complete
polarization density matrix, or for a definite (diagonal) helicity.
\emph{HepMC does not allow to specify the degree of polarization,
therefore we have to map it to either 0 or 1. We choose 0 for
polarization less than $0.5$ and 1 for polarization greater than
$0.5$. Even this simplification works only for spin-1/2 and for
massless particles; massive vector bosons cannot be treated this
way. In particular, zero helicity is always translated as
unpolarized.}
\emph{For massive vector bosons, we arbitrarily choose the convention
that the longitudinal (zero) helicity state is mapped to the theta
angle $\pi/2$. This works under the condition that helicity is
projected onto one of the basis states.}
<<HepMC interface: interfaces>>=
interface
type(c_ptr) function new_polarization (theta, phi) bind(C)
import
real(c_double), value :: theta, phi
end function new_polarization
end interface
@ %def new_polarization
<<HepMC interface: public>>=
public :: hepmc_polarization_init
<<HepMC interface: interfaces>>=
interface hepmc_polarization_init
module procedure hepmc_polarization_init_pol
module procedure hepmc_polarization_init_hel
module procedure hepmc_polarization_init_int
end interface
<<HepMC interface: procedures>>=
subroutine hepmc_polarization_init_pol (hpol, pol)
type(hepmc_polarization_t), intent(out) :: hpol
type(polarization_t), intent(in) :: pol
real(default) :: r, theta, phi
if (pol%is_polarized ()) then
call pol%to_angles (r, theta, phi)
if (r >= 0.5) then
hpol%polarized = .true.
hpol%obj = new_polarization &
(real (theta, c_double), real (phi, c_double))
end if
end if
end subroutine hepmc_polarization_init_pol
subroutine hepmc_polarization_init_hel (hpol, hel)
type(hepmc_polarization_t), intent(out) :: hpol
type(helicity_t), intent(in) :: hel
integer, dimension(2) :: h
if (hel%is_defined ()) then
h = hel%to_pair ()
select case (h(1))
case (1:)
hpol%polarized = .true.
hpol%obj = new_polarization (0._c_double, 0._c_double)
case (:-1)
hpol%polarized = .true.
hpol%obj = new_polarization (real (pi, c_double), 0._c_double)
case (0)
hpol%polarized = .true.
hpol%obj = new_polarization (real (pi/2, c_double), 0._c_double)
end select
end if
end subroutine hepmc_polarization_init_hel
subroutine hepmc_polarization_init_int (hpol, hel)
type(hepmc_polarization_t), intent(out) :: hpol
integer, intent(in) :: hel
select case (hel)
case (1:)
hpol%polarized = .true.
hpol%obj = new_polarization (0._c_double, 0._c_double)
case (:-1)
hpol%polarized = .true.
hpol%obj = new_polarization (real (pi, c_double), 0._c_double)
case (0)
hpol%polarized = .true.
hpol%obj = new_polarization (real (pi/2, c_double), 0._c_double)
end select
end subroutine hepmc_polarization_init_int
@ %def hepmc_polarization_init
@ Destructor. The C object is deallocated only if the [[polarized]]
flag is set.
<<HepMC interface: interfaces>>=
interface
subroutine polarization_delete (pol_obj) bind(C)
import
type(c_ptr), value :: pol_obj
end subroutine polarization_delete
end interface
@ %def polarization_delete
<<HepMC interface: public>>=
public :: hepmc_polarization_final
<<HepMC interface: procedures>>=
subroutine hepmc_polarization_final (hpol)
type(hepmc_polarization_t), intent(inout) :: hpol
if (hpol%polarized) call polarization_delete (hpol%obj)
end subroutine hepmc_polarization_final
@ %def hepmc_polarization_final
@ Recover polarization from HepMC polarization object (with the
abovementioned deficiencies).
<<HepMC interface: interfaces>>=
interface
function polarization_theta (pol_obj) result (theta) bind(C)
import
real(c_double) :: theta
type(c_ptr), value :: pol_obj
end function polarization_theta
end interface
interface
function polarization_phi (pol_obj) result (phi) bind(C)
import
real(c_double) :: phi
type(c_ptr), value :: pol_obj
end function polarization_phi
end interface
@ %def polarization_theta polarization_phi
<<HepMC interface: public>>=
public :: hepmc_polarization_to_pol
<<HepMC interface: procedures>>=
subroutine hepmc_polarization_to_pol (hpol, flv, pol)
type(hepmc_polarization_t), intent(in) :: hpol
type(flavor_t), intent(in) :: flv
type(polarization_t), intent(out) :: pol
real(default) :: theta, phi
theta = polarization_theta (hpol%obj)
phi = polarization_phi (hpol%obj)
call pol%init_angles (flv, 1._default, theta, phi)
end subroutine hepmc_polarization_to_pol
@ %def hepmc_polarization_to_pol
@ Recover helicity. Here, $\phi$ is ignored and only the sign of
$\cos\theta$ is relevant, mapped to positive/negative helicity.
<<HepMC interface: public>>=
public :: hepmc_polarization_to_hel
<<HepMC interface: procedures>>=
subroutine hepmc_polarization_to_hel (hpol, flv, hel)
type(hepmc_polarization_t), intent(in) :: hpol
type(flavor_t), intent(in) :: flv
type(helicity_t), intent(out) :: hel
real(default) :: theta
integer :: hmax
theta = polarization_theta (hpol%obj)
hmax = flv%get_spin_type () / 2
call hel%init (sign (hmax, nint (cos (theta))))
end subroutine hepmc_polarization_to_hel
@ %def hepmc_polarization_to_hel
@
\subsection{GenParticle}
Particle objects have the obvious meaning.
<<HepMC interface: public>>=
public :: hepmc_particle_t
<<HepMC interface: types>>=
type :: hepmc_particle_t
private
type(c_ptr) :: obj
end type hepmc_particle_t
@ %def hepmc_particle_t
@ Constructor. The C version takes a FourVector object, which in the
Fortran wrapper is created on the fly from a [[vector4]] Lorentz
vector.
No destructor is needed as long as all particles are entered into
vertex containers.
<<HepMC interface: interfaces>>=
interface
type(c_ptr) function new_gen_particle (prt_obj, pdg_id, status) bind(C)
import
type(c_ptr), value :: prt_obj
integer(c_int), value :: pdg_id, status
end function new_gen_particle
end interface
@ %def new_gen_particle
<<HepMC interface: public>>=
public :: hepmc_particle_init
<<HepMC interface: procedures>>=
subroutine hepmc_particle_init (prt, p, pdg, status)
type(hepmc_particle_t), intent(out) :: prt
type(vector4_t), intent(in) :: p
integer, intent(in) :: pdg, status
type(hepmc_four_vector_t) :: pp
call hepmc_four_vector_init (pp, p)
prt%obj = new_gen_particle (pp%obj, int (pdg, c_int), int (status, c_int))
call hepmc_four_vector_final (pp)
end subroutine hepmc_particle_init
@ %def hepmc_particle_init
@ Set the particle color flow.
<<HepMC interface: interfaces>>=
interface
subroutine gen_particle_set_flow (prt_obj, code_index, code) bind(C)
import
type(c_ptr), value :: prt_obj
integer(c_int), value :: code_index, code
end subroutine gen_particle_set_flow
end interface
@ %def gen_particle_set_flow
@ Set the particle color. Either from a [[color_t]] object or
directly from a pair of integers.
<<HepMC interface: interfaces>>=
interface hepmc_particle_set_color
module procedure hepmc_particle_set_color_col
module procedure hepmc_particle_set_color_int
end interface hepmc_particle_set_color
<<HepMC interface: public>>=
public :: hepmc_particle_set_color
<<HepMC interface: procedures>>=
subroutine hepmc_particle_set_color_col (prt, col)
type(hepmc_particle_t), intent(inout) :: prt
type(color_t), intent(in) :: col
integer(c_int) :: c
c = col%get_col ()
if (c /= 0) call gen_particle_set_flow (prt%obj, 1_c_int, c)
c = col%get_acl ()
if (c /= 0) call gen_particle_set_flow (prt%obj, 2_c_int, c)
end subroutine hepmc_particle_set_color_col
subroutine hepmc_particle_set_color_int (prt, col)
type(hepmc_particle_t), intent(inout) :: prt
integer, dimension(2), intent(in) :: col
integer(c_int) :: c
c = col(1)
if (c /= 0) call gen_particle_set_flow (prt%obj, 1_c_int, c)
c = col(2)
if (c /= 0) call gen_particle_set_flow (prt%obj, 2_c_int, c)
end subroutine hepmc_particle_set_color_int
@ %def hepmc_particle_set_color
@ Set the particle polarization. For the restrictions on particle
polarization in HepMC, see above [[hepmc_polarization_init]].
<<HepMC interface: interfaces>>=
interface
subroutine gen_particle_set_polarization (prt_obj, pol_obj) bind(C)
import
type(c_ptr), value :: prt_obj, pol_obj
end subroutine gen_particle_set_polarization
end interface
@ %def gen_particle_set_polarization
<<HepMC interface: public>>=
public :: hepmc_particle_set_polarization
<<HepMC interface: interfaces>>=
interface hepmc_particle_set_polarization
module procedure hepmc_particle_set_polarization_pol
module procedure hepmc_particle_set_polarization_hel
module procedure hepmc_particle_set_polarization_int
end interface
<<HepMC interface: procedures>>=
subroutine hepmc_particle_set_polarization_pol (prt, pol)
type(hepmc_particle_t), intent(inout) :: prt
type(polarization_t), intent(in) :: pol
type(hepmc_polarization_t) :: hpol
call hepmc_polarization_init (hpol, pol)
if (hpol%polarized) call gen_particle_set_polarization (prt%obj, hpol%obj)
call hepmc_polarization_final (hpol)
end subroutine hepmc_particle_set_polarization_pol
subroutine hepmc_particle_set_polarization_hel (prt, hel)
type(hepmc_particle_t), intent(inout) :: prt
type(helicity_t), intent(in) :: hel
type(hepmc_polarization_t) :: hpol
call hepmc_polarization_init (hpol, hel)
if (hpol%polarized) call gen_particle_set_polarization (prt%obj, hpol%obj)
call hepmc_polarization_final (hpol)
end subroutine hepmc_particle_set_polarization_hel
subroutine hepmc_particle_set_polarization_int (prt, hel)
type(hepmc_particle_t), intent(inout) :: prt
integer, intent(in) :: hel
type(hepmc_polarization_t) :: hpol
call hepmc_polarization_init (hpol, hel)
if (hpol%polarized) call gen_particle_set_polarization (prt%obj, hpol%obj)
call hepmc_polarization_final (hpol)
end subroutine hepmc_particle_set_polarization_int
@ %def hepmc_particle_set_polarization
@ Return the HepMC barcode (unique integer ID) of the particle.
<<HepMC interface: interfaces>>=
interface
function gen_particle_barcode (prt_obj) result (barcode) bind(C)
import
integer(c_int) :: barcode
type(c_ptr), value :: prt_obj
end function gen_particle_barcode
end interface
@ %def gen_particle_barcode
<<HepMC interface: public>>=
public :: hepmc_particle_get_barcode
<<HepMC interface: procedures>>=
function hepmc_particle_get_barcode (prt) result (barcode)
integer :: barcode
type(hepmc_particle_t), intent(in) :: prt
barcode = gen_particle_barcode (prt%obj)
end function hepmc_particle_get_barcode
@ %def hepmc_particle_get_barcode
@ Return the four-vector component of the particle object as a [[vector4_t]] Lorentz vector.
<<HepMC interface: interfaces>>=
interface
type(c_ptr) function gen_particle_momentum (prt_obj) bind(C)
import
type(c_ptr), value :: prt_obj
end function gen_particle_momentum
end interface
@ %def gen_particle_momentum
<<HepMC interface: public>>=
public :: hepmc_particle_get_momentum
<<HepMC interface: procedures>>=
function hepmc_particle_get_momentum (prt) result (p)
type(vector4_t) :: p
type(hepmc_particle_t), intent(in) :: prt
type(hepmc_four_vector_t) :: pp
call hepmc_four_vector_init (pp, prt)
call hepmc_four_vector_to_vector4 (pp, p)
call hepmc_four_vector_final (pp)
end function hepmc_particle_get_momentum
@ %def hepmc_particle_get_momentum
@ Return the invariant mass squared of the particle object. HepMC
stores the signed invariant mass (no squaring).
<<HepMC interface: interfaces>>=
interface
function gen_particle_generated_mass (prt_obj) result (mass) bind(C)
import
real(c_double) :: mass
type(c_ptr), value :: prt_obj
end function gen_particle_generated_mass
end interface
@ %def gen_particle_generated_mass
<<HepMC interface: public>>=
public :: hepmc_particle_get_mass_squared
<<HepMC interface: procedures>>=
function hepmc_particle_get_mass_squared (prt) result (m2)
real(default) :: m2
type(hepmc_particle_t), intent(in) :: prt
real(default) :: m
m = gen_particle_generated_mass (prt%obj)
m2 = sign (m**2, m)
end function hepmc_particle_get_mass_squared
@ %def hepmc_particle_get_mass_squared
@ Return the PDG ID:
<<HepMC interface: interfaces>>=
interface
function gen_particle_pdg_id (prt_obj) result (pdg_id) bind(C)
import
integer(c_int) :: pdg_id
type(c_ptr), value :: prt_obj
end function gen_particle_pdg_id
end interface
@ %def gen_particle_pdg_id
<<HepMC interface: public>>=
public :: hepmc_particle_get_pdg
<<HepMC interface: procedures>>=
function hepmc_particle_get_pdg (prt) result (pdg)
integer :: pdg
type(hepmc_particle_t), intent(in) :: prt
pdg = gen_particle_pdg_id (prt%obj)
end function hepmc_particle_get_pdg
@ %def hepmc_particle_get_pdg
@ Return the status code:
<<HepMC interface: interfaces>>=
interface
function gen_particle_status (prt_obj) result (status) bind(C)
import
integer(c_int) :: status
type(c_ptr), value :: prt_obj
end function gen_particle_status
end interface
@ %def gen_particle_status
<<HepMC interface: public>>=
public :: hepmc_particle_get_status
<<HepMC interface: procedures>>=
function hepmc_particle_get_status (prt) result (status)
integer :: status
type(hepmc_particle_t), intent(in) :: prt
status = gen_particle_status (prt%obj)
end function hepmc_particle_get_status
@ %def hepmc_particle_get_status
<<HepMC interface: interfaces>>=
interface
function gen_particle_is_beam (prt_obj) result (is_beam) bind(C)
import
logical(c_bool) :: is_beam
type(c_ptr), value :: prt_obj
end function gen_particle_is_beam
end interface
@ %def gen_particle_is_beam
@ Determine whether a particle is a beam particle.
<<HepMC interface: public>>=
public :: hepmc_particle_is_beam
<<HepMC interface: procedures>>=
function hepmc_particle_is_beam (prt) result (is_beam)
logical :: is_beam
type(hepmc_particle_t), intent(in) :: prt
is_beam = gen_particle_is_beam (prt%obj)
end function hepmc_particle_is_beam
@ %def hepmc_particle_is_beam
@ Return the production/decay vertex (as a pointer, no finalization
necessary).
<<HepMC interface: interfaces>>=
interface
type(c_ptr) function gen_particle_production_vertex (prt_obj) bind(C)
import
type(c_ptr), value :: prt_obj
end function gen_particle_production_vertex
end interface
interface
type(c_ptr) function gen_particle_end_vertex (prt_obj) bind(C)
import
type(c_ptr), value :: prt_obj
end function gen_particle_end_vertex
end interface
@ %def gen_particle_production_vertex gen_particle_end_vertex
<<HepMC interface: public>>=
public :: hepmc_particle_get_production_vertex
public :: hepmc_particle_get_decay_vertex
<<HepMC interface: procedures>>=
function hepmc_particle_get_production_vertex (prt) result (v)
type(hepmc_vertex_t) :: v
type(hepmc_particle_t), intent(in) :: prt
v%obj = gen_particle_production_vertex (prt%obj)
end function hepmc_particle_get_production_vertex
function hepmc_particle_get_decay_vertex (prt) result (v)
type(hepmc_vertex_t) :: v
type(hepmc_particle_t), intent(in) :: prt
v%obj = gen_particle_end_vertex (prt%obj)
end function hepmc_particle_get_decay_vertex
@ %def hepmc_particle_get_production_vertex hepmc_particle_get_decay_vertex
@ Convenience function: Return the array of parent particles for a
given HepMC particle. The contents are HepMC barcodes that still have
to be mapped to the particle indices.
<<HepMC interface: public>>=
public :: hepmc_particle_get_parent_barcodes
public :: hepmc_particle_get_child_barcodes
<<HepMC interface: procedures>>=
function hepmc_particle_get_parent_barcodes (prt) result (parent_barcode)
type(hepmc_particle_t), intent(in) :: prt
integer, dimension(:), allocatable :: parent_barcode
type(hepmc_vertex_t) :: v
type(hepmc_vertex_particle_in_iterator_t) :: it
integer :: i
v = hepmc_particle_get_production_vertex (prt)
if (hepmc_vertex_is_valid (v)) then
allocate (parent_barcode (hepmc_vertex_get_n_in (v)))
if (size (parent_barcode) /= 0) then
if (HEPMC2_AVAILABLE) then
call hepmc_vertex_particle_in_iterator_init (it, v)
do i = 1, size (parent_barcode)
parent_barcode(i) = hepmc_particle_get_barcode &
(hepmc_vertex_particle_in_iterator_get (it))
call hepmc_vertex_particle_in_iterator_advance (it)
end do
call hepmc_vertex_particle_in_iterator_final (it)
else if (HEPMC3_AVAILABLE) then
do i = 1, size (parent_barcode)
parent_barcode(i) = hepmc_particle_get_barcode &
(hepmc_vertex_get_nth_particle_in (v, i))
end do
end if
end if
else
allocate (parent_barcode (0))
end if
end function hepmc_particle_get_parent_barcodes
function hepmc_particle_get_child_barcodes (prt) result (child_barcode)
type(hepmc_particle_t), intent(in) :: prt
integer, dimension(:), allocatable :: child_barcode
type(hepmc_vertex_t) :: v
type(hepmc_vertex_particle_out_iterator_t) :: it
integer :: i
v = hepmc_particle_get_decay_vertex (prt)
if (hepmc_vertex_is_valid (v)) then
allocate (child_barcode (hepmc_vertex_get_n_out (v)))
if (size (child_barcode) /= 0) then
if (HEPMC2_AVAILABLE) then
call hepmc_vertex_particle_out_iterator_init (it, v)
do i = 1, size (child_barcode)
child_barcode(i) = hepmc_particle_get_barcode &
(hepmc_vertex_particle_out_iterator_get (it))
call hepmc_vertex_particle_out_iterator_advance (it)
end do
call hepmc_vertex_particle_out_iterator_final (it)
else if (HEPMC3_AVAILABLE) then
do i = 1, size (child_barcode)
child_barcode(i) = hepmc_particle_get_barcode &
(hepmc_vertex_get_nth_particle_out (v, i))
end do
end if
end if
else
allocate (child_barcode (0))
end if
end function hepmc_particle_get_child_barcodes
@ %def hepmc_particle_get_parent_barcodes hepmc_particle_get_child_barcodes
@ Return the polarization (assuming that the particle is completely
polarized). Note that the generated polarization object needs finalization.
<<HepMC interface: interfaces>>=
interface
type(c_ptr) function gen_particle_polarization (prt_obj) bind(C)
import
type(c_ptr), value :: prt_obj
end function gen_particle_polarization
end interface
@ %def gen_particle_polarization
<<HepMC interface: public>>=
public :: hepmc_particle_get_polarization
<<HepMC interface: procedures>>=
function hepmc_particle_get_polarization (prt) result (pol)
type(hepmc_polarization_t) :: pol
type(hepmc_particle_t), intent(in) :: prt
pol%obj = gen_particle_polarization (prt%obj)
end function hepmc_particle_get_polarization
@ %def hepmc_particle_get_polarization
@ Return the particle color as a two-dimensional array (color, anticolor).
<<HepMC interface: interfaces>>=
interface
function gen_particle_flow (prt_obj, code_index) result (code) bind(C)
import
integer(c_int) :: code
type(c_ptr), value :: prt_obj
integer(c_int), value :: code_index
end function gen_particle_flow
end interface
@ %def gen_particle_flow
<<HepMC interface: public>>=
public :: hepmc_particle_get_color
<<HepMC interface: procedures>>=
function hepmc_particle_get_color (prt) result (col)
integer, dimension(2) :: col
type(hepmc_particle_t), intent(in) :: prt
col(1) = gen_particle_flow (prt%obj, 1)
col(2) = - gen_particle_flow (prt%obj, 2)
end function hepmc_particle_get_color
@ %def hepmc_particle_get_color
@
<<HepMC interface: interfaces>>=
interface
function gen_vertex_pos_x (v_obj) result (x) bind(C)
import
type(c_ptr), value :: v_obj
real(c_double) :: x
end function gen_vertex_pos_x
end interface
interface
function gen_vertex_pos_y (v_obj) result (y) bind(C)
import
type(c_ptr), value :: v_obj
real(c_double) :: y
end function gen_vertex_pos_y
end interface
interface
function gen_vertex_pos_z (v_obj) result (z) bind(C)
import
type(c_ptr), value :: v_obj
real(c_double) :: z
end function gen_vertex_pos_z
end interface
interface
function gen_vertex_time (v_obj) result (t) bind(C)
import
type(c_ptr), value :: v_obj
real(c_double) :: t
end function gen_vertex_time
end interface
@
<<HepMC interface: public>>=
public :: hepmc_vertex_to_vertex
<<HepMC interface: procedures>>=
function hepmc_vertex_to_vertex (vtx) result (v)
type(hepmc_vertex_t), intent(in) :: vtx
type(vector4_t) :: v
real(default) :: t, vx, vy, vz
if (hepmc_vertex_is_valid (vtx)) then
t = gen_vertex_time (vtx%obj)
vx = gen_vertex_pos_x (vtx%obj)
vy = gen_vertex_pos_y (vtx%obj)
vz = gen_vertex_pos_z (vtx%obj)
v = vector4_moving (t, &
vector3_moving ([vx, vy, vz]))
end if
end function hepmc_vertex_to_vertex
@ %def hepmc_vertex_to_vertex
@
\subsection{GenVertex}
Vertices are made of particles (incoming and outgoing).
<<HepMC interface: public>>=
public :: hepmc_vertex_t
<<HepMC interface: types>>=
type :: hepmc_vertex_t
private
type(c_ptr) :: obj
end type hepmc_vertex_t
@ %def hepmc_vertex_t
@ Constructor. Two versions, one plain, one with the position in
space and time (measured in mm) as argument. The Fortran version has
initializer form, and the vertex position is an optional argument.
A destructor is unnecessary as long as all vertices are entered into
an event container.
<<HepMC interface: interfaces>>=
interface
type(c_ptr) function new_gen_vertex () bind(C)
import
end function new_gen_vertex
end interface
interface
type(c_ptr) function new_gen_vertex_pos (prt_obj) bind(C)
import
type(c_ptr), value :: prt_obj
end function new_gen_vertex_pos
end interface
@ %def new_gen_vertex new_gen_vertex_pos
<<HepMC interface: public>>=
public :: hepmc_vertex_init
<<HepMC interface: procedures>>=
subroutine hepmc_vertex_init (v, x)
type(hepmc_vertex_t), intent(out) :: v
type(vector4_t), intent(in), optional :: x
type(hepmc_four_vector_t) :: pos
if (present (x)) then
call hepmc_four_vector_init (pos, x)
v%obj = new_gen_vertex_pos (pos%obj)
call hepmc_four_vector_final (pos)
else
v%obj = new_gen_vertex ()
end if
end subroutine hepmc_vertex_init
@ %def hepmc_vertex_init
@ Return true if the vertex pointer is non-null:
<<HepMC interface: interfaces>>=
interface
function gen_vertex_is_valid (v_obj) result (flag) bind(C)
import
logical(c_bool) :: flag
type(c_ptr), value :: v_obj
end function gen_vertex_is_valid
end interface
@ %def gen_vertex_is_valid
<<HepMC interface: public>>=
public :: hepmc_vertex_is_valid
<<HepMC interface: procedures>>=
function hepmc_vertex_is_valid (v) result (flag)
logical :: flag
type(hepmc_vertex_t), intent(in) :: v
flag = gen_vertex_is_valid (v%obj)
end function hepmc_vertex_is_valid
@ %def hepmc_vertex_is_valid
@ Add a particle to a vertex, incoming or outgoing.
<<HepMC interface: interfaces>>=
interface
subroutine gen_vertex_add_particle_in (v_obj, prt_obj) bind(C)
import
type(c_ptr), value :: v_obj, prt_obj
end subroutine gen_vertex_add_particle_in
end interface
interface
subroutine gen_vertex_add_particle_out (v_obj, prt_obj) bind(C)
import
type(c_ptr), value :: v_obj, prt_obj
end subroutine gen_vertex_add_particle_out
end interface
<<HepMC interface: public>>=
public :: hepmc_vertex_add_particle_in
public :: hepmc_vertex_add_particle_out
@ %def gen_vertex_add_particle_in gen_vertex_add_particle_out
<<HepMC interface: procedures>>=
subroutine hepmc_vertex_add_particle_in (v, prt)
type(hepmc_vertex_t), intent(inout) :: v
type(hepmc_particle_t), intent(in) :: prt
call gen_vertex_add_particle_in (v%obj, prt%obj)
end subroutine hepmc_vertex_add_particle_in
subroutine hepmc_vertex_add_particle_out (v, prt)
type(hepmc_vertex_t), intent(inout) :: v
type(hepmc_particle_t), intent(in) :: prt
call gen_vertex_add_particle_out (v%obj, prt%obj)
end subroutine hepmc_vertex_add_particle_out
@ %def hepmc_vertex_add_particle_in hepmc_vertex_add_particle_out
@ Return the number of incoming/outgoing particles.
<<HepMC interface: interfaces>>=
interface
function gen_vertex_particles_in_size (v_obj) result (size) bind(C)
import
integer(c_int) :: size
type(c_ptr), value :: v_obj
end function gen_vertex_particles_in_size
end interface
interface
function gen_vertex_particles_out_size (v_obj) result (size) bind(C)
import
integer(c_int) :: size
type(c_ptr), value :: v_obj
end function gen_vertex_particles_out_size
end interface
interface
function gen_particle_get_n_parents (p_obj) result (size) bind(C)
import
integer(c_int) :: size
type(c_ptr), value :: p_obj
end function gen_particle_get_n_parents
end interface
interface
function gen_particle_get_n_children (p_obj) result (size) bind(C)
import
integer(c_int) :: size
type(c_ptr), value :: p_obj
end function gen_particle_get_n_children
end interface
@ %def gen_vertex_particles_in_size gen_vertex_particles_out_size
@ %def gen_particle_get_n_parents get_particle_get_n_children
<<HepMC interface: public>>=
public :: hepmc_vertex_get_n_in
public :: hepmc_vertex_get_n_out
public :: hepmc_particle_get_parents
public :: hepmc_particle_get_children
<<HepMC interface: procedures>>=
function hepmc_vertex_get_n_in (v) result (n_in)
integer :: n_in
type(hepmc_vertex_t), intent(in) :: v
n_in = gen_vertex_particles_in_size (v%obj)
end function hepmc_vertex_get_n_in
function hepmc_vertex_get_n_out (v) result (n_out)
integer :: n_out
type(hepmc_vertex_t), intent(in) :: v
n_out = gen_vertex_particles_out_size (v%obj)
end function hepmc_vertex_get_n_out
function hepmc_particle_get_parents (p) result (n_p)
integer :: n_p
type(hepmc_particle_t), intent(in) :: p
n_p = gen_particle_get_n_parents (p%obj)
end function hepmc_particle_get_parents
function hepmc_particle_get_children (p) result (n_ch)
integer :: n_ch
type(hepmc_particle_t), intent(in) :: p
n_ch = gen_particle_get_n_children (p%obj)
end function hepmc_particle_get_children
@ %def hepmc_vertex_n_in hepmc_vertex_n_out
@ %def hepmc_particle_get_parents hepmc_particle_get_children
@ Return the number of parents/children.
<<HepMC interface: public>>=
public :: hepmc_particle_get_n_parents
public :: hepmc_particle_get_n_children
<<HepMC interface: procedures>>=
function hepmc_particle_get_n_parents (prt) result (n_parents)
integer :: n_parents
type(hepmc_particle_t), intent(in) :: prt
type(hepmc_vertex_t) :: v
if (HEPMC2_AVAILABLE) then
v = hepmc_particle_get_production_vertex (prt)
if (hepmc_vertex_is_valid (v)) then
n_parents = hepmc_vertex_get_n_in (v)
else
n_parents = 0
end if
else if (HEPMC3_AVAILABLE) then
n_parents = hepmc_particle_get_parents (prt)
end if
end function hepmc_particle_get_n_parents
function hepmc_particle_get_n_children (prt) result (n_children)
integer :: n_children
type(hepmc_particle_t), intent(in) :: prt
type(hepmc_vertex_t) :: v
if (HEPMC2_AVAILABLE) then
v = hepmc_particle_get_decay_vertex (prt)
if (hepmc_vertex_is_valid (v)) then
n_children = hepmc_vertex_get_n_out (v)
else
n_children = 0
end if
else if (HEPMC3_AVAILABLE) then
n_children = hepmc_particle_get_children (prt)
end if
end function hepmc_particle_get_n_children
@ %def hepmc_particle_get_n_parents
@ %def hepmc_particle_get_n_children
\subsection{Vertex-particle-in iterator}
This iterator iterates over all incoming particles in an vertex. We store a
pointer to the vertex in addition to the iterator. This allows for
simple end checking.
The iterator is actually a constant iterator; it can only read.
<<HepMC interface: public>>=
public :: hepmc_vertex_particle_in_iterator_t
<<HepMC interface: types>>=
type :: hepmc_vertex_particle_in_iterator_t
private
type(c_ptr) :: obj
type(c_ptr) :: v_obj
end type hepmc_vertex_particle_in_iterator_t
@ %def hepmc_vertex_particle_in_iterator_t
@ Constructor. The iterator is initialized at the first particle in
the vertex.
<<HepMC interface: interfaces>>=
interface
type(c_ptr) function &
new_vertex_particles_in_const_iterator (v_obj) bind(C)
import
type(c_ptr), value :: v_obj
end function new_vertex_particles_in_const_iterator
end interface
@ %def new_vertex_particles_in_const_iterator
<<HepMC interface: public>>=
public :: hepmc_vertex_particle_in_iterator_init
<<HepMC interface: procedures>>=
subroutine hepmc_vertex_particle_in_iterator_init (it, v)
type(hepmc_vertex_particle_in_iterator_t), intent(out) :: it
type(hepmc_vertex_t), intent(in) :: v
it%obj = new_vertex_particles_in_const_iterator (v%obj)
it%v_obj = v%obj
end subroutine hepmc_vertex_particle_in_iterator_init
@ %def hepmc_vertex_particle_in_iterator_init
@ Destructor. Necessary because the iterator is allocated on the
heap.
<<HepMC interface: interfaces>>=
interface
subroutine vertex_particles_in_const_iterator_delete (it_obj) bind(C)
import
type(c_ptr), value :: it_obj
end subroutine vertex_particles_in_const_iterator_delete
end interface
@ %def vertex_particles_in_const_iterator_delete
<<HepMC interface: public>>=
public :: hepmc_vertex_particle_in_iterator_final
<<HepMC interface: procedures>>=
subroutine hepmc_vertex_particle_in_iterator_final (it)
type(hepmc_vertex_particle_in_iterator_t), intent(inout) :: it
call vertex_particles_in_const_iterator_delete (it%obj)
end subroutine hepmc_vertex_particle_in_iterator_final
@ %def hepmc_vertex_particle_in_iterator_final
@ Increment
<<HepMC interface: interfaces>>=
interface
subroutine vertex_particles_in_const_iterator_advance (it_obj) bind(C)
import
type(c_ptr), value :: it_obj
end subroutine vertex_particles_in_const_iterator_advance
end interface
@ %def vertex_particles_in_const_iterator_advance
<<HepMC interface: public>>=
public :: hepmc_vertex_particle_in_iterator_advance
<<HepMC interface: procedures>>=
subroutine hepmc_vertex_particle_in_iterator_advance (it)
type(hepmc_vertex_particle_in_iterator_t), intent(inout) :: it
call vertex_particles_in_const_iterator_advance (it%obj)
end subroutine hepmc_vertex_particle_in_iterator_advance
@ %def hepmc_vertex_particle_in_iterator_advance
@ Reset to the beginning
<<HepMC interface: interfaces>>=
interface
subroutine vertex_particles_in_const_iterator_reset &
(it_obj, v_obj) bind(C)
import
type(c_ptr), value :: it_obj, v_obj
end subroutine vertex_particles_in_const_iterator_reset
end interface
@ %def vertex_particles_in_const_iterator_reset
<<HepMC interface: public>>=
public :: hepmc_vertex_particle_in_iterator_reset
<<HepMC interface: procedures>>=
subroutine hepmc_vertex_particle_in_iterator_reset (it)
type(hepmc_vertex_particle_in_iterator_t), intent(inout) :: it
call vertex_particles_in_const_iterator_reset (it%obj, it%v_obj)
end subroutine hepmc_vertex_particle_in_iterator_reset
@ %def hepmc_vertex_particle_in_iterator_reset
@ Test: return true as long as we are not past the end.
<<HepMC interface: interfaces>>=
interface
function vertex_particles_in_const_iterator_is_valid &
(it_obj, v_obj) result (flag) bind(C)
import
logical(c_bool) :: flag
type(c_ptr), value :: it_obj, v_obj
end function vertex_particles_in_const_iterator_is_valid
end interface
@ %def vertex_particles_in_const_iterator_is_valid
<<HepMC interface: public>>=
public :: hepmc_vertex_particle_in_iterator_is_valid
<<HepMC interface: procedures>>=
function hepmc_vertex_particle_in_iterator_is_valid (it) result (flag)
logical :: flag
type(hepmc_vertex_particle_in_iterator_t), intent(in) :: it
flag = vertex_particles_in_const_iterator_is_valid (it%obj, it%v_obj)
end function hepmc_vertex_particle_in_iterator_is_valid
@ %def hepmc_vertex_particle_in_iterator_is_valid
@ Return the particle pointed to by the iterator. (The particle
object should not be finalized, since it contains merely a pointer to
the particle which is owned by the vertex.)
<<HepMC interface: interfaces>>=
interface
type(c_ptr) function &
vertex_particles_in_const_iterator_get (it_obj) bind(C)
import
type(c_ptr), value :: it_obj
end function vertex_particles_in_const_iterator_get
end interface
@ %def vertex_particles_in_const_iterator_get
<<HepMC interface: public>>=
public :: hepmc_vertex_particle_in_iterator_get
<<HepMC interface: procedures>>=
function hepmc_vertex_particle_in_iterator_get (it) result (prt)
type(hepmc_particle_t) :: prt
type(hepmc_vertex_particle_in_iterator_t), intent(in) :: it
prt%obj = vertex_particles_in_const_iterator_get (it%obj)
end function hepmc_vertex_particle_in_iterator_get
@ %def hepmc_vertex_particle_in_iterator_get
@
<<HepMC interface: interfaces>>=
interface
type(c_ptr) function vertex_get_nth_particle_in (vtx_obj, n) bind(C)
import
type(c_ptr), value :: vtx_obj
integer(c_int), value :: n
end function vertex_get_nth_particle_in
end interface
interface
type(c_ptr) function vertex_get_nth_particle_out (vtx_obj, n) bind(C)
import
type(c_ptr), value :: vtx_obj
integer(c_int), value :: n
end function vertex_get_nth_particle_out
end interface
@ %def vertex_get_nth_particle_in
<<HepMC interface: public>>=
public :: hepmc_vertex_get_nth_particle_in
public :: hepmc_vertex_get_nth_particle_out
<<HepMC interface: procedures>>=
function hepmc_vertex_get_nth_particle_in (vtx, n) result (prt)
type(hepmc_particle_t) :: prt
type(hepmc_vertex_t), intent(in) :: vtx
integer, intent(in) :: n
integer(c_int) :: nth
nth = n
prt%obj = vertex_get_nth_particle_in (vtx%obj, nth)
end function hepmc_vertex_get_nth_particle_in
function hepmc_vertex_get_nth_particle_out (vtx, n) result (prt)
type(hepmc_particle_t) :: prt
type(hepmc_vertex_t), intent(in) :: vtx
integer, intent(in) :: n
integer(c_int) :: nth
nth = n
prt%obj = vertex_get_nth_particle_out (vtx%obj, nth)
end function hepmc_vertex_get_nth_particle_out
@ %def hepmc_vertex_get_nth_particle_in
@ %def hepmc_vertex_get_nth_particle_out
@
\subsection{Vertex-particle-out iterator}
This iterator iterates over all incoming particles in an vertex. We store a
pointer to the vertex in addition to the iterator. This allows for
simple end checking.
The iterator is actually a constant iterator; it can only read.
<<HepMC interface: public>>=
public :: hepmc_vertex_particle_out_iterator_t
<<HepMC interface: types>>=
type :: hepmc_vertex_particle_out_iterator_t
private
type(c_ptr) :: obj
type(c_ptr) :: v_obj
end type hepmc_vertex_particle_out_iterator_t
@ %def hepmc_vertex_particle_out_iterator_t
@ Constructor. The iterator is initialized at the first particle in
the vertex.
<<HepMC interface: interfaces>>=
interface
type(c_ptr) function &
new_vertex_particles_out_const_iterator (v_obj) bind(C)
import
type(c_ptr), value :: v_obj
end function new_vertex_particles_out_const_iterator
end interface
@ %def new_vertex_particles_out_const_iterator
<<HepMC interface: public>>=
public :: hepmc_vertex_particle_out_iterator_init
<<HepMC interface: procedures>>=
subroutine hepmc_vertex_particle_out_iterator_init (it, v)
type(hepmc_vertex_particle_out_iterator_t), intent(out) :: it
type(hepmc_vertex_t), intent(in) :: v
it%obj = new_vertex_particles_out_const_iterator (v%obj)
it%v_obj = v%obj
end subroutine hepmc_vertex_particle_out_iterator_init
@ %def hepmc_vertex_particle_out_iterator_init
@ Destructor. Necessary because the iterator is allocated on the
heap.
<<HepMC interface: interfaces>>=
interface
subroutine vertex_particles_out_const_iterator_delete (it_obj) bind(C)
import
type(c_ptr), value :: it_obj
end subroutine vertex_particles_out_const_iterator_delete
end interface
@ %def vertex_particles_out_const_iterator_delete
<<HepMC interface: public>>=
public :: hepmc_vertex_particle_out_iterator_final
<<HepMC interface: procedures>>=
subroutine hepmc_vertex_particle_out_iterator_final (it)
type(hepmc_vertex_particle_out_iterator_t), intent(inout) :: it
call vertex_particles_out_const_iterator_delete (it%obj)
end subroutine hepmc_vertex_particle_out_iterator_final
@ %def hepmc_vertex_particle_out_iterator_final
@ Increment
<<HepMC interface: interfaces>>=
interface
subroutine vertex_particles_out_const_iterator_advance (it_obj) bind(C)
import
type(c_ptr), value :: it_obj
end subroutine vertex_particles_out_const_iterator_advance
end interface
@ %def vertex_particles_out_const_iterator_advance
<<HepMC interface: public>>=
public :: hepmc_vertex_particle_out_iterator_advance
<<HepMC interface: procedures>>=
subroutine hepmc_vertex_particle_out_iterator_advance (it)
type(hepmc_vertex_particle_out_iterator_t), intent(inout) :: it
call vertex_particles_out_const_iterator_advance (it%obj)
end subroutine hepmc_vertex_particle_out_iterator_advance
@ %def hepmc_vertex_particle_out_iterator_advance
@ Reset to the beginning
<<HepMC interface: interfaces>>=
interface
subroutine vertex_particles_out_const_iterator_reset &
(it_obj, v_obj) bind(C)
import
type(c_ptr), value :: it_obj, v_obj
end subroutine vertex_particles_out_const_iterator_reset
end interface
@ %def vertex_particles_out_const_iterator_reset
<<HepMC interface: public>>=
public :: hepmc_vertex_particle_out_iterator_reset
<<HepMC interface: procedures>>=
subroutine hepmc_vertex_particle_out_iterator_reset (it)
type(hepmc_vertex_particle_out_iterator_t), intent(inout) :: it
call vertex_particles_out_const_iterator_reset (it%obj, it%v_obj)
end subroutine hepmc_vertex_particle_out_iterator_reset
@ %def hepmc_vertex_particle_out_iterator_reset
@ Test: return true as long as we are not past the end.
<<HepMC interface: interfaces>>=
interface
function vertex_particles_out_const_iterator_is_valid &
(it_obj, v_obj) result (flag) bind(C)
import
logical(c_bool) :: flag
type(c_ptr), value :: it_obj, v_obj
end function vertex_particles_out_const_iterator_is_valid
end interface
@ %def vertex_particles_out_const_iterator_is_valid
<<HepMC interface: public>>=
public :: hepmc_vertex_particle_out_iterator_is_valid
<<HepMC interface: procedures>>=
function hepmc_vertex_particle_out_iterator_is_valid (it) result (flag)
logical :: flag
type(hepmc_vertex_particle_out_iterator_t), intent(in) :: it
flag = vertex_particles_out_const_iterator_is_valid (it%obj, it%v_obj)
end function hepmc_vertex_particle_out_iterator_is_valid
@ %def hepmc_vertex_particle_out_iterator_is_valid
@ Return the particle pointed to by the iterator. (The particle
object should not be finalized, since it contains merely a pointer to
the particle which is owned by the vertex.)
<<HepMC interface: interfaces>>=
interface
type(c_ptr) function &
vertex_particles_out_const_iterator_get (it_obj) bind(C)
import
type(c_ptr), value :: it_obj
end function vertex_particles_out_const_iterator_get
end interface
@ %def vertex_particles_out_const_iterator_get
<<HepMC interface: public>>=
public :: hepmc_vertex_particle_out_iterator_get
<<HepMC interface: procedures>>=
function hepmc_vertex_particle_out_iterator_get (it) result (prt)
type(hepmc_particle_t) :: prt
type(hepmc_vertex_particle_out_iterator_t), intent(in) :: it
prt%obj = vertex_particles_out_const_iterator_get (it%obj)
end function hepmc_vertex_particle_out_iterator_get
@ %def hepmc_vertex_particle_out_iterator_get
@
\subsection{GenEvent}
The main object of HepMC is a GenEvent. The object is filled by
GenVertex objects, which in turn contain GenParticle objects.
This is an extension of the abstract [[event_handle_t]], so we can use the
according communicator features.
<<HepMC interface: public>>=
public :: hepmc_event_t
<<HepMC interface: types>>=
type, extends (event_handle_t) :: hepmc_event_t
private
type(c_ptr) :: obj = c_null_ptr
end type hepmc_event_t
@ %def hepmc_event_t
@ Constructor. Arguments are process ID (integer) and event ID
(integer).
The Fortran version has initializer form.
<<HepMC interface: interfaces>>=
interface
type(c_ptr) function new_gen_event (proc_id, event_id) bind(C)
import
integer(c_int), value :: proc_id, event_id
end function new_gen_event
end interface
@ %def new_gen_event
<<HepMC interface: public>>=
public :: hepmc_event_init
<<HepMC interface: procedures>>=
subroutine hepmc_event_init (evt, proc_id, event_id)
type(hepmc_event_t), intent(out) :: evt
integer, intent(in), optional :: proc_id, event_id
integer(c_int) :: pid, eid
pid = 0; if (present (proc_id)) pid = proc_id
eid = 0; if (present (event_id)) eid = event_id
evt%obj = new_gen_event (pid, eid)
end subroutine hepmc_event_init
@ %def hepmc_event_init
@ Destructor.
<<HepMC interface: interfaces>>=
interface
subroutine gen_event_delete (evt_obj) bind(C)
import
type(c_ptr), value :: evt_obj
end subroutine gen_event_delete
end interface
@ %def gen_event_delete
@ Finalize: use the HepMC destructor. Also nullify the pointer explicitly, to
be on the safe side.
<<HepMC interface: public>>=
public :: hepmc_event_final
<<HepMC interface: procedures>>=
subroutine hepmc_event_final (evt)
type(hepmc_event_t), intent(inout) :: evt
if (c_associated (evt%obj)) then
call gen_event_delete (evt%obj)
evt%obj = c_null_ptr
end if
end subroutine hepmc_event_final
@ %def hepmc_event_final
@ Nullify: do not call the destructor, just nullify the C pointer. There
should be another pointer associated with the object.
<<HepMC interface: public>>=
public :: hepmc_event_nullify
<<HepMC interface: procedures>>=
subroutine hepmc_event_nullify (evt)
type(hepmc_event_t), intent(inout) :: evt
evt%obj = c_null_ptr
end subroutine hepmc_event_nullify
@ %def hepmc_event_nullify
@ Return the actual object as a C pointer. For use in the native C++
interface only.
<<HepMC interface: public>>=
public :: hepmc_event_get_c_ptr
<<HepMC interface: procedures>>=
function hepmc_event_get_c_ptr (evt) result (p)
type(hepmc_event_t), intent(in) :: evt
type(c_ptr) :: p
p = evt%obj
end function hepmc_event_get_c_ptr
@ %def hepmc_event_get_c_ptr
@ Screen output. Printing to file is possible in principle (using a
C++ output channel), by allowing an argument. Printing to an open
Fortran unit is obviously not possible.
<<HepMC interface: interfaces>>=
interface
subroutine gen_event_print (evt_obj) bind(C)
import
type(c_ptr), value :: evt_obj
end subroutine gen_event_print
end interface
@ %def gen_event_print
<<HepMC interface: public>>=
public :: hepmc_event_print
<<HepMC interface: procedures>>=
subroutine hepmc_event_print (evt)
type(hepmc_event_t), intent(in) :: evt
call gen_event_print (evt%obj)
end subroutine hepmc_event_print
@ %def hepmc_event_print
@ Get the event number.
<<HepMC interface: interfaces>>=
interface
integer(c_int) function gen_event_event_number (evt_obj) bind(C)
use iso_c_binding !NODEP!
type(c_ptr), value :: evt_obj
end function gen_event_event_number
end interface
@ %def gen_event_event_number
<<HepMC interface: public>>=
public :: hepmc_event_get_event_index
<<HepMC interface: procedures>>=
function hepmc_event_get_event_index (evt) result (i_proc)
integer :: i_proc
type(hepmc_event_t), intent(in) :: evt
i_proc = gen_event_event_number (evt%obj)
end function hepmc_event_get_event_index
@ %def hepmc_event_get_event_index
<<HepMC interface: interfaces>>=
interface
integer(c_int) function gen_event_get_n_particles &
(evt_obj) bind(C)
import
type(c_ptr), value :: evt_obj
end function gen_event_get_n_particles
end interface
interface
integer(c_int) function gen_event_get_n_beams &
(evt_obj) bind(C)
import
type(c_ptr), value :: evt_obj
end function gen_event_get_n_beams
end interface
@ %def gen_event_get_n_particles gen_event_get_n_beams
<<HepMC interface: public>>=
public :: hepmc_event_get_n_particles
public :: hepmc_event_get_n_beams
<<HepMC interface: procedures>>=
function hepmc_event_get_n_particles (evt) result (n_tot)
integer :: n_tot
type(hepmc_event_t), intent(in) :: evt
n_tot = gen_event_get_n_particles (evt%obj)
end function hepmc_event_get_n_particles
function hepmc_event_get_n_beams (evt) result (n_tot)
integer :: n_tot
type(hepmc_event_t), intent(in) :: evt
n_tot = gen_event_get_n_beams (evt%obj)
end function hepmc_event_get_n_beams
@ %def hepmc_event_get_n_particles
@ %def hepmc_event_get_n_beams
@ Set the numeric signal process ID
<<HepMC interface: interfaces>>=
interface
subroutine gen_event_set_signal_process_id (evt_obj, proc_id) bind(C)
import
type(c_ptr), value :: evt_obj
integer(c_int), value :: proc_id
end subroutine gen_event_set_signal_process_id
end interface
@ %def gen_event_set_signal_process_id
<<HepMC interface: public>>=
public :: hepmc_event_set_process_id
<<HepMC interface: procedures>>=
subroutine hepmc_event_set_process_id (evt, proc)
type(hepmc_event_t), intent(in) :: evt
integer, intent(in) :: proc
integer(c_int) :: i_proc
i_proc = proc
call gen_event_set_signal_process_id (evt%obj, i_proc)
end subroutine hepmc_event_set_process_id
@ %def hepmc_event_set_process_id
@ Get the numeric signal process ID
<<HepMC interface: interfaces>>=
interface
integer(c_int) function gen_event_signal_process_id (evt_obj) bind(C)
import
type(c_ptr), value :: evt_obj
end function gen_event_signal_process_id
end interface
@ %def gen_event_signal_process_id
<<HepMC interface: public>>=
public :: hepmc_event_get_process_id
<<HepMC interface: procedures>>=
function hepmc_event_get_process_id (evt) result (i_proc)
integer :: i_proc
type(hepmc_event_t), intent(in) :: evt
i_proc = gen_event_signal_process_id (evt%obj)
end function hepmc_event_get_process_id
@ %def hepmc_event_get_process_id
@ Set the event energy scale
<<HepMC interface: interfaces>>=
interface
subroutine gen_event_set_event_scale (evt_obj, scale) bind(C)
import
type(c_ptr), value :: evt_obj
real(c_double), value :: scale
end subroutine gen_event_set_event_scale
end interface
@ %def gen_event_set_event_scale
<<HepMC interface: public>>=
public :: hepmc_event_set_scale
<<HepMC interface: procedures>>=
subroutine hepmc_event_set_scale (evt, scale)
type(hepmc_event_t), intent(in) :: evt
real(default), intent(in) :: scale
real(c_double) :: cscale
cscale = scale
call gen_event_set_event_scale (evt%obj, cscale)
end subroutine hepmc_event_set_scale
@ %def hepmc_event_set_scale
@ Get the event energy scale
<<HepMC interface: interfaces>>=
interface
real(c_double) function gen_event_event_scale (evt_obj) bind(C)
import
type(c_ptr), value :: evt_obj
end function gen_event_event_scale
end interface
@ %def gen_event_event_scale
<<HepMC interface: public>>=
public :: hepmc_event_get_scale
<<HepMC interface: procedures>>=
function hepmc_event_get_scale (evt) result (scale)
real(default) :: scale
type(hepmc_event_t), intent(in) :: evt
scale = gen_event_event_scale (evt%obj)
end function hepmc_event_get_scale
@ %def hepmc_event_set_scale
@ Set the value of $\alpha_{\rm QCD}$.
<<HepMC interface: interfaces>>=
interface
subroutine gen_event_set_alpha_qcd (evt_obj, a) bind(C)
import
type(c_ptr), value :: evt_obj
real(c_double), value :: a
end subroutine gen_event_set_alpha_qcd
end interface
@ %def gen_event_set_alpha_qcd
<<HepMC interface: public>>=
public :: hepmc_event_set_alpha_qcd
<<HepMC interface: procedures>>=
subroutine hepmc_event_set_alpha_qcd (evt, alpha)
type(hepmc_event_t), intent(in) :: evt
real(default), intent(in) :: alpha
real(c_double) :: a
a = alpha
call gen_event_set_alpha_qcd (evt%obj, a)
end subroutine hepmc_event_set_alpha_qcd
@ %def hepmc_event_set_alpha_qcd
@ Get the value of $\alpha_{\rm QCD}$.
<<HepMC interface: interfaces>>=
interface
real(c_double) function gen_event_alpha_qcd (evt_obj) bind(C)
import
type(c_ptr), value :: evt_obj
end function gen_event_alpha_qcd
end interface
@ %def gen_event_get_alpha_qcd
<<HepMC interface: public>>=
public :: hepmc_event_get_alpha_qcd
<<HepMC interface: procedures>>=
function hepmc_event_get_alpha_qcd (evt) result (alpha)
real(default) :: alpha
type(hepmc_event_t), intent(in) :: evt
alpha = gen_event_alpha_qcd (evt%obj)
end function hepmc_event_get_alpha_qcd
@ %def hepmc_event_get_alpha_qcd
@ Set the value of $\alpha_{\rm QED}$.
<<HepMC interface: interfaces>>=
interface
subroutine gen_event_set_alpha_qed (evt_obj, a) bind(C)
import
type(c_ptr), value :: evt_obj
real(c_double), value :: a
end subroutine gen_event_set_alpha_qed
end interface
@ %def gen_event_set_alpha_qed
<<HepMC interface: public>>=
public :: hepmc_event_set_alpha_qed
<<HepMC interface: procedures>>=
subroutine hepmc_event_set_alpha_qed (evt, alpha)
type(hepmc_event_t), intent(in) :: evt
real(default), intent(in) :: alpha
real(c_double) :: a
a = alpha
call gen_event_set_alpha_qed (evt%obj, a)
end subroutine hepmc_event_set_alpha_qed
@ %def hepmc_event_set_alpha_qed
@ Get the value of $\alpha_{\rm QED}$.
<<HepMC interface: interfaces>>=
interface
real(c_double) function gen_event_alpha_qed (evt_obj) bind(C)
import
type(c_ptr), value :: evt_obj
end function gen_event_alpha_qed
end interface
@ %def gen_event_get_alpha_qed
<<HepMC interface: public>>=
public :: hepmc_event_get_alpha_qed
<<HepMC interface: procedures>>=
function hepmc_event_get_alpha_qed (evt) result (alpha)
real(default) :: alpha
type(hepmc_event_t), intent(in) :: evt
alpha = gen_event_alpha_qed (evt%obj)
end function hepmc_event_get_alpha_qed
@ %def hepmc_event_get_alpha_qed
@ Clear a weight value to the end of the weight container.
<<HepMC interface: interfaces>>=
interface
subroutine gen_event_clear_weights (evt_obj) bind(C)
use iso_c_binding !NODEP!
type(c_ptr), value :: evt_obj
end subroutine gen_event_clear_weights
end interface
@ %def gen_event_set_alpha_qed
@ The HepMC weights are measured in pb.
<<HepMC interface: parameters>>=
integer, parameter, public :: HEPMC3_MODE_HEPMC2 = 1
integer, parameter, public :: HEPMC3_MODE_HEPMC3 = 2
integer, parameter, public :: HEPMC3_MODE_ROOT = 3
integer, parameter, public :: HEPMC3_MODE_ROOTTREE = 4
integer, parameter, public :: HEPMC3_MODE_HEPEVT = 5
@ %def HEPMC3_MODE_HEPMC2 HEPMC3_MODE_HEPMC3
@ %def HEPMC3_MODE_ROOT HEPMC3_MODE_ROOTTREE
@ %def HEPMC3_MODE_HEPEVT
@
<<HepMC interface: public>>=
public :: hepmc_event_clear_weights
<<HepMC interface: procedures>>=
subroutine hepmc_event_clear_weights (evt)
type(hepmc_event_t), intent(in) :: evt
call gen_event_clear_weights (evt%obj)
end subroutine hepmc_event_clear_weights
@ %def hepmc_event_clear_weights
@ Add a weight value to the end of the weight container.
<<HepMC interface: interfaces>>=
interface
subroutine gen_event_add_weight (evt_obj, w) bind(C)
use iso_c_binding !NODEP!
type(c_ptr), value :: evt_obj
real(c_double), value :: w
end subroutine gen_event_add_weight
end interface
@ %def gen_event_add_weight
@
<<HepMC interface: public>>=
public :: hepmc_event_add_weight
<<HepMC interface: procedures>>=
subroutine hepmc_event_add_weight (evt, weight, rescale)
type(hepmc_event_t), intent(in) :: evt
real(default), intent(in) :: weight
logical, intent(in) :: rescale
real(c_double) :: w
if (rescale) then
w = weight * pb_per_fb
else
w = weight
end if
call gen_event_add_weight (evt%obj, w)
end subroutine hepmc_event_add_weight
@ %def hepmc_event_add_weight
@ Get the size of the weight container (the number of valid elements).
<<HepMC interface: interfaces>>=
interface
integer(c_int) function gen_event_weights_size (evt_obj) bind(C)
use iso_c_binding !NODEP!
type(c_ptr), value :: evt_obj
end function gen_event_weights_size
end interface
@ %def gen_event_get_weight
<<HepMC interface: public>>=
public :: hepmc_event_get_weights_size
<<HepMC interface: procedures>>=
function hepmc_event_get_weights_size (evt) result (n)
integer :: n
type(hepmc_event_t), intent(in) :: evt
n = gen_event_weights_size (evt%obj)
end function hepmc_event_get_weights_size
@ %def hepmc_event_get_weights_size
@ Get the value of the weight with index [[i]]. (Count from 1, while C counts
from zero.)
<<HepMC interface: interfaces>>=
interface
real(c_double) function gen_event_weight (evt_obj, i) bind(C)
use iso_c_binding !NODEP!
type(c_ptr), value :: evt_obj
integer(c_int), value :: i
end function gen_event_weight
end interface
@ %def gen_event_get_weight
<<HepMC interface: public>>=
public :: hepmc_event_get_weight
<<HepMC interface: procedures>>=
function hepmc_event_get_weight (evt, index, rescale) result (weight)
real(default) :: weight
type(hepmc_event_t), intent(in) :: evt
integer, intent(in) :: index
logical, intent(in) :: rescale
integer(c_int) :: i
i = index - 1
if (rescale) then
weight = gen_event_weight (evt%obj, i) / pb_per_fb
else
weight = gen_event_weight (evt%obj, i)
end if
end function hepmc_event_get_weight
@ %def hepmc_event_get_weight
@ Add a vertex to the event container.
<<HepMC interface: interfaces>>=
interface
subroutine gen_event_add_vertex (evt_obj, v_obj) bind(C)
import
type(c_ptr), value :: evt_obj
type(c_ptr), value :: v_obj
end subroutine gen_event_add_vertex
end interface
@ %def gen_event_add_vertex
<<HepMC interface: public>>=
public :: hepmc_event_add_vertex
<<HepMC interface: procedures>>=
subroutine hepmc_event_add_vertex (evt, v)
type(hepmc_event_t), intent(inout) :: evt
type(hepmc_vertex_t), intent(in) :: v
call gen_event_add_vertex (evt%obj, v%obj)
end subroutine hepmc_event_add_vertex
@ %def hepmc_event_add_vertex
@ Mark a particular vertex as the signal process (hard interaction).
<<HepMC interface: interfaces>>=
interface
subroutine gen_event_set_signal_process_vertex (evt_obj, v_obj) bind(C)
import
type(c_ptr), value :: evt_obj
type(c_ptr), value :: v_obj
end subroutine gen_event_set_signal_process_vertex
end interface
@ %def gen_event_set_signal_process_vertex
<<HepMC interface: public>>=
public :: hepmc_event_set_signal_process_vertex
<<HepMC interface: procedures>>=
subroutine hepmc_event_set_signal_process_vertex (evt, v)
type(hepmc_event_t), intent(inout) :: evt
type(hepmc_vertex_t), intent(in) :: v
call gen_event_set_signal_process_vertex (evt%obj, v%obj)
end subroutine hepmc_event_set_signal_process_vertex
@ %def hepmc_event_set_signal_process_vertex
@ Return the the signal process (hard interaction).
<<HepMC interface: interfaces>>=
interface
function gen_event_get_signal_process_vertex (evt_obj) &
result (v_obj) bind(C)
import
type(c_ptr), value :: evt_obj
type(c_ptr) :: v_obj
end function gen_event_get_signal_process_vertex
end interface
@ %def gen_event_get_signal_process_vertex
<<HepMC interface: public>>=
public :: hepmc_event_get_signal_process_vertex
<<HepMC interface: procedures>>=
function hepmc_event_get_signal_process_vertex (evt) result (v)
type(hepmc_event_t), intent(in) :: evt
type(hepmc_vertex_t) :: v
v%obj = gen_event_get_signal_process_vertex (evt%obj)
end function hepmc_event_get_signal_process_vertex
@ %def hepmc_event_get_signal_process_vertex
@ Set the beam particles explicitly.
<<HepMC interface: public>>=
public :: hepmc_event_set_beam_particles
<<HepMC interface: procedures>>=
subroutine hepmc_event_set_beam_particles (evt, prt1, prt2)
type(hepmc_event_t), intent(inout) :: evt
type(hepmc_particle_t), intent(in) :: prt1, prt2
logical(c_bool) :: flag
flag = gen_event_set_beam_particles (evt%obj, prt1%obj, prt2%obj)
end subroutine hepmc_event_set_beam_particles
@ %def hepmc_event_set_beam_particles
@ The C function returns a boolean which we do not use.
<<HepMC interface: interfaces>>=
interface
logical(c_bool) function gen_event_set_beam_particles &
(evt_obj, prt1_obj, prt2_obj) bind(C)
import
type(c_ptr), value :: evt_obj, prt1_obj, prt2_obj
end function gen_event_set_beam_particles
end interface
@ %def gen_event_set_beam_particles
@ Set the cross section and error explicitly. Note that HepMC uses
pb, while WHIZARD uses fb.
<<HepMC interface: public>>=
public :: hepmc_event_set_cross_section
<<HepMC interface: procedures>>=
subroutine hepmc_event_set_cross_section (evt, xsec, xsec_err)
type(hepmc_event_t), intent(inout) :: evt
real(default), intent(in) :: xsec, xsec_err
call gen_event_set_cross_section &
(evt%obj, &
real (xsec * 1e-3_default, c_double), &
real (xsec_err * 1e-3_default, c_double))
end subroutine hepmc_event_set_cross_section
@ %def hepmc_event_set_cross_section
@ The C function returns a boolean which we do not use.
<<HepMC interface: interfaces>>=
interface
subroutine gen_event_set_cross_section (evt_obj, xs, xs_err) bind(C)
import
type(c_ptr), value :: evt_obj
real(c_double), value :: xs, xs_err
end subroutine gen_event_set_cross_section
end interface
@ %def gen_event_set_cross_section
@
\subsection{Event-particle iterator}
This iterator iterates over all particles in an event. We store a
pointer to the event in addition to the iterator. This allows for
simple end checking.
The iterator is actually a constant iterator; it can only read.
<<HepMC interface: public>>=
public :: hepmc_event_particle_iterator_t
<<HepMC interface: types>>=
type :: hepmc_event_particle_iterator_t
private
type(c_ptr) :: obj
type(c_ptr) :: evt_obj
end type hepmc_event_particle_iterator_t
@ %def hepmc_event_particle_iterator_t
@ Constructor. The iterator is initialized at the first particle in
the event.
<<HepMC interface: interfaces>>=
interface
type(c_ptr) function new_event_particle_const_iterator (evt_obj) bind(C)
import
type(c_ptr), value :: evt_obj
end function new_event_particle_const_iterator
end interface
@ %def new_event_particle_const_iterator
<<HepMC interface: public>>=
public :: hepmc_event_particle_iterator_init
<<HepMC interface: procedures>>=
subroutine hepmc_event_particle_iterator_init (it, evt)
type(hepmc_event_particle_iterator_t), intent(out) :: it
type(hepmc_event_t), intent(in) :: evt
it%obj = new_event_particle_const_iterator (evt%obj)
it%evt_obj = evt%obj
end subroutine hepmc_event_particle_iterator_init
@ %def hepmc_event_particle_iterator_init
@ Destructor. Necessary because the iterator is allocated on the
heap.
<<HepMC interface: interfaces>>=
interface
subroutine event_particle_const_iterator_delete (it_obj) bind(C)
import
type(c_ptr), value :: it_obj
end subroutine event_particle_const_iterator_delete
end interface
@ %def event_particle_const_iterator_delete
<<HepMC interface: public>>=
public :: hepmc_event_particle_iterator_final
<<HepMC interface: procedures>>=
subroutine hepmc_event_particle_iterator_final (it)
type(hepmc_event_particle_iterator_t), intent(inout) :: it
call event_particle_const_iterator_delete (it%obj)
end subroutine hepmc_event_particle_iterator_final
@ %def hepmc_event_particle_iterator_final
@ Increment
<<HepMC interface: interfaces>>=
interface
subroutine event_particle_const_iterator_advance (it_obj) bind(C)
import
type(c_ptr), value :: it_obj
end subroutine event_particle_const_iterator_advance
end interface
@ %def event_particle_const_iterator_advance
<<HepMC interface: public>>=
public :: hepmc_event_particle_iterator_advance
<<HepMC interface: procedures>>=
subroutine hepmc_event_particle_iterator_advance (it)
type(hepmc_event_particle_iterator_t), intent(inout) :: it
call event_particle_const_iterator_advance (it%obj)
end subroutine hepmc_event_particle_iterator_advance
@ %def hepmc_event_particle_iterator_advance
@ Reset to the beginning
<<HepMC interface: interfaces>>=
interface
subroutine event_particle_const_iterator_reset (it_obj, evt_obj) bind(C)
import
type(c_ptr), value :: it_obj, evt_obj
end subroutine event_particle_const_iterator_reset
end interface
@ %def event_particle_const_iterator_reset
<<HepMC interface: public>>=
public :: hepmc_event_particle_iterator_reset
<<HepMC interface: procedures>>=
subroutine hepmc_event_particle_iterator_reset (it)
type(hepmc_event_particle_iterator_t), intent(inout) :: it
call event_particle_const_iterator_reset (it%obj, it%evt_obj)
end subroutine hepmc_event_particle_iterator_reset
@ %def hepmc_event_particle_iterator_reset
@ Test: return true as long as we are not past the end.
<<HepMC interface: interfaces>>=
interface
function event_particle_const_iterator_is_valid &
(it_obj, evt_obj) result (flag) bind(C)
import
logical(c_bool) :: flag
type(c_ptr), value :: it_obj, evt_obj
end function event_particle_const_iterator_is_valid
end interface
@ %def event_particle_const_iterator_is_valid
<<HepMC interface: public>>=
public :: hepmc_event_particle_iterator_is_valid
<<HepMC interface: procedures>>=
function hepmc_event_particle_iterator_is_valid (it) result (flag)
logical :: flag
type(hepmc_event_particle_iterator_t), intent(in) :: it
flag = event_particle_const_iterator_is_valid (it%obj, it%evt_obj)
end function hepmc_event_particle_iterator_is_valid
@ %def hepmc_event_particle_iterator_is_valid
@ Return the particle pointed to by the iterator. (The particle
object should not be finalized, since it contains merely a pointer to
the particle which is owned by the vertex.)
<<HepMC interface: interfaces>>=
interface
type(c_ptr) function event_particle_const_iterator_get (it_obj) bind(C)
import
type(c_ptr), value :: it_obj
end function event_particle_const_iterator_get
end interface
@ %def event_particle_const_iterator_get
<<HepMC interface: public>>=
public :: hepmc_event_particle_iterator_get
<<HepMC interface: procedures>>=
function hepmc_event_particle_iterator_get (it) result (prt)
type(hepmc_particle_t) :: prt
type(hepmc_event_particle_iterator_t), intent(in) :: it
prt%obj = event_particle_const_iterator_get (it%obj)
end function hepmc_event_particle_iterator_get
@ %def hepmc_event_particle_iterator_get
<<HepMC interface: interfaces>>=
interface
type(c_ptr) function gen_event_get_nth_particle (evt_obj, n) bind(C)
import
type(c_ptr), value :: evt_obj
integer(c_int), value :: n
end function gen_event_get_nth_particle
end interface
interface
integer(c_int) function gen_event_get_nth_beam (evt_obj, n) bind(C)
import
type(c_ptr), value :: evt_obj
integer(c_int), value :: n
end function gen_event_get_nth_beam
end interface
@ %def gen_event_get_nth_particle
@ %def gen_event_get_nth_beam
<<HepMC interface: public>>=
public :: hepmc_event_get_nth_particle
public :: hepmc_event_get_nth_beam
<<HepMC interface: procedures>>=
function hepmc_event_get_nth_particle (evt, n) result (prt)
type(hepmc_particle_t) :: prt
type(hepmc_event_t), intent(in) :: evt
integer, intent(in) :: n
integer :: n_tot
integer(c_int) :: nth
nth = n
n_tot = gen_event_get_n_particles (evt%obj)
if (n > n_tot .or. n < 1) then
prt%obj = c_null_ptr
call msg_error ("HepMC interface called for wrong particle ID.")
else
prt%obj = gen_event_get_nth_particle (evt%obj, nth)
end if
end function hepmc_event_get_nth_particle
function hepmc_event_get_nth_beam (evt, n) result (beam_barcode)
integer :: beam_barcode
type(hepmc_event_t), intent(in) :: evt
integer, intent(in) :: n
integer(c_int) :: bc
bc = gen_event_get_nth_beam (evt%obj, n)
beam_barcode = bc
end function hepmc_event_get_nth_beam
@ %def hepmc_event_get_nth_particle
@ %def hepmc_event_get_nth_beam
@
\subsection{I/O streams}
There is a specific I/O stream type for handling the output of
GenEvent objects (i.e., Monte Carlo event samples) to file. Opening
the file is done by the constructor, closing by the destructor.
<<HepMC interface: public>>=
public :: hepmc_iostream_t
<<HepMC interface: types>>=
type :: hepmc_iostream_t
private
type(c_ptr) :: obj
end type hepmc_iostream_t
@ %def hepmc_iostream_t
@ Constructor for an output stream associated to a file.
<<HepMC interface: interfaces>>=
interface
type(c_ptr) function new_io_gen_event_out (hepmc3_mode, filename) bind(C)
import
integer(c_int), intent(in) :: hepmc3_mode
character(c_char), dimension(*), intent(in) :: filename
end function new_io_gen_event_out
end interface
@ %def new_io_gen_event_out
<<HepMC interface: public>>=
public :: hepmc_iostream_open_out
<<HepMC interface: procedures>>=
subroutine hepmc_iostream_open_out (iostream, filename, hepmc3_mode)
type(hepmc_iostream_t), intent(out) :: iostream
type(string_t), intent(in) :: filename
integer, intent(in) :: hepmc3_mode
integer(c_int) :: mode
mode = hepmc3_mode
iostream%obj = &
new_io_gen_event_out (mode, char (filename) // c_null_char)
end subroutine hepmc_iostream_open_out
@ %def hepmc_iostream_open_out
@ Constructor for an input stream associated to a file.
<<HepMC interface: interfaces>>=
interface
type(c_ptr) function new_io_gen_event_in (hepmc3_mode, filename) bind(C)
import
integer(c_int), intent(in) :: hepmc3_mode
character(c_char), dimension(*), intent(in) :: filename
end function new_io_gen_event_in
end interface
@ %def new_io_gen_event_in
<<HepMC interface: public>>=
public :: hepmc_iostream_open_in
<<HepMC interface: procedures>>=
subroutine hepmc_iostream_open_in (iostream, filename, hepmc3_mode)
type(hepmc_iostream_t), intent(out) :: iostream
type(string_t), intent(in) :: filename
integer, intent(in) :: hepmc3_mode
integer(c_int) :: mode
mode = hepmc3_mode
iostream%obj = &
new_io_gen_event_in (mode, char (filename) // c_null_char)
end subroutine hepmc_iostream_open_in
@ %def hepmc_iostream_open_in
@ Destructor:
<<HepMC interface: interfaces>>=
interface
subroutine io_gen_event_delete (io_obj) bind(C)
import
type(c_ptr), value :: io_obj
end subroutine io_gen_event_delete
end interface
@ %def io_gen_event_delete
<<HepMC interface: public>>=
public :: hepmc_iostream_close
<<HepMC interface: procedures>>=
subroutine hepmc_iostream_close (iostream)
type(hepmc_iostream_t), intent(inout) :: iostream
call io_gen_event_delete (iostream%obj)
end subroutine hepmc_iostream_close
@ %def hepmc_iostream_close
@ Write a single event to the I/O stream.
<<HepMC interface: interfaces>>=
interface
subroutine io_gen_event_write_event (io_obj, evt_obj) bind(C)
import
type(c_ptr), value :: io_obj, evt_obj
end subroutine io_gen_event_write_event
end interface
interface
subroutine io_gen_event_write_event_hepmc2 (io_obj, evt_obj) bind(C)
import
type(c_ptr), value :: io_obj, evt_obj
end subroutine io_gen_event_write_event_hepmc2
end interface
@ %def io_gen_event_write_event io_gen_event_write_event_hepmc2
<<HepMC interface: public>>=
public :: hepmc_iostream_write_event
<<HepMC interface: procedures>>=
subroutine hepmc_iostream_write_event (iostream, evt, hepmc3_mode)
type(hepmc_iostream_t), intent(inout) :: iostream
type(hepmc_event_t), intent(in) :: evt
integer, intent(in), optional :: hepmc3_mode
integer :: mode
mode = HEPMC3_MODE_HEPMC3
if (present (hepmc3_mode)) mode = hepmc3_mode
call io_gen_event_write_event (iostream%obj, evt%obj)
end subroutine hepmc_iostream_write_event
@ %def hepmc_iostream_write_event
@ Read a single event from the I/O stream. Return true if successful.
<<HepMC interface: interfaces>>=
interface
logical(c_bool) function io_gen_event_read_event (io_obj, evt_obj) bind(C)
import
type(c_ptr), value :: io_obj, evt_obj
end function io_gen_event_read_event
end interface
@ %def io_gen_event_read_event
<<HepMC interface: public>>=
public :: hepmc_iostream_read_event
<<HepMC interface: procedures>>=
subroutine hepmc_iostream_read_event (iostream, evt, ok)
type(hepmc_iostream_t), intent(inout) :: iostream
type(hepmc_event_t), intent(inout) :: evt
logical, intent(out) :: ok
ok = io_gen_event_read_event (iostream%obj, evt%obj)
end subroutine hepmc_iostream_read_event
@ %def hepmc_iostream_read_event
@
\subsection{Unit tests}
Test module, followed by the corresponding implementation module.
<<[[hepmc_interface_ut.f90]]>>=
<<File header>>
module hepmc_interface_ut
use unit_tests
use system_dependencies, only: HEPMC2_AVAILABLE
use system_dependencies, only: HEPMC3_AVAILABLE
use hepmc_interface_uti
<<Standard module head>>
<<HepMC interface: public test>>
contains
<<HepMC interface: test driver>>
end module hepmc_interface_ut
@ %def hepmc_interface_ut
@
<<[[hepmc_interface_uti.f90]]>>=
<<File header>>
module hepmc_interface_uti
<<Use kinds>>
<<Use strings>>
use io_units
use lorentz
use flavors
use colors
use polarizations
use hepmc_interface
<<Standard module head>>
<<HepMC interface: test declarations>>
contains
<<HepMC interface: tests>>
end module hepmc_interface_uti
@ %def hepmc_interface_ut
@ API: driver for the unit tests below.
<<HepMC interface: public test>>=
public :: hepmc_interface_test
<<HepMC interface: test driver>>=
subroutine hepmc_interface_test (u, results)
integer, intent(in) :: u
type(test_results_t), intent(inout) :: results
<<HepMC interface: execute tests>>
end subroutine hepmc_interface_test
@ %def hepmc_test
@
This test example is an abridged version from the build-from-scratch
example in the HepMC distribution. We create two vertices for $p\to
q$ PDF splitting, then a vertex for a $qq\to W^-g$ hard-interaction
process, and finally a vertex for $W^-\to qq$ decay. The setup is for
LHC kinematics.
Extending the original example, we set color flow for the incoming
quarks and polarization for the outgoing photon. For the latter, we
have to define a particle-data object for the photon, so a flavor
object can be correctly initialized.
<<HepMC interface: execute tests>>=
if (HEPMC2_AVAILABLE) then
call test (hepmc_interface_1, "hepmc2_interface_1", &
"check HepMC2 interface", &
u, results)
else if (HEPMC3_AVAILABLE) then
call test (hepmc_interface_1, "hepmc3_interface_1", &
"check HepMC3 interface", &
u, results)
end if
<<HepMC interface: test declarations>>=
public :: hepmc_interface_1
<<HepMC interface: tests>>=
subroutine hepmc_interface_1 (u)
use physics_defs, only: VECTOR
use model_data, only: field_data_t
integer, intent(in) :: u
integer :: u_file, iostat
type(hepmc_event_t) :: evt
type(hepmc_vertex_t) :: v1, v2, v3, v4
type(hepmc_particle_t) :: prt1, prt2, prt3, prt4, prt5, prt6, prt7, prt8
type(hepmc_iostream_t) :: iostream
type(flavor_t) :: flv
type(color_t) :: col
type(polarization_t) :: pol
type(field_data_t), target :: photon_data
character(80) :: buffer
write (u, "(A)") "* Test output: HepMC interface"
write (u, "(A)") "* Purpose: test HepMC interface"
write (u, "(A)")
write (u, "(A)") "* Initialization"
write (u, "(A)")
! Initialize a photon flavor object and some polarization
call photon_data%init (var_str ("PHOTON"), 22)
call photon_data%set (spin_type=VECTOR)
call photon_data%freeze ()
call flv%init (photon_data)
call pol%init_angles &
(flv, 0.6_default, 1._default, 0.5_default)
! Event initialization
call hepmc_event_init (evt, 20, 1)
write (u, "(A)") "* p -> q splitting"
write (u, "(A)")
! $p\to q$ splittings
call hepmc_vertex_init (v1)
call hepmc_event_add_vertex (evt, v1)
call hepmc_vertex_init (v2)
call hepmc_event_add_vertex (evt, v2)
call particle_init (prt1, &
0._default, 0._default, 7000._default, 7000._default, &
2212, 3)
call hepmc_vertex_add_particle_in (v1, prt1)
call particle_init (prt2, &
0._default, 0._default,-7000._default, 7000._default, &
2212, 3)
call hepmc_vertex_add_particle_in (v2, prt2)
call particle_init (prt3, &
.750_default, -1.569_default, 32.191_default, 32.238_default, &
1, 3)
call color_init_from_array (col, [501])
call hepmc_particle_set_color (prt3, col)
call hepmc_vertex_add_particle_out (v1, prt3)
call particle_init (prt4, &
-3.047_default, -19._default, -54.629_default, 57.920_default, &
-2, 3)
call color_init_from_array (col, [-501])
call hepmc_particle_set_color (prt4, col)
call hepmc_vertex_add_particle_out (v2, prt4)
write (u, "(A)") "* Hard interaction"
write (u, "(A)")
! Hard interaction
call hepmc_vertex_init (v3)
call hepmc_event_add_vertex (evt, v3)
call hepmc_vertex_add_particle_in (v3, prt3)
call hepmc_vertex_add_particle_in (v3, prt4)
call particle_init (prt6, &
-3.813_default, 0.113_default, -1.833_default, 4.233_default, &
22, 1)
call hepmc_particle_set_polarization (prt6, pol)
call hepmc_vertex_add_particle_out (v3, prt6)
call particle_init (prt5, &
1.517_default, -20.68_default, -20.605_default, 85.925_default, &
-24, 3)
call hepmc_vertex_add_particle_out (v3, prt5)
call hepmc_event_set_signal_process_vertex (evt, v3)
! $W^-$ decay
call vertex_init_pos (v4, &
0.12_default, -0.3_default, 0.05_default, 0.004_default)
call hepmc_event_add_vertex (evt, v4)
call hepmc_vertex_add_particle_in (v4, prt5)
call particle_init (prt7, &
-2.445_default, 28.816_default, 6.082_default, 29.552_default, &
1, 1)
call hepmc_vertex_add_particle_out (v4, prt7)
call particle_init (prt8, &
3.962_default, -49.498_default, -26.687_default, 56.373_default, &
-2, 1)
call hepmc_vertex_add_particle_out (v4, prt8)
! Event output
call hepmc_event_print (evt)
write (u, "(A)") "Writing to file 'hepmc_test.hepmc'"
write (u, "(A)")
call hepmc_iostream_open_out (iostream , var_str ("hepmc_test.hepmc"), 2)
call hepmc_iostream_write_event (iostream, evt)
call hepmc_iostream_close (iostream)
write (u, "(A)") "Writing completed"
write (u, "(A)")
write (u, "(A)") "* File contents:"
write (u, "(A)")
u_file = free_unit ()
open (u_file, file = "hepmc_test.hepmc", &
action = "read", status = "old")
do
read (u_file, "(A)", iostat = iostat) buffer
if (buffer(1:14) == "HepMC::Version") buffer = "[...]"
if (iostat /= 0) exit
write (u, "(A)") trim (buffer)
end do
close (u_file)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
write (u, "(A)")
! Wrapup
! call pol%final ()
call hepmc_event_final (evt)
write (u, "(A)")
write (u, "(A)") "* Test output end: hepmc_interface_1"
contains
subroutine vertex_init_pos (v, x, y, z, t)
type(hepmc_vertex_t), intent(out) :: v
real(default), intent(in) :: x, y, z, t
type(vector4_t) :: xx
xx = vector4_moving (t, vector3_moving ([x, y, z]))
call hepmc_vertex_init (v, xx)
end subroutine vertex_init_pos
subroutine particle_init (prt, px, py, pz, E, pdg, status)
type(hepmc_particle_t), intent(out) :: prt
real(default), intent(in) :: px, py, pz, E
integer, intent(in) :: pdg, status
type(vector4_t) :: p
p = vector4_moving (E, vector3_moving ([px, py, pz]))
call hepmc_particle_init (prt, p, pdg, status)
end subroutine particle_init
end subroutine hepmc_interface_1
@ %def hepmc_interface_1
@
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{LCIO events}
This section provides the interface to the LCIO C++ library for handling
Monte-Carlo events.
Each C++ class of LCIO that we use is mirrored by a Fortran type,
which contains as its only component the C pointer to the C++ object.
Each C++ method of LCIO that we use has a C wrapper function. This
function takes a pointer to the host object as its first argument.
Further arguments are either C pointers, or in the case of simple
types (integer, real), interoperable C/Fortran objects.
The C wrapper functions have explicit interfaces in the Fortran
module. They are called by Fortran wrapper procedures. These are
treated as methods of the corresponding Fortran type.
<<[[lcio_interface.f90]]>>=
<<File header>>
module lcio_interface
use, intrinsic :: iso_c_binding !NODEP!
<<Use kinds>>
<<Use strings>>
use constants, only: PI
use physics_defs, only: ns_per_mm
use diagnostics
use lorentz
use flavors
use colors
use helicities
use polarizations
use event_handles, only: event_handle_t
<<Standard module head>>
<<LCIO interface: public>>
<<LCIO interface: types>>
<<LCIO interface: interfaces>>
contains
<<LCIO interface: procedures>>
end module lcio_interface
@ %def lcio_interface
@
\subsection{Interface check}
This function can be called in order to verify that we are using the
actual LCIO library, and not the dummy version.
<<LCIO interface: interfaces>>=
interface
logical(c_bool) function lcio_available () bind(C)
import
end function lcio_available
end interface
<<LCIO interface: public>>=
public :: lcio_is_available
<<LCIO interface: procedures>>=
function lcio_is_available () result (flag)
logical :: flag
flag = lcio_available ()
end function lcio_is_available
@ %def lcio_is_available
@
\subsection{LCIO Run Header}
This is a type for the run header of the LCIO file.
<<LCIO interface: public>>=
public :: lcio_run_header_t
<<LCIO interface: types>>=
type :: lcio_run_header_t
private
type(c_ptr) :: obj
end type lcio_run_header_t
@ %def lcio_run_header_t
The Fortran version has initializer form.
<<LCIO interface: interfaces>>=
interface
type(c_ptr) function new_lcio_run_header (proc_id) bind(C)
import
integer(c_int), value :: proc_id
end function new_lcio_run_header
end interface
@ %def new_lcio_run_header
<<LCIO interface: interfaces>>=
interface
subroutine run_header_set_simstring &
(runhdr_obj, simstring) bind(C)
import
type(c_ptr), value :: runhdr_obj
character(c_char), dimension(*), intent(in) :: simstring
end subroutine run_header_set_simstring
end interface
@ %def run_header_set_simstring
<<LCIO interface: public>>=
public :: lcio_run_header_init
<<LCIO interface: procedures>>=
subroutine lcio_run_header_init (runhdr, proc_id, run_id)
type(lcio_run_header_t), intent(out) :: runhdr
integer, intent(in), optional :: proc_id, run_id
integer(c_int) :: rid
rid = 0; if (present (run_id)) rid = run_id
runhdr%obj = new_lcio_run_header (rid)
call run_header_set_simstring (runhdr%obj, &
"WHIZARD version:" // "<<Version>>")
end subroutine lcio_run_header_init
@ %def lcio_run_header_init
@
<<LCIO interface: interfaces>>=
interface
subroutine write_run_header (lcwrt_obj, runhdr_obj) bind(C)
import
type(c_ptr), value :: lcwrt_obj
type(c_ptr), value :: runhdr_obj
end subroutine write_run_header
end interface
@ %def write_run_header
<<LCIO interface: public>>=
public :: lcio_run_header_write
<<LCIO interface: procedures>>=
subroutine lcio_run_header_write (wrt, hdr)
type(lcio_writer_t), intent(inout) :: wrt
type(lcio_run_header_t), intent(inout) :: hdr
call write_run_header (wrt%obj, hdr%obj)
end subroutine lcio_run_header_write
@ %def lcio_run_header_write
@
\subsection{LCIO Event and LC Collection}
The main object of LCIO is a LCEventImpl. The object is filled by
MCParticle objects, which are set as LCCollection.
<<LCIO interface: public>>=
public :: lccollection_t
<<LCIO interface: types>>=
type :: lccollection_t
private
type(c_ptr) :: obj = c_null_ptr
end type lccollection_t
@ %def lccollection_t
@ Initializer.
<<LCIO interface: interfaces>>=
interface
type(c_ptr) function new_lccollection () bind(C)
import
end function new_lccollection
end interface
@ %def new_lccollection
<<LCIO interface: public>>=
public :: lcio_event_t
<<LCIO interface: types>>=
type, extends (event_handle_t) :: lcio_event_t
private
type(c_ptr) :: obj = c_null_ptr
type(lccollection_t) :: lccoll
end type lcio_event_t
@ %def lcio_event_t
@ Constructor. Arguments are process ID (integer) and event ID
(integer).
The Fortran version has initializer form.
<<LCIO interface: interfaces>>=
interface
type(c_ptr) function new_lcio_event (proc_id, event_id, run_id) bind(C)
import
integer(c_int), value :: proc_id, event_id, run_id
end function new_lcio_event
end interface
@ %def new_lcio_event
@
<<LCIO interface: public>>=
public :: lcio_event_init
<<LCIO interface: procedures>>=
subroutine lcio_event_init (evt, proc_id, event_id, run_id)
type(lcio_event_t), intent(out) :: evt
integer, intent(in), optional :: proc_id, event_id, run_id
integer(c_int) :: pid, eid, rid
pid = 0; if (present (proc_id)) pid = proc_id
eid = 0; if (present (event_id)) eid = event_id
rid = 0; if (present (run_id)) rid = run_id
evt%obj = new_lcio_event (pid, eid, rid)
evt%lccoll%obj = new_lccollection ()
end subroutine lcio_event_init
@ %def lcio_event_init
@ Destructor.
<<LCIO interface: interfaces>>=
interface
subroutine lcio_event_delete (evt_obj) bind(C)
import
type(c_ptr), value :: evt_obj
end subroutine lcio_event_delete
end interface
@ %def lcio_event_delete
@ Show event on screen.
<<LCIO interface: interfaces>>=
interface
subroutine dump_lcio_event (evt_obj) bind(C)
import
type(c_ptr), value :: evt_obj
end subroutine dump_lcio_event
end interface
@ %def dump_lcio_event
<<LCIO interface: public>>=
public :: show_lcio_event
<<LCIO interface: procedures>>=
subroutine show_lcio_event (evt)
type(lcio_event_t), intent(in) :: evt
if (c_associated (evt%obj)) then
call dump_lcio_event (evt%obj)
else
call msg_error ("LCIO event is not allocated.")
end if
end subroutine show_lcio_event
@ %def show_lcio_event
@ Put a single event to file.
<<LCIO interface: interfaces>>=
interface
subroutine lcio_event_to_file (evt_obj, filename) bind(C)
import
type(c_ptr), value :: evt_obj
character(c_char), dimension(*), intent(in) :: filename
end subroutine lcio_event_to_file
end interface
@ %def lcio_event_to_file
<<LCIO interface: public>>=
public :: write_lcio_event
<<LCIO interface: procedures>>=
subroutine write_lcio_event (evt, filename)
type(lcio_event_t), intent(in) :: evt
type(string_t), intent(in) :: filename
call lcio_event_to_file (evt%obj, char (filename) // c_null_char)
end subroutine write_lcio_event
@ %def write_lcio_event
@ Finalize: use the LCIO destructor. Also nullify the pointer explicitly, to
be on the safe side.
<<LCIO interface: public>>=
public :: lcio_event_final
<<LCIO interface: procedures>>=
subroutine lcio_event_final (evt, delete)
type(lcio_event_t), intent(inout) :: evt
logical, intent(in) :: delete
if (c_associated (evt%obj)) then
if (delete) call lcio_event_delete (evt%obj)
evt%obj = c_null_ptr
evt%lccoll%obj = c_null_ptr
end if
end subroutine lcio_event_final
@ %def lcio_event_final
@ Nullify: do not call the destructor, just nullify the C pointer. There
should be another pointer associated with the object.
<<LCIO interface: public>>=
public :: lcio_event_nullify
<<LCIO interface: procedures>>=
subroutine lcio_event_nullify (evt)
type(lcio_event_t), intent(inout) :: evt
evt%obj = c_null_ptr
evt%lccoll%obj = c_null_ptr
end subroutine lcio_event_nullify
@ %def lcio_event_nullify
@ Return the actual object as a C pointer. For use in the native C++
interface only.
<<LCIO interface: public>>=
public :: lcio_event_get_c_ptr
<<LCIO interface: procedures>>=
function lcio_event_get_c_ptr (evt) result (p)
type(lcio_event_t), intent(in) :: evt
type(c_ptr) :: p
p = evt%obj
end function lcio_event_get_c_ptr
@ %def lcio_event_get_c_ptr
@
<<LCIO interface: interfaces>>=
interface
subroutine lcio_set_weight (evt_obj, weight) bind(C)
import
type(c_ptr), value :: evt_obj
real(c_double), value :: weight
end subroutine lcio_set_weight
end interface
interface
subroutine lcio_set_alpha_qcd (evt_obj, alphas) bind(C)
import
type(c_ptr), value :: evt_obj
real(c_double), value :: alphas
end subroutine lcio_set_alpha_qcd
end interface
interface
subroutine lcio_set_scale (evt_obj, scale) bind(C)
import
type(c_ptr), value :: evt_obj
real(c_double), value :: scale
end subroutine lcio_set_scale
end interface
interface
subroutine lcio_set_sqrts (evt_obj, sqrts) bind(C)
import
type(c_ptr), value :: evt_obj
real(c_double), value :: sqrts
end subroutine lcio_set_sqrts
end interface
interface
subroutine lcio_set_xsec (evt_obj, xsec, xsec_err) bind(C)
import
type(c_ptr), value :: evt_obj
real(c_double), value :: xsec, xsec_err
end subroutine lcio_set_xsec
end interface
interface
subroutine lcio_set_beam (evt_obj, pdg, beam) bind(C)
import
type(c_ptr), value :: evt_obj
integer(c_int), value :: pdg, beam
end subroutine lcio_set_beam
end interface
interface
subroutine lcio_set_pol (evt_obj, pol1, pol2) bind(C)
import
type(c_ptr), value :: evt_obj
real(c_double), value :: pol1, pol2
end subroutine lcio_set_pol
end interface
interface
subroutine lcio_set_beam_file (evt_obj, file) bind(C)
import
type(c_ptr), value :: evt_obj
character(len=1, kind=c_char), dimension(*), intent(in) :: file
end subroutine lcio_set_beam_file
end interface
interface
subroutine lcio_set_process_name (evt_obj, name) bind(C)
import
type(c_ptr), value :: evt_obj
character(len=1, kind=c_char), dimension(*), intent(in) :: name
end subroutine lcio_set_process_name
end interface
interface
subroutine lcio_set_sqme (evt_obj, sqme) bind(C)
import
type(c_ptr), value :: evt_obj
real(c_double), value :: sqme
end subroutine lcio_set_sqme
end interface
interface
subroutine lcio_set_alt_sqme (evt_obj, sqme, index) bind(C)
import
type(c_ptr), value :: evt_obj
real(c_double), value :: sqme
integer(c_int), value :: index
end subroutine lcio_set_alt_sqme
end interface
interface
subroutine lcio_set_alt_weight (evt_obj, weight, index) bind(C)
import
type(c_ptr), value :: evt_obj
real(c_double), value :: weight
integer(c_int), value :: index
end subroutine lcio_set_alt_weight
end interface
@ %def lcio_set_weight lcio_set_alpha_qcd lcio_set_scale lcio_set_sqrts
@ %def lcio_set_xsec lcio_set_beam lcio_set_pol
@ %def lcio_set_beam_file lcio_set_process_name
@ %def lcio_set_sqme lcio_set_alt_sqme lcio_set_alt_weight
@
<<LCIO interface: public>>=
public :: lcio_event_set_weight
<<LCIO interface: procedures>>=
subroutine lcio_event_set_weight (evt, weight)
type(lcio_event_t), intent(inout) :: evt
real(default), intent(in) :: weight
call lcio_set_weight (evt%obj, real (weight, c_double))
end subroutine lcio_event_set_weight
@ %def lcio_event_set_weight
@
<<LCIO interface: public>>=
public :: lcio_event_set_alpha_qcd
<<LCIO interface: procedures>>=
subroutine lcio_event_set_alpha_qcd (evt, alphas)
type(lcio_event_t), intent(inout) :: evt
real(default), intent(in) :: alphas
call lcio_set_alpha_qcd (evt%obj, real (alphas, c_double))
end subroutine lcio_event_set_alpha_qcd
@ %def lcio_event_set_alpha_qcd
@
<<LCIO interface: public>>=
public :: lcio_event_set_scale
<<LCIO interface: procedures>>=
subroutine lcio_event_set_scale (evt, scale)
type(lcio_event_t), intent(inout) :: evt
real(default), intent(in) :: scale
call lcio_set_scale (evt%obj, real (scale, c_double))
end subroutine lcio_event_set_scale
@ %def lcio_event_set_scale
@
<<LCIO interface: public>>=
public :: lcio_event_set_sqrts
<<LCIO interface: procedures>>=
subroutine lcio_event_set_sqrts (evt, sqrts)
type(lcio_event_t), intent(inout) :: evt
real(default), intent(in) :: sqrts
call lcio_set_sqrts (evt%obj, real (sqrts, c_double))
end subroutine lcio_event_set_sqrts
@ %def lcio_event_set_sqrts
@
<<LCIO interface: public>>=
public :: lcio_event_set_xsec
<<LCIO interface: procedures>>=
subroutine lcio_event_set_xsec (evt, xsec, xsec_err)
type(lcio_event_t), intent(inout) :: evt
real(default), intent(in) :: xsec, xsec_err
call lcio_set_xsec (evt%obj, &
real (xsec, c_double), real (xsec_err, c_double))
end subroutine lcio_event_set_xsec
@ %def lcio_event_set_xsec
@
<<LCIO interface: public>>=
public :: lcio_event_set_beam
<<LCIO interface: procedures>>=
subroutine lcio_event_set_beam (evt, pdg, beam)
type(lcio_event_t), intent(inout) :: evt
integer, intent(in) :: pdg, beam
call lcio_set_beam (evt%obj, &
int (pdg, c_int), int (beam, c_int))
end subroutine lcio_event_set_beam
@ %def lcio_event_set_beam
@
<<LCIO interface: public>>=
public :: lcio_event_set_polarization
<<LCIO interface: procedures>>=
subroutine lcio_event_set_polarization (evt, pol)
type(lcio_event_t), intent(inout) :: evt
real(default), intent(in), dimension(2) :: pol
call lcio_set_pol (evt%obj, &
real (pol(1), c_double), real (pol(2), c_double))
end subroutine lcio_event_set_polarization
@ %def lcio_event_set_polarization
@
<<LCIO interface: public>>=
public :: lcio_event_set_beam_file
<<LCIO interface: procedures>>=
subroutine lcio_event_set_beam_file (evt, file)
type(lcio_event_t), intent(inout) :: evt
type(string_t), intent(in) :: file
call lcio_set_beam_file (evt%obj, &
char (file) // c_null_char)
end subroutine lcio_event_set_beam_file
@ %def lcio_event_set_beam_file
@
<<LCIO interface: public>>=
public :: lcio_event_set_process_name
<<LCIO interface: procedures>>=
subroutine lcio_event_set_process_name (evt, name)
type(lcio_event_t), intent(inout) :: evt
type(string_t), intent(in) :: name
call lcio_set_process_name (evt%obj, &
char (name) // c_null_char)
end subroutine lcio_event_set_process_name
@ %def lcio_event_set_process_name
@
<<LCIO interface: public>>=
public :: lcio_event_set_alt_sqme
<<LCIO interface: procedures>>=
subroutine lcio_event_set_alt_sqme (evt, sqme, index)
type(lcio_event_t), intent(inout) :: evt
real(default), intent(in) :: sqme
integer, intent(in) :: index
call lcio_set_alt_sqme (evt%obj, real (sqme, c_double), &
int (index, c_int))
end subroutine lcio_event_set_alt_sqme
@ %def lcio_event_set_alt_sqme
@
<<LCIO interface: public>>=
public :: lcio_event_set_sqme
<<LCIO interface: procedures>>=
subroutine lcio_event_set_sqme (evt, sqme)
type(lcio_event_t), intent(inout) :: evt
real(default), intent(in) :: sqme
call lcio_set_sqme (evt%obj, real (sqme, c_double))
end subroutine lcio_event_set_sqme
@ %def lcio_event_set_sqme
@
<<LCIO interface: public>>=
public :: lcio_event_set_alt_weight
<<LCIO interface: procedures>>=
subroutine lcio_event_set_alt_weight (evt, weight, index)
type(lcio_event_t), intent(inout) :: evt
real(default), intent(in) :: weight
integer, intent(in) :: index
call lcio_set_alt_weight (evt%obj, real (weight, c_double), &
int (index, c_int))
end subroutine lcio_event_set_alt_weight
@ %def lcio_event_set_alt_weight
@
<<LCIO interface: interfaces>>=
interface
subroutine lcio_event_add_collection &
(evt_obj, lccoll_obj) bind(C)
import
type(c_ptr), value :: evt_obj, lccoll_obj
end subroutine lcio_event_add_collection
end interface
@ %def lcio_event_add_collection
<<LCIO interface: public>>=
public :: lcio_event_add_coll
<<LCIO interface: procedures>>=
subroutine lcio_event_add_coll (evt)
type(lcio_event_t), intent(inout) :: evt
call lcio_event_add_collection (evt%obj, &
evt%lccoll%obj)
end subroutine lcio_event_add_coll
@ %def lcio_event_add_coll
@
\subsection{LCIO Particle}
Particle objects have the obvious meaning.
<<LCIO interface: public>>=
public :: lcio_particle_t
<<LCIO interface: types>>=
type :: lcio_particle_t
private
type(c_ptr) :: obj
end type lcio_particle_t
@ %def lcio_particle_t
@ Constructor.
<<LCIO interface: interfaces>>=
interface
type(c_ptr) function new_lcio_particle &
(px, py, pz, pdg_id, mass, charge, status) bind(C)
import
integer(c_int), value :: pdg_id, status
real(c_double), value :: px, py, pz, mass, charge
end function new_lcio_particle
end interface
@ %def new_lcio_particle
@
<<LCIO interface: interfaces>>=
interface
subroutine add_particle_to_collection &
(prt_obj, lccoll_obj) bind(C)
import
type(c_ptr), value :: prt_obj, lccoll_obj
end subroutine add_particle_to_collection
end interface
@ %def add_particle_to_collection
<<LCIO interface: public>>=
public :: lcio_particle_add_to_evt_coll
<<LCIO interface: procedures>>=
subroutine lcio_particle_add_to_evt_coll &
(lprt, evt)
type(lcio_particle_t), intent(in) :: lprt
type(lcio_event_t), intent(inout) :: evt
call add_particle_to_collection (lprt%obj, evt%lccoll%obj)
end subroutine lcio_particle_add_to_evt_coll
@ %def lcio_particle_to_collection
@
<<LCIO interface: public>>=
public :: lcio_particle_init
<<LCIO interface: procedures>>=
subroutine lcio_particle_init (prt, p, pdg, charge, status)
type(lcio_particle_t), intent(out) :: prt
type(vector4_t), intent(in) :: p
real(default), intent(in) :: charge
real(default) :: mass
real(default) :: px, py, pz
integer, intent(in) :: pdg, status
px = vector4_get_component (p, 1)
py = vector4_get_component (p, 2)
pz = vector4_get_component (p, 3)
mass = p**1
prt%obj = new_lcio_particle (real (px, c_double), real (py, c_double), &
real (pz, c_double), int (pdg, c_int), &
real (mass, c_double), real (charge, c_double), int (status, c_int))
end subroutine lcio_particle_init
@ %def lcio_particle_init
@ Set the particle color flow.
<<LCIO interface: interfaces>>=
interface
subroutine lcio_set_color_flow (prt_obj, col1, col2) bind(C)
import
type(c_ptr), value :: prt_obj
integer(c_int), value :: col1, col2
end subroutine lcio_set_color_flow
end interface
@ %def lcio_set_color_flow
@ Set the particle color. Either from a [[color_t]] object or
directly from a pair of integers.
<<LCIO interface: interfaces>>=
interface lcio_particle_set_color
module procedure lcio_particle_set_color_col
module procedure lcio_particle_set_color_int
end interface lcio_particle_set_color
<<LCIO interface: public>>=
public :: lcio_particle_set_color
<<LCIO interface: procedures>>=
subroutine lcio_particle_set_color_col (prt, col)
type(lcio_particle_t), intent(inout) :: prt
type(color_t), intent(in) :: col
integer(c_int), dimension(2) :: c
c(1) = col%get_col ()
c(2) = col%get_acl ()
if (c(1) /= 0 .or. c(2) /= 0) then
call lcio_set_color_flow (prt%obj, c(1), c(2))
end if
end subroutine lcio_particle_set_color_col
subroutine lcio_particle_set_color_int (prt, col)
type(lcio_particle_t), intent(inout) :: prt
integer, dimension(2), intent(in) :: col
integer(c_int), dimension(2) :: c
c = col
if (c(1) /= 0 .or. c(2) /= 0) then
call lcio_set_color_flow (prt%obj, c(1), c(2))
end if
end subroutine lcio_particle_set_color_int
@ %def lcio_particle_set_color
@ Return the particle color as a two-dimensional array (color, anticolor).
<<LCIO interface: interfaces>>=
interface
integer(c_int) function lcio_particle_flow (prt_obj, col_index) bind(C)
use iso_c_binding !NODEP!
type(c_ptr), value :: prt_obj
integer(c_int), value :: col_index
end function lcio_particle_flow
end interface
@ %def lcio_particle_flow
<<LCIO interface: public>>=
public :: lcio_particle_get_flow
<<LCIO interface: procedures>>=
function lcio_particle_get_flow (prt) result (col)
integer, dimension(2) :: col
type(lcio_particle_t), intent(in) :: prt
col(1) = lcio_particle_flow (prt%obj, 0_c_int)
col(2) = - lcio_particle_flow (prt%obj, 1_c_int)
end function lcio_particle_get_flow
@ %def lcio_particle_get_flow
@ Return the four-momentum of a LCIO particle.
<<LCIO interface: interfaces>>=
interface
real(c_double) function lcio_three_momentum (prt_obj, p_index) bind(C)
use iso_c_binding !NODEP!
type(c_ptr), value :: prt_obj
integer(c_int), value :: p_index
end function lcio_three_momentum
end interface
@ %def lcio_three_momentum
<<LCIO interface: interfaces>>=
interface
real(c_double) function lcio_energy (prt_obj) bind(C)
import
type(c_ptr), intent(in), value :: prt_obj
end function lcio_energy
end interface
@ %def lcio_energy
<<LCIO interface: public>>=
public :: lcio_particle_get_momentum
<<LCIO interface: procedures>>=
function lcio_particle_get_momentum (prt) result (p)
type(vector4_t) :: p
type(lcio_particle_t), intent(in) :: prt
real(default) :: E, px, py, pz
E = lcio_energy (prt%obj)
px = lcio_three_momentum (prt%obj, 0_c_int)
py = lcio_three_momentum (prt%obj, 1_c_int)
pz = lcio_three_momentum (prt%obj, 2_c_int)
p = vector4_moving ( E, vector3_moving ([ px, py, pz ]))
end function lcio_particle_get_momentum
@ %def lcio_particle_get_momentum
@ Return the invariant mass squared of the particle object. LCIO
stores the signed invariant mass (no squaring).
<<LCIO interface: interfaces>>=
interface
function lcio_mass (prt_obj) result (mass) bind(C)
import
real(c_double) :: mass
type(c_ptr), value :: prt_obj
end function lcio_mass
end interface
@ %def lcio_mass
<<LCIO interface: public>>=
public :: lcio_particle_get_mass_squared
<<LCIO interface: procedures>>=
function lcio_particle_get_mass_squared (prt) result (m2)
real(default) :: m2
type(lcio_particle_t), intent(in) :: prt
real(default) :: m
m = lcio_mass (prt%obj)
m2 = sign (m**2, m)
end function lcio_particle_get_mass_squared
@ %def lcio_particle_get_mass_squared
@ Return vertex and production time of a LCIO particle.
<<LCIO interface: interfaces>>=
interface
real(c_double) function lcio_vtx_x (prt) bind(C)
import
type(c_ptr), value :: prt
end function lcio_vtx_x
end interface
interface
real(c_double) function lcio_vtx_y (prt) bind(C)
import
type(c_ptr), value :: prt
end function lcio_vtx_y
end interface
interface
real(c_double) function lcio_vtx_z (prt) bind(C)
import
type(c_ptr), value :: prt
end function lcio_vtx_z
end interface
interface
real(c_float) function lcio_prt_time (prt) bind(C)
import
type(c_ptr), value :: prt
end function lcio_prt_time
end interface
@
@
(Decay) times in LCIO are in nanoseconds, so they need to get
converted to mm for the internal format.
<<LCIO interface: public>>=
public :: lcio_particle_get_vertex
public :: lcio_particle_get_time
<<LCIO interface: procedures>>=
function lcio_particle_get_vertex (prt) result (vtx)
type(vector3_t) :: vtx
type(lcio_particle_t), intent(in) :: prt
real(default) :: vx, vy, vz
vx = lcio_vtx_x (prt%obj)
vy = lcio_vtx_y (prt%obj)
vz = lcio_vtx_z (prt%obj)
vtx = vector3_moving ([vx, vy, vz])
end function lcio_particle_get_vertex
function lcio_particle_get_time (prt) result (time)
real(default) :: time
type(lcio_particle_t), intent(in) :: prt
time = lcio_prt_time (prt%obj)
time = time / ns_per_mm
end function lcio_particle_get_time
@ %def lcio_particle_get_vertex lcio_particle_get_time
@
\subsection{Polarization}
For polarization there is a three-component float entry foreseen in the LCIO
format. Completely generic density matrices can in principle be attached to
events as float vectors added to [[LCCollection]] of the [[LCEvent]]. This is
not yet implemented currently. Here, we restrict ourselves to the same
implementation as in HepMC format: we use two entries as the polarization
angles, while the first entry gives the degree of polarization (something
not specified in the HepMC format).
\emph{For massive vector bosons, we arbitrarily choose the convention
that the longitudinal (zero) helicity state is mapped to the theta
angle $\pi/2$. This works under the condition that helicity is
projected onto one of the basis states.}
<<LCIO interface: interfaces>>=
interface
subroutine lcio_particle_set_spin (prt_obj, s1, s2, s3) bind(C)
import
type(c_ptr), value :: prt_obj
real(c_double), value :: s1, s2, s3
end subroutine lcio_particle_set_spin
end interface
@ %def lcio_particle_set_spin
@
<<LCIO interface: public>>=
public :: lcio_polarization_init
<<LCIO interface: interfaces>>=
interface lcio_polarization_init
module procedure lcio_polarization_init_pol
module procedure lcio_polarization_init_hel
module procedure lcio_polarization_init_int
end interface
<<LCIO interface: procedures>>=
subroutine lcio_polarization_init_pol (prt, pol)
type(lcio_particle_t), intent(inout) :: prt
type(polarization_t), intent(in) :: pol
real(default) :: r, theta, phi
if (pol%is_polarized ()) then
call pol%to_angles (r, theta, phi)
call lcio_particle_set_spin (prt%obj, &
real(r, c_double), real (theta, c_double), real (phi, c_double))
end if
end subroutine lcio_polarization_init_pol
subroutine lcio_polarization_init_hel (prt, hel)
type(lcio_particle_t), intent(inout) :: prt
type(helicity_t), intent(in) :: hel
integer, dimension(2) :: h
if (hel%is_defined ()) then
h = hel%to_pair ()
select case (h(1))
case (1:)
call lcio_particle_set_spin (prt%obj, 1._c_double, &
0._c_double, 0._c_double)
case (:-1)
call lcio_particle_set_spin (prt%obj, 1._c_double, &
real (pi, c_double), 0._c_double)
case (0)
call lcio_particle_set_spin (prt%obj, 1._c_double, &
real (pi/2, c_double), 0._c_double)
end select
end if
end subroutine lcio_polarization_init_hel
subroutine lcio_polarization_init_int (prt, hel)
type(lcio_particle_t), intent(inout) :: prt
integer, intent(in) :: hel
call lcio_particle_set_spin (prt%obj, 0._c_double, &
0._c_double, real (hel, c_double))
end subroutine lcio_polarization_init_int
@ %def lcio_polarization_init
@ Recover polarization from LCIO particle (with the
abovementioned deficiencies).
<<LCIO interface: interfaces>>=
interface
function lcio_polarization_degree (prt_obj) result (degree) bind(C)
import
real(c_double) :: degree
type(c_ptr), value :: prt_obj
end function lcio_polarization_degree
end interface
interface
function lcio_polarization_theta (prt_obj) result (theta) bind(C)
import
real(c_double) :: theta
type(c_ptr), value :: prt_obj
end function lcio_polarization_theta
end interface
interface
function lcio_polarization_phi (prt_obj) result (phi) bind(C)
import
real(c_double) :: phi
type(c_ptr), value :: prt_obj
end function lcio_polarization_phi
end interface
@ %def lcio_polarization_degree lcio_polarization_theta lcio_polarization_phi
<<LCIO interface: public>>=
public :: lcio_particle_to_pol
<<LCIO interface: procedures>>=
subroutine lcio_particle_to_pol (prt, flv, pol)
type(lcio_particle_t), intent(in) :: prt
type(flavor_t), intent(in) :: flv
type(polarization_t), intent(out) :: pol
real(default) :: degree, theta, phi
degree = lcio_polarization_degree (prt%obj)
theta = lcio_polarization_theta (prt%obj)
phi = lcio_polarization_phi (prt%obj)
call pol%init_angles (flv, degree, theta, phi)
end subroutine lcio_particle_to_pol
@ %def lcio_polarization_to_pol
@ Recover helicity. Here, $\phi$ and [[degree]] is ignored and only the sign of
$\cos\theta$ is relevant, mapped to positive/negative helicity.
<<LCIO interface: public>>=
public :: lcio_particle_to_hel
<<LCIO interface: procedures>>=
subroutine lcio_particle_to_hel (prt, flv, hel)
type(lcio_particle_t), intent(in) :: prt
type(flavor_t), intent(in) :: flv
type(helicity_t), intent(out) :: hel
real(default) :: theta
integer :: hmax
theta = lcio_polarization_theta (prt%obj)
hmax = flv%get_spin_type () / 2
call hel%init (sign (hmax, nint (cos (theta))))
end subroutine lcio_particle_to_hel
@ %def lcio_particle_to_hel
@ Set the vertex of a particle.
<<LCIO interface: interfaces>>=
interface
subroutine lcio_particle_set_vertex (prt_obj, vx, vy, vz) bind(C)
import
type(c_ptr), value :: prt_obj
real(c_double), value :: vx, vy, vz
end subroutine lcio_particle_set_vertex
end interface
interface
subroutine lcio_particle_set_time (prt_obj, t) bind(C)
import
type(c_ptr), value :: prt_obj
real(c_float), value :: t
end subroutine lcio_particle_set_time
end interface
@ %def lcio_particle_set_vertex lcio_particle_set_time
@
<<LCIO interface: public>>=
public :: lcio_particle_set_vtx
<<LCIO interface: procedures>>=
subroutine lcio_particle_set_vtx (prt, vtx)
type(lcio_particle_t), intent(inout) :: prt
type(vector3_t), intent(in) :: vtx
call lcio_particle_set_vertex (prt%obj, real(vtx%p(1), c_double), &
real(vtx%p(2), c_double), real(vtx%p(3), c_double))
end subroutine lcio_particle_set_vtx
@ %def lcio_particle_set_vtx
@
Times in LCIO are in nanoseconds, not in mm, so need to be converted.
<<LCIO interface: public>>=
public :: lcio_particle_set_t
<<LCIO interface: procedures>>=
subroutine lcio_particle_set_t (prt, t)
type(lcio_particle_t), intent(inout) :: prt
real(default), intent(in) :: t
real(default) :: ns_from_t_mm
ns_from_t_mm = ns_per_mm * t
call lcio_particle_set_time (prt%obj, real(ns_from_t_mm, c_float))
end subroutine lcio_particle_set_t
@ %def lcio_particle_set_t
@
<<LCIO interface: interfaces>>=
interface
subroutine lcio_particle_add_parent (prt_obj1, prt_obj2) bind(C)
import
type(c_ptr), value :: prt_obj1, prt_obj2
end subroutine lcio_particle_add_parent
end interface
@ %def lcio_particle_add_parent
<<LCIO interface: public>>=
public :: lcio_particle_set_parent
<<LCIO interface: procedures>>=
subroutine lcio_particle_set_parent (daughter, parent)
type(lcio_particle_t), intent(inout) :: daughter, parent
call lcio_particle_add_parent (daughter%obj, parent%obj)
end subroutine lcio_particle_set_parent
@ %def lcio_particle_set_parent
@
<<LCIO interface: interfaces>>=
interface
integer(c_int) function lcio_particle_get_generator_status &
(prt_obj) bind(C)
import
type(c_ptr), value :: prt_obj
end function lcio_particle_get_generator_status
end interface
@ %def lcio_particle_get_generator_status
<<LCIO interface: public>>=
public :: lcio_particle_get_status
<<LCIO interface: procedures>>=
function lcio_particle_get_status (lptr) result (status)
integer :: status
type(lcio_particle_t), intent(in) :: lptr
status = lcio_particle_get_generator_status (lptr%obj)
end function lcio_particle_get_status
@ %def lcio_particle_get_status
@ Getting the PDG code.
<<LCIO interface: interfaces>>=
interface
integer(c_int) function lcio_particle_get_pdg_code (prt_obj) bind(C)
import
type(c_ptr), value :: prt_obj
end function lcio_particle_get_pdg_code
end interface
@ %def lcio_particle_get_pdg_code
@
<<LCIO interface: public>>=
public :: lcio_particle_get_pdg
<<LCIO interface: procedures>>=
function lcio_particle_get_pdg (lptr) result (pdg)
integer :: pdg
type(lcio_particle_t), intent(in) :: lptr
pdg = lcio_particle_get_pdg_code (lptr%obj)
end function lcio_particle_get_pdg
@ %def lcio_particle_get_pdg
@ Obtaining the number of parents and daughters of an LCIO particle.
<<LCIO interface: interfaces>>=
interface
integer(c_int) function lcio_n_parents (prt_obj) bind(C)
import
type(c_ptr), value :: prt_obj
end function lcio_n_parents
end interface
@ %def lcio_n_parents
@
<<LCIO interface: interfaces>>=
interface
integer(c_int) function lcio_n_daughters (prt_obj) bind(C)
import
type(c_ptr), value :: prt_obj
end function lcio_n_daughters
end interface
@ %def lcio_n_daughters
@
<<LCIO interface: public>>=
public :: lcio_particle_get_n_parents
<<LCIO interface: procedures>>=
function lcio_particle_get_n_parents (lptr) result (n_parents)
integer :: n_parents
type(lcio_particle_t), intent(in) :: lptr
n_parents = lcio_n_parents (lptr%obj)
end function lcio_particle_get_n_parents
@ %def lcio_particle_get_n_parents
@
<<LCIO interface: public>>=
public :: lcio_particle_get_n_children
<<LCIO interface: procedures>>=
function lcio_particle_get_n_children (lptr) result (n_children)
integer :: n_children
type(lcio_particle_t), intent(in) :: lptr
n_children = lcio_n_daughters (lptr%obj)
end function lcio_particle_get_n_children
@ %def lcio_particle_get_n_children
@ This provides access from the LCIO event [[lcio_event_t]] to the array entries
of the parent and daughter arrays of the LCIO particles.
<<LCIO interface: interfaces>>=
interface
integer(c_int) function lcio_event_parent_k &
(evt_obj, num_part, k_parent) bind (C)
use iso_c_binding !NODEP!
type(c_ptr), value :: evt_obj
integer(c_int), value :: num_part, k_parent
end function lcio_event_parent_k
end interface
@ %def lcio_event_parent_k
<<LCIO interface: interfaces>>=
interface
integer(c_int) function lcio_event_daughter_k &
(evt_obj, num_part, k_daughter) bind (C)
use iso_c_binding !NODEP!
type(c_ptr), value :: evt_obj
integer(c_int), value :: num_part, k_daughter
end function lcio_event_daughter_k
end interface
@ %def lcio_event_daughter_k
@
<<LCIO interface: public>>=
public :: lcio_get_n_parents
<<LCIO interface: procedures>>=
function lcio_get_n_parents (evt, num_part, k_parent) result (index_parent)
type(lcio_event_t), intent(in) :: evt
integer, intent(in) :: num_part, k_parent
integer :: index_parent
index_parent = lcio_event_parent_k (evt%obj, int (num_part, c_int), &
int (k_parent, c_int))
end function lcio_get_n_parents
@ %def lcio_get_n_parents
@
<<LCIO interface: public>>=
public :: lcio_get_n_children
<<LCIO interface: procedures>>=
function lcio_get_n_children (evt, num_part, k_daughter) result (index_daughter)
type(lcio_event_t), intent(in) :: evt
integer, intent(in) :: num_part, k_daughter
integer :: index_daughter
index_daughter = lcio_event_daughter_k (evt%obj, int (num_part, c_int), &
int (k_daughter, c_int))
end function lcio_get_n_children
@ %def lcio_get_n_children
@
\subsection{LCIO Writer type}
There is a specific LCIO Writer type for handling the output of
LCEventImpl objects (i.e., Monte Carlo event samples) to file. Opening
the file is done by the constructor, closing by the destructor.
<<LCIO interface: public>>=
public :: lcio_writer_t
<<LCIO interface: types>>=
type :: lcio_writer_t
private
type(c_ptr) :: obj
end type lcio_writer_t
@ %def lcio_writer_t
@ Constructor for an output associated to a file.
<<LCIO interface: interfaces>>=
interface
type(c_ptr) function open_lcio_writer_new (filename, complevel) bind(C)
import
character(c_char), dimension(*), intent(in) :: filename
integer(c_int), intent(in) :: complevel
end function open_lcio_writer_new
end interface
@ %def open_lcio_writer_now
<<LCIO interface: public>>=
public :: lcio_writer_open_out
<<LCIO interface: procedures>>=
subroutine lcio_writer_open_out (lcio_writer, filename)
type(lcio_writer_t), intent(out) :: lcio_writer
type(string_t), intent(in) :: filename
lcio_writer%obj = open_lcio_writer_new (char (filename) // &
c_null_char, 9_c_int)
end subroutine lcio_writer_open_out
@ %def lcio_writer_open_out
@ Destructor:
<<LCIO interface: interfaces>>=
interface
subroutine lcio_writer_delete (io_obj) bind(C)
import
type(c_ptr), value :: io_obj
end subroutine lcio_writer_delete
end interface
@ %def lcio_writer_delete
<<LCIO interface: public>>=
public :: lcio_writer_close
<<LCIO interface: procedures>>=
subroutine lcio_writer_close (lciowriter)
type(lcio_writer_t), intent(inout) :: lciowriter
call lcio_writer_delete (lciowriter%obj)
end subroutine lcio_writer_close
@ %def lcio_writer_close
@ Write a single event to the LCIO writer.
<<LCIO interface: interfaces>>=
interface
subroutine lcio_write_event (io_obj, evt_obj) bind(C)
import
type(c_ptr), value :: io_obj, evt_obj
end subroutine lcio_write_event
end interface
@ %def lcio_write_event
<<LCIO interface: public>>=
public :: lcio_event_write
<<LCIO interface: procedures>>=
subroutine lcio_event_write (wrt, evt)
type(lcio_writer_t), intent(inout) :: wrt
type(lcio_event_t), intent(in) :: evt
call lcio_write_event (wrt%obj, evt%obj)
end subroutine lcio_event_write
@ %def lcio_event_write
@
\subsection{LCIO Reader type}
There is a specific LCIO Reader type for handling the input of
LCEventImpl objects (i.e., Monte Carlo event samples) from file. Opening
the file is done by the constructor, closing by the destructor.
<<LCIO interface: public>>=
public :: lcio_reader_t
<<LCIO interface: types>>=
type :: lcio_reader_t
private
type(c_ptr) :: obj
end type lcio_reader_t
@ %def lcio_reader_t
@ Constructor for an output associated to a file.
<<LCIO interface: interfaces>>=
interface
type(c_ptr) function open_lcio_reader (filename) bind(C)
import
character(c_char), dimension(*), intent(in) :: filename
end function open_lcio_reader
end interface
@ %def open_lcio_reader
<<LCIO interface: public>>=
public :: lcio_open_file
<<LCIO interface: procedures>>=
subroutine lcio_open_file (lcio_reader, filename)
type(lcio_reader_t), intent(out) :: lcio_reader
type(string_t), intent(in) :: filename
lcio_reader%obj = open_lcio_reader (char (filename) // c_null_char)
end subroutine lcio_open_file
@ %def lcio_open_file
@ Destructor:
<<LCIO interface: interfaces>>=
interface
subroutine lcio_reader_delete (io_obj) bind(C)
import
type(c_ptr), value :: io_obj
end subroutine lcio_reader_delete
end interface
@ %def lcio_reader_delete
<<LCIO interface: public>>=
public :: lcio_reader_close
<<LCIO interface: procedures>>=
subroutine lcio_reader_close (lcioreader)
type(lcio_reader_t), intent(inout) :: lcioreader
call lcio_reader_delete (lcioreader%obj)
end subroutine lcio_reader_close
@ %def lcio_reader_close
@
@ Read a single event from the event file. Return true if successful.
<<LCIO interface: interfaces>>=
interface
type(c_ptr) function read_lcio_event (io_obj) bind(C)
import
type(c_ptr), value :: io_obj
end function read_lcio_event
end interface
@ %def read_lcio_event
<<LCIO interface: public>>=
public :: lcio_read_event
<<LCIO interface: procedures>>=
subroutine lcio_read_event (lcrdr, evt, ok)
type(lcio_reader_t), intent(inout) :: lcrdr
type(lcio_event_t), intent(out) :: evt
logical, intent(out) :: ok
evt%obj = read_lcio_event (lcrdr%obj)
ok = c_associated (evt%obj)
end subroutine lcio_read_event
@ %def lcio_read_event
@ Get the event index.
<<LCIO interface: interfaces>>=
interface
integer(c_int) function lcio_event_get_event_number (evt_obj) bind(C)
import
type(c_ptr), value :: evt_obj
end function lcio_event_get_event_number
end interface
@ %def lcio_event_get_event_number
<<LCIO interface: public>>=
public :: lcio_event_get_event_index
<<LCIO interface: procedures>>=
function lcio_event_get_event_index (evt) result (i_evt)
integer :: i_evt
type(lcio_event_t), intent(in) :: evt
i_evt = lcio_event_get_event_number (evt%obj)
end function lcio_event_get_event_index
@ %def lcio_event_get_event_index
@ Extract the process ID. This is stored (at the moment abusively) in the
RUN ID as well as in an additional event parameter.
<<LCIO interface: interfaces>>=
interface
integer(c_int) function lcio_event_signal_process_id (evt_obj) bind(C)
import
type(c_ptr), value :: evt_obj
end function lcio_event_signal_process_id
end interface
@ %def lcio_event_signal_process_id
<<LCIO interface: public>>=
public :: lcio_event_get_process_id
<<LCIO interface: procedures>>=
function lcio_event_get_process_id (evt) result (i_proc)
integer :: i_proc
type(lcio_event_t), intent(in) :: evt
i_proc = lcio_event_signal_process_id (evt%obj)
end function lcio_event_get_process_id
@ %def lcio_event_get_process_id
@ Number of particles in an LCIO event.
<<LCIO interface: interfaces>>=
interface
integer(c_int) function lcio_event_get_n_particles (evt_obj) bind(C)
import
type(c_ptr), value :: evt_obj
end function lcio_event_get_n_particles
end interface
@ %def lcio_event_get_n_particles
<<LCIO interface:>>=
@
<<LCIO interface: public>>=
public :: lcio_event_get_n_tot
<<LCIO interface: procedures>>=
function lcio_event_get_n_tot (evt) result (n_tot)
integer :: n_tot
type(lcio_event_t), intent(in) :: evt
n_tot = lcio_event_get_n_particles (evt%obj)
end function lcio_event_get_n_tot
@ %def lcio_event_get_n_tot
@ Extracting $\alpha_s$ and the scale.
<<LCIO interface: interfaces>>=
interface
function lcio_event_get_alpha_qcd (evt_obj) result (as) bind(C)
import
real(c_double) :: as
type(c_ptr), value :: evt_obj
end function lcio_event_get_alpha_qcd
end interface
interface
function lcio_event_get_scale (evt_obj) result (scale) bind(C)
import
real(c_double) :: scale
type(c_ptr), value :: evt_obj
end function lcio_event_get_scale
end interface
@ %def lcio_event_get_alpha_qcd lcio_event_get_scale
@
<<LCIO interface: public>>=
public :: lcio_event_get_alphas
<<LCIO interface: procedures>>=
function lcio_event_get_alphas (evt) result (as)
type(lcio_event_t), intent(in) :: evt
real(default) :: as
as = lcio_event_get_alpha_qcd (evt%obj)
end function lcio_event_get_alphas
@ %def lcio_event_get_alphas
@
<<LCIO interface: public>>=
public :: lcio_event_get_scaleval
<<LCIO interface: procedures>>=
function lcio_event_get_scaleval (evt) result (scale)
type(lcio_event_t), intent(in) :: evt
real(default) :: scale
scale = lcio_event_get_scale (evt%obj)
end function lcio_event_get_scaleval
@ %def lcio_event_get_scaleval
@ Extracting particles by index from an LCIO event.
<<LCIO interface: interfaces>>=
interface
type(c_ptr) function lcio_event_particle_k (evt_obj, k) bind(C)
import
type(c_ptr), value :: evt_obj
integer(c_int), value :: k
end function lcio_event_particle_k
end interface
@ %def lcio_event_particle_k
@
<<LCIO interface: public>>=
public :: lcio_event_get_particle
<<LCIO interface: procedures>>=
function lcio_event_get_particle (evt, n) result (prt)
type(lcio_event_t), intent(in) :: evt
integer, intent(in) :: n
type(lcio_particle_t) :: prt
prt%obj = lcio_event_particle_k (evt%obj, int (n, c_int))
end function lcio_event_get_particle
@ %def lcio_event_get_particle
@
\subsection{Unit tests}
Test module, followed by the corresponding implementation module.
<<[[lcio_interface_ut.f90]]>>=
<<File header>>
module lcio_interface_ut
use unit_tests
use lcio_interface_uti
<<Standard module head>>
<<LCIO interface: public test>>
contains
<<LCIO interface: test driver>>
end module lcio_interface_ut
@ %def lcio_interface_ut
@
<<[[lcio_interface_uti.f90]]>>=
<<File header>>
module lcio_interface_uti
<<Use kinds>>
<<Use strings>>
use io_units
use lorentz
use flavors
use colors
use polarizations
use lcio_interface
<<Standard module head>>
<<LCIO interface: test declarations>>
contains
<<LCIO interface: tests>>
end module lcio_interface_uti
@ %def lcio_interface_ut
@ API: driver for the unit tests below.
<<LCIO interface: public test>>=
public :: lcio_interface_test
<<LCIO interface: test driver>>=
subroutine lcio_interface_test (u, results)
integer, intent(in) :: u
type(test_results_t), intent(inout) :: results
<<LCIO interface: execute tests>>
end subroutine lcio_interface_test
@ %def lcio_interface_test
@
<<LCIO interface: execute tests>>=
call test (lcio_interface_1, "lcio_interface_1", &
"check LCIO interface", &
u, results)
<<LCIO interface: test declarations>>=
public :: lcio_interface_1
<<LCIO interface: tests>>=
subroutine lcio_interface_1 (u)
use physics_defs, only: VECTOR
use model_data, only: field_data_t
integer, intent(in) :: u
integer :: u_file, iostat
type(lcio_event_t) :: evt
type(lcio_particle_t) :: prt1, prt2, prt3, prt4, prt5, prt6, prt7, prt8
type(flavor_t) :: flv
type(color_t) :: col
type(polarization_t) :: pol
type(field_data_t), target :: photon_data
character(220) :: buffer
write (u, "(A)") "* Test output: LCIO interface"
write (u, "(A)") "* Purpose: test LCIO interface"
write (u, "(A)")
write (u, "(A)") "* Initialization"
write (u, "(A)")
! Initialize a photon flavor object and some polarization
call photon_data%init (var_str ("PHOTON"), 22)
call photon_data%set (spin_type=VECTOR)
call photon_data%freeze ()
call flv%init (photon_data)
call pol%init_angles &
(flv, 0.6_default, 1._default, 0.5_default)
! Event initialization
call lcio_event_init (evt, 20, 1, 42)
write (u, "(A)") "* p -> q splitting"
write (u, "(A)")
! $p\to q$ splittings
call particle_init (prt1, &
0._default, 0._default, 7000._default, 7000._default, &
2212, 1._default, 3)
call particle_init (prt2, &
0._default, 0._default,-7000._default, 7000._default, &
2212, 1._default, 3)
call particle_init (prt3, &
.750_default, -1.569_default, 32.191_default, 32.238_default, &
1, -1._default/3._default, 3)
call color_init_from_array (col, [501])
call lcio_particle_set_color (prt3, col)
call lcio_particle_set_parent (prt3, prt1)
call lcio_particle_set_parent (prt3, prt2)
call particle_init (prt4, &
-3.047_default, -19._default, -54.629_default, 57.920_default, &
-2, -2._default/3._default, 3)
call color_init_from_array (col, [-501])
call lcio_particle_set_color (prt4, col)
call lcio_particle_set_parent (prt4, prt1)
call lcio_particle_set_parent (prt4, prt2)
write (u, "(A)") "* Hard interaction"
write (u, "(A)")
! Hard interaction
call particle_init (prt6, &
-3.813_default, 0.113_default, -1.833_default, 4.233_default, &
22, 0._default, 1)
call lcio_polarization_init (prt6, pol)
call particle_init (prt5, &
1.517_default, -20.68_default, -20.605_default, 85.925_default, &
-24, -1._default, 3)
call lcio_particle_set_parent (prt5, prt3)
call lcio_particle_set_parent (prt5, prt4)
call lcio_particle_set_parent (prt6, prt3)
call lcio_particle_set_parent (prt6, prt4)
! $W^-$ decay
call particle_init (prt7, &
-2.445_default, 28.816_default, 6.082_default, 29.552_default, &
1, -1._default/3._default, 1)
call particle_init (prt8, &
3.962_default, -49.498_default, -26.687_default, 56.373_default, &
-2, -2._default/3._default, 1)
call lcio_particle_set_t (prt7, 0.12_default)
call lcio_particle_set_t (prt8, 0.12_default)
call lcio_particle_set_vtx &
(prt7, vector3_moving ([-0.3_default, 0.05_default, 0.004_default]))
call lcio_particle_set_vtx &
(prt8, vector3_moving ([-0.3_default, 0.05_default, 0.004_default]))
call lcio_particle_set_parent (prt7, prt5)
call lcio_particle_set_parent (prt8, prt5)
call lcio_particle_add_to_evt_coll (prt1, evt)
call lcio_particle_add_to_evt_coll (prt2, evt)
call lcio_particle_add_to_evt_coll (prt3, evt)
call lcio_particle_add_to_evt_coll (prt4, evt)
call lcio_particle_add_to_evt_coll (prt5, evt)
call lcio_particle_add_to_evt_coll (prt6, evt)
call lcio_particle_add_to_evt_coll (prt7, evt)
call lcio_particle_add_to_evt_coll (prt8, evt)
call lcio_event_add_coll (evt)
! Event output
write (u, "(A)") "Writing in ASCII form to file 'lcio_test.slcio'"
write (u, "(A)")
call write_lcio_event (evt, var_str ("lcio_test.slcio"))
write (u, "(A)") "Writing completed"
write (u, "(A)")
write (u, "(A)") "* File contents:"
write (u, "(A)")
u_file = free_unit ()
open (u_file, file = "lcio_test.slcio", &
action = "read", status = "old")
do
read (u_file, "(A)", iostat = iostat) buffer
if (trim (buffer) == "") cycle
if (buffer(1:12) == " - timestamp") buffer = "[...]"
if (buffer(1:6) == " date:") buffer = "[...]"
if (iostat /= 0) exit
write (u, "(A)") trim (buffer)
end do
close (u_file)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
write (u, "(A)")
! Wrapup
! call pol%final ()
call lcio_event_final (evt, .true.)
write (u, "(A)")
write (u, "(A)") "* Test output end: lcio_interface_1"
contains
subroutine particle_init &
(prt, px, py, pz, E, pdg, charge, status)
type(lcio_particle_t), intent(out) :: prt
real(default), intent(in) :: px, py, pz, E, charge
integer, intent(in) :: pdg, status
type(vector4_t) :: p
p = vector4_moving (E, vector3_moving ([px, py, pz]))
call lcio_particle_init (prt, p, pdg, charge, status)
end subroutine particle_init
end subroutine lcio_interface_1
@ %def lcio_interface_1
@
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{HEP Common and Events}
This is a separate module that manages data exchange between the common blocks
and [[event_t]] objects. We separate this from the previous module in order
to avoid a circular module dependency. It also contains the functions
necessary for communication between [[hepmc_event_t]] and
[[event_t]] or [[lcio_event_t]] and [[event_t]] as well as
[[particle_set_t]] and [[particle_t]] objects.
<<[[hep_events.f90]]>>=
<<File header>>
module hep_events
<<Use kinds>>
<<Use strings>>
use system_dependencies, only: HEPMC2_AVAILABLE
use system_dependencies, only: HEPMC3_AVAILABLE
use diagnostics
use lorentz
use numeric_utils
use flavors
use colors
use helicities
use polarizations
use model_data
use subevents, only: PRT_BEAM, PRT_INCOMING, PRT_OUTGOING
use subevents, only: PRT_UNDEFINED
use subevents, only: PRT_VIRTUAL, PRT_RESONANT, PRT_BEAM_REMNANT
use particles
use hep_common
use hepmc_interface
use lcio_interface
use event_base
<<Standard module head>>
<<HEP events: public>>
contains
<<HEP events: procedures>>
end module hep_events
@ %def hep_events
@
\subsection{Data Transfer: events}
Fill the HEPEUP block, given a \whizard\ event object.
<<HEP events: public>>=
public :: hepeup_from_event
<<HEP events: procedures>>=
subroutine hepeup_from_event &
(event, keep_beams, keep_remnants, process_index)
class(generic_event_t), intent(in), target :: event
logical, intent(in), optional :: keep_beams
logical, intent(in), optional :: keep_remnants
integer, intent(in), optional :: process_index
type(particle_set_t), pointer :: particle_set
real(default) :: scale, alpha_qcd
if (event%has_valid_particle_set ()) then
particle_set => event%get_particle_set_ptr ()
call hepeup_from_particle_set (particle_set, keep_beams, keep_remnants)
if (present (process_index)) then
call hepeup_set_event_parameters (proc_id = process_index)
end if
scale = event%get_fac_scale ()
if (.not. vanishes (scale)) then
call hepeup_set_event_parameters (scale = scale)
end if
alpha_qcd = event%get_alpha_s ()
if (.not. vanishes (alpha_qcd)) then
call hepeup_set_event_parameters (alpha_qcd = alpha_qcd)
end if
if (event%weight_prc_is_known ()) then
call hepeup_set_event_parameters (weight = event%get_weight_prc ())
end if
else
call msg_bug ("HEPEUP: event incomplete")
end if
end subroutine hepeup_from_event
@ %def hepeup_from_event
@ Reverse.
Note: The current implementation sets the particle set of the hard
process and is therefore not useful if the event on file is dressed.
This should be reconsidered.
Note: setting of scale or alpha is not yet supported by the
[[event_t]] object. Ticket \#628.
<<HEP events: public>>=
public :: hepeup_to_event
<<HEP events: procedures>>=
subroutine hepeup_to_event &
(event, fallback_model, process_index, recover_beams, &
use_alpha_s, use_scale)
class(generic_event_t), intent(inout), target :: event
class(model_data_t), intent(in), target :: fallback_model
integer, intent(out), optional :: process_index
logical, intent(in), optional :: recover_beams
logical, intent(in), optional :: use_alpha_s
logical, intent(in), optional :: use_scale
class(model_data_t), pointer :: model
real(default) :: weight, scale, alpha_qcd
type(particle_set_t) :: particle_set
model => event%get_model_ptr ()
call hepeup_to_particle_set &
(particle_set, recover_beams, model, fallback_model)
call event%set_hard_particle_set (particle_set)
call particle_set%final ()
if (present (process_index)) then
call hepeup_get_event_parameters (proc_id = process_index)
end if
call hepeup_get_event_parameters (weight = weight, &
scale = scale, alpha_qcd = alpha_qcd)
call event%set_weight_ref (weight)
if (present (use_alpha_s)) then
if (use_alpha_s .and. alpha_qcd > 0) &
call event%set_alpha_qcd_forced (alpha_qcd)
end if
if (present (use_scale)) then
if (use_scale .and. scale > 0) &
call event%set_scale_forced (scale)
end if
end subroutine hepeup_to_event
@ %def hepeup_to_event
@ Fill the HEPEVT (event) common block.
The [[i_evt]] argument overrides the index stored in the [[event]] object.
<<HEP events: public>>=
public :: hepevt_from_event
<<HEP events: procedures>>=
subroutine hepevt_from_event &
(event, process_index, i_evt, keep_beams, keep_remnants, &
ensure_order, fill_hepev4)
class(generic_event_t), intent(in), target :: event
integer, intent(in), optional :: i_evt, process_index
logical, intent(in), optional :: keep_beams
logical, intent(in), optional :: keep_remnants
logical, intent(in), optional :: ensure_order
logical, intent(in), optional :: fill_hepev4
type(particle_set_t), pointer :: particle_set
real(default) :: alpha_qcd, scale
if (event%has_valid_particle_set ()) then
particle_set => event%get_particle_set_ptr ()
call hepevt_from_particle_set (particle_set, keep_beams, &
keep_remnants, ensure_order, fill_hepev4)
if (present (process_index)) then
call hepevt_set_event_parameters (proc_id = process_index)
end if
if (event%weight_prc_is_known ()) then
call hepevt_set_event_parameters (weight = event%get_weight_prc ())
end if
if (event%sqme_prc_is_known ()) then
call hepevt_set_event_parameters &
(function_value = event%get_sqme_prc ())
end if
scale = event%get_fac_scale ()
if (.not. vanishes (scale)) then
call hepevt_set_event_parameters (scale = scale)
end if
alpha_qcd = event%get_alpha_s ()
if (.not. vanishes (alpha_qcd)) then
call hepevt_set_event_parameters (alpha_qcd = alpha_qcd)
end if
if (present (i_evt)) then
call hepevt_set_event_parameters (i_evt = i_evt)
else if (event%has_index ()) then
call hepevt_set_event_parameters (i_evt = event%get_index ())
else
call hepevt_set_event_parameters (i_evt = 0)
end if
else
call msg_bug ("HEPEVT: event incomplete")
end if
end subroutine hepevt_from_event
@ %def hepevt_from_event
@
\subsubsection{HepMC format}
The master output function fills a HepMC GenEvent object that is
already initialized, but has no vertices in it.
We first set up the vertex lists and enter the vertices into the HepMC
event. Then, we assign first all incoming particles and then all
outgoing particles to their associated vertices. Particles which have
neither parent nor children entries (this should not happen) are
dropped.
Finally, we insert the beam particles. If there are none, use the incoming
particles instead.
@ Transform a particle into a [[hepmc_particle]] object, including
color and polarization. The HepMC status is equivalent to the HEPEVT
status, in particular: 0 = null entry, 1 = physical particle, 2 =
decayed/fragmented SM hadron, tau or muon, 3 = other unphysical particle
entry, 4 = incoming particles, 11 = intermediate resonance such as squarks.
The use of 11 for intermediate resonances is as done by HERWIG, see
http://herwig.hepforge.org/trac/wiki/FaQs.
<<HEP events: procedures>>=
subroutine particle_to_hepmc (prt, hprt)
type(particle_t), intent(in) :: prt
type(hepmc_particle_t), intent(out) :: hprt
integer :: hepmc_status
select case (prt%get_status ())
case (PRT_UNDEFINED)
hepmc_status = 0
case (PRT_OUTGOING)
hepmc_status = 1
case (PRT_BEAM)
hepmc_status = 4
case (PRT_RESONANT)
if (abs(prt%get_pdg()) == 13 .or. &
abs(prt%get_pdg()) == 15) then
hepmc_status = 2
else
hepmc_status = 11
end if
case default
hepmc_status = 3
end select
call hepmc_particle_init (hprt, &
prt%get_momentum (), prt%get_pdg (), &
hepmc_status)
if (HEPMC2_AVAILABLE) then
call hepmc_particle_set_color (hprt, prt%get_color ())
select case (prt%get_polarization_status ())
case (PRT_DEFINITE_HELICITY)
call hepmc_particle_set_polarization (hprt, &
prt%get_helicity ())
case (PRT_GENERIC_POLARIZATION)
call hepmc_particle_set_polarization (hprt, &
prt%get_polarization ())
end select
end if
end subroutine particle_to_hepmc
@ %def particle_to_hepmc
@ For HepMC3, a HepMC particle needs first to be attached to a vertex
and an event before non-intrinsic particle properties (color flow and
helicity) could be set.
<<HEP events: public>>=
public :: hepmc_event_from_particle_set
<<HEP events: procedures>>=
subroutine hepmc_event_from_particle_set &
(evt, particle_set, cross_section, error)
type(hepmc_event_t), intent(inout) :: evt
type(particle_set_t), intent(in) :: particle_set
real(default), intent(in), optional :: cross_section, error
type(hepmc_vertex_t), dimension(:), allocatable :: v
type(hepmc_particle_t), dimension(:), allocatable :: hprt
type(hepmc_particle_t), dimension(2) :: hbeam
type(vector4_t), dimension(:), allocatable :: vtx
logical, dimension(:), allocatable :: is_beam
integer, dimension(:), allocatable :: v_from, v_to
integer :: n_vertices, n_tot, i
n_tot = particle_set%get_n_tot ()
allocate (v_from (n_tot), v_to (n_tot))
call particle_set%assign_vertices (v_from, v_to, n_vertices)
allocate (hprt (n_tot))
allocate (vtx (n_vertices))
vtx = vector4_null
do i = 1, n_tot
if (v_to(i) /= 0 .or. v_from(i) /= 0) then
call particle_to_hepmc (particle_set%prt(i), hprt(i))
if (v_to(i) /= 0) then
vtx(v_to(i)) = particle_set%prt(i)%get_vertex ()
end if
end if
end do
if (present (cross_section) .and. present(error)) &
call hepmc_event_set_cross_section (evt, cross_section, error)
allocate (v (n_vertices))
do i = 1, n_vertices
call hepmc_vertex_init (v(i), vtx(i))
call hepmc_event_add_vertex (evt, v(i))
end do
allocate (is_beam (n_tot))
is_beam = particle_set%prt(1:n_tot)%get_status () == PRT_BEAM
if (.not. any (is_beam)) then
is_beam = particle_set%prt(1:n_tot)%get_status () == PRT_INCOMING
end if
if (count (is_beam) == 2) then
hbeam = pack (hprt, is_beam)
call hepmc_event_set_beam_particles (evt, hbeam(1), hbeam(2))
end if
do i = 1, n_tot
if (v_to(i) /= 0) then
call hepmc_vertex_add_particle_in (v(v_to(i)), hprt(i))
end if
end do
do i = 1, n_tot
if (v_from(i) /= 0) then
call hepmc_vertex_add_particle_out (v(v_from(i)), hprt(i))
end if
end do
FIND_SIGNAL_PROCESS: do i = 1, n_tot
if (particle_set%prt(i)%get_status () == PRT_INCOMING) then
call hepmc_event_set_signal_process_vertex (evt, v(v_to(i)))
exit FIND_SIGNAL_PROCESS
end if
end do FIND_SIGNAL_PROCESS
if (HEPMC3_AVAILABLE) then
do i = 1, n_tot
call hepmc_particle_set_color (hprt(i), &
particle_set%prt(i)%get_color ())
select case (particle_set%prt(i)%get_polarization_status ())
case (PRT_DEFINITE_HELICITY)
call hepmc_particle_set_polarization (hprt(i), &
particle_set%prt(i)%get_helicity ())
case (PRT_GENERIC_POLARIZATION)
call hepmc_particle_set_polarization (hprt(i), &
particle_set%prt(i)%get_polarization ())
end select
end do
end if
end subroutine hepmc_event_from_particle_set
@ %def hepmc_event_from_particle_set
@ Initialize a particle from a HepMC particle object. The model is
necessary for making a fully qualified flavor component. We have the
additional flag [[polarized]] which tells whether the polarization
information should be interpreted or ignored, and the lookup array of
barcodes. Note that the lookup array is searched linearly, a possible
bottleneck for large particle arrays. If necessary, the barcode array
could be replaced by a hash table.
<<HEP events: procedures>>=
subroutine particle_from_hepmc_particle &
(prt, hprt, model, fallback_model, polarization, barcode)
type(particle_t), intent(out) :: prt
type(hepmc_particle_t), intent(in) :: hprt
type(model_data_t), intent(in), target :: model
type(model_data_t), intent(in), target :: fallback_model
type(hepmc_vertex_t) :: vtx
integer, intent(in) :: polarization
integer, dimension(:), intent(in) :: barcode
type(hepmc_polarization_t) :: hpol
type(flavor_t) :: flv
type(color_t) :: col
type(helicity_t) :: hel
type(polarization_t) :: pol
type(vector4_t) :: vertex
integer :: n_parents, n_children
integer, dimension(:), allocatable :: &
parent_barcode, child_barcode, parent, child
integer :: i
select case (hepmc_particle_get_status (hprt))
case (1); call prt%set_status (PRT_OUTGOING)
case (2); call prt%set_status (PRT_RESONANT)
case (3); call prt%set_status (PRT_VIRTUAL)
end select
if (hepmc_particle_is_beam (hprt)) call prt%set_status (PRT_BEAM)
call flv%init (hepmc_particle_get_pdg (hprt), model, fallback_model)
call col%init (hepmc_particle_get_color (hprt))
call prt%set_flavor (flv)
call prt%set_color (col)
call prt%set_polarization (polarization)
select case (polarization)
case (PRT_DEFINITE_HELICITY)
hpol = hepmc_particle_get_polarization (hprt)
call hepmc_polarization_to_hel (hpol, prt%get_flv (), hel)
call prt%set_helicity (hel)
call hepmc_polarization_final (hpol)
case (PRT_GENERIC_POLARIZATION)
hpol = hepmc_particle_get_polarization (hprt)
call hepmc_polarization_to_pol (hpol, prt%get_flv (), pol)
call prt%set_pol (pol)
call hepmc_polarization_final (hpol)
end select
call prt%set_momentum (hepmc_particle_get_momentum (hprt), &
hepmc_particle_get_mass_squared (hprt))
n_parents = hepmc_particle_get_n_parents (hprt)
n_children = hepmc_particle_get_n_children (hprt)
if (HEPMC2_AVAILABLE) then
allocate (parent_barcode (n_parents), parent (n_parents))
allocate (child_barcode (n_children), child (n_children))
parent_barcode = hepmc_particle_get_parent_barcodes (hprt)
child_barcode = hepmc_particle_get_child_barcodes (hprt)
do i = 1, size (barcode)
where (parent_barcode == barcode(i)) parent = i
where (child_barcode == barcode(i)) child = i
end do
call prt%set_parents (parent)
call prt%set_children (child)
else if (HEPMC3_AVAILABLE) then
allocate (parent_barcode (n_parents), parent (n_parents))
allocate (child_barcode (n_children), child (n_children))
parent_barcode = hepmc_particle_get_parent_barcodes (hprt)
child_barcode = hepmc_particle_get_child_barcodes (hprt)
do i = 1, size (barcode)
where (parent_barcode == barcode(i)) parent = i
where (child_barcode == barcode(i)) child = i
end do
call prt%set_parents (parent)
call prt%set_children (child)
end if
if (prt%get_status () == PRT_VIRTUAL .and. n_parents == 0) &
call prt%set_status (PRT_INCOMING)
if (HEPMC2_AVAILABLE) then
vtx = hepmc_particle_get_decay_vertex (hprt)
if (hepmc_vertex_is_valid (vtx)) then
vertex = hepmc_vertex_to_vertex (vtx)
if (vertex /= vector4_null) call prt%set_vertex (vertex)
end if
end if
end subroutine particle_from_hepmc_particle
@ %def particle_from_hepmc_particle
@ If a particle set is initialized from a HepMC event record, we have
to specify the treatment of polarization (unpolarized or density
matrix) which is common to all particles. Correlated polarization
information is not available.
There is some complication in reconstructing incoming particles and
beam remnants. First of all, they all will be tagged as virtual. We
then define an incoming particle as
<<HEP events: public>>=
public :: hepmc_event_to_particle_set
<<HEP events: procedures>>=
subroutine hepmc_event_to_particle_set &
(particle_set, evt, model, fallback_model, polarization)
type(particle_set_t), intent(inout), target :: particle_set
type(hepmc_event_t), intent(in) :: evt
class(model_data_t), intent(in), target :: model, fallback_model
integer, intent(in) :: polarization
type(hepmc_event_particle_iterator_t) :: it
type(hepmc_vertex_t) :: v
type(hepmc_vertex_particle_in_iterator_t) :: v_it
type(hepmc_particle_t) :: prt
integer, dimension(:), allocatable :: barcode, n_parents
integer :: n_tot, n_beam, i, bc
n_tot = hepmc_event_get_n_particles(evt)
allocate (barcode (n_tot))
if (HEPMC2_AVAILABLE) then
call hepmc_event_particle_iterator_init (it, evt)
do i = 1, n_tot
barcode(i) = hepmc_particle_get_barcode &
(hepmc_event_particle_iterator_get (it))
call hepmc_event_particle_iterator_advance (it)
end do
allocate (particle_set%prt (n_tot))
call hepmc_event_particle_iterator_reset (it)
do i = 1, n_tot
prt = hepmc_event_particle_iterator_get (it)
call particle_from_hepmc_particle (particle_set%prt(i), &
prt, model, fallback_model, polarization, barcode)
call hepmc_event_particle_iterator_advance (it)
end do
call hepmc_event_particle_iterator_final (it)
v = hepmc_event_get_signal_process_vertex (evt)
if (hepmc_vertex_is_valid (v)) then
call hepmc_vertex_particle_in_iterator_init (v_it, v)
do while (hepmc_vertex_particle_in_iterator_is_valid (v_it))
prt = hepmc_vertex_particle_in_iterator_get (v_it)
bc = hepmc_particle_get_barcode &
(hepmc_vertex_particle_in_iterator_get (v_it))
do i = 1, size(barcode)
if (bc == barcode(i)) &
call particle_set%prt(i)%set_status (PRT_INCOMING)
end do
call hepmc_vertex_particle_in_iterator_advance (v_it)
end do
call hepmc_vertex_particle_in_iterator_final (v_it)
end if
else if (HEPMC3_AVAILABLE) then
allocate (particle_set%prt (n_tot))
do i = 1, n_tot
barcode(i) = hepmc_particle_get_barcode &
(hepmc_event_get_nth_particle (evt, i))
end do
do i = 1, n_tot
prt = hepmc_event_get_nth_particle (evt, i)
call particle_from_hepmc_particle (particle_set%prt(i), &
prt, model, fallback_model, polarization, barcode)
end do
end if
do i = 1, n_tot
if (particle_set%prt(i)%get_status () == PRT_VIRTUAL &
.and. particle_set%prt(i)%get_n_children () == 0) &
call particle_set%prt(i)%set_status (PRT_OUTGOING)
end do
if (HEPMC3_AVAILABLE) then
n_beam = hepmc_event_get_n_beams (evt)
do i = 1, n_beam
bc = hepmc_event_get_nth_beam (evt, i)
if (.not. particle_set%prt(bc)%get_status () == PRT_INCOMING) &
call particle_set%prt(bc)%set_status (PRT_BEAM)
end do
do i = 1, n_tot
if (particle_set%prt(i)%get_status () == PRT_VIRTUAL) then
n_parents = particle_set%prt(i)%get_parents ()
if (all &
(particle_set%prt(n_parents)%get_status () == PRT_BEAM)) then
call particle_set%prt(i)%set_status (PRT_INCOMING)
end if
end if
end do
end if
particle_set%n_tot = n_tot
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_in - particle_set%n_out
end subroutine hepmc_event_to_particle_set
@ %def hepmc_event_to_particle_set
@ Fill a WHIZARD event from a HepMC event record. In HepMC the weights
are in a weight container. If the size of this container is larger than
one, it is ambiguous to assign the event a specific weight. For now we
only allow to read in unweighted events.
<<HEP events: public>>=
public :: hepmc_to_event
<<HEP events: procedures>>=
subroutine hepmc_to_event &
(event, hepmc_event, fallback_model, process_index, &
recover_beams, use_alpha_s, use_scale)
class(generic_event_t), intent(inout), target :: event
type(hepmc_event_t), intent(inout) :: hepmc_event
class(model_data_t), intent(in), target :: fallback_model
integer, intent(out), optional :: process_index
logical, intent(in), optional :: recover_beams
logical, intent(in), optional :: use_alpha_s
logical, intent(in), optional :: use_scale
class(model_data_t), pointer :: model
real(default) :: scale, alpha_qcd
type(particle_set_t) :: particle_set
model => event%get_model_ptr ()
call event%set_index (hepmc_event_get_event_index (hepmc_event))
call hepmc_event_to_particle_set (particle_set, &
hepmc_event, model, fallback_model, PRT_DEFINITE_HELICITY)
call event%set_hard_particle_set (particle_set)
call particle_set%final ()
call event%set_weight_ref (1._default)
alpha_qcd = hepmc_event_get_alpha_qcd (hepmc_event)
scale = hepmc_event_get_scale (hepmc_event)
if (present (use_alpha_s)) then
if (use_alpha_s .and. alpha_qcd > 0) &
call event%set_alpha_qcd_forced (alpha_qcd)
end if
if (present (use_scale)) then
if (use_scale .and. scale > 0) &
call event%set_scale_forced (scale)
end if
end subroutine hepmc_to_event
@ %def hepmc_to_event
@
\subsubsection{LCIO event format}
The master output function fills a LCIO event object that is
already initialized, but has no particles in it.
In contrast to HepMC in LCIO there are no vertices (except for tracker
and other detector specifications). So we assign first all incoming
particles and then all outgoing particles to LCIO particle types.
Particles which have neither parent nor children entries (this
should not happen) are dropped. Finally, we insert the beam particles.
If there are none, use the incoming particles instead.
Transform a particle into a [[lcio_particle]] object, including
color and polarization. The LCIO status is equivalent to the HepMC
status, in particular: 0 = null entry, 1 = physical particle, 2 =
decayed/fragmented SM hadron, tau or muon, 3 = other unphysical particle
entry, 4 = incoming particles, 11 = intermediate resonance such as squarks.
The use of 11 for intermediate resonances is as done by HERWIG, see
http://herwig.hepforge.org/trac/wiki/FaQs.
A beam-remnant particle (e.g., ISR photon) that has no children is
tagged as outgoing, otherwise unphysical.
<<HEP events: public>>=
public :: particle_to_lcio
<<HEP events: procedures>>=
subroutine particle_to_lcio (prt, lprt)
type(particle_t), intent(in) :: prt
type(lcio_particle_t), intent(out) :: lprt
integer :: lcio_status
type(vector4_t) :: vtx
select case (prt%get_status ())
case (PRT_UNDEFINED)
lcio_status = 0
case (PRT_OUTGOING)
lcio_status = 1
case (PRT_BEAM_REMNANT)
if (prt%get_n_children () == 0) then
lcio_status = 1
else
lcio_status = 3
end if
case (PRT_BEAM)
lcio_status = 4
case (PRT_RESONANT)
lcio_status = 2
case default
lcio_status = 3
end select
call lcio_particle_init (lprt, &
prt%get_momentum (), &
prt%get_pdg (), &
prt%flv%get_charge (), &
lcio_status)
call lcio_particle_set_color (lprt, prt%get_color ())
vtx = prt%get_vertex ()
call lcio_particle_set_vtx (lprt, space_part (vtx))
call lcio_particle_set_t (lprt, vtx%p(0))
select case (prt%get_polarization_status ())
case (PRT_DEFINITE_HELICITY)
call lcio_polarization_init (lprt, prt%get_helicity ())
case (PRT_GENERIC_POLARIZATION)
call lcio_polarization_init (lprt, prt%get_polarization ())
end select
end subroutine particle_to_lcio
@ %def particle_to_lcio
@
@ Initialize a particle from a LCIO particle object. The model is
necessary for making a fully qualified flavor component.
<<HEP events: public>>=
public :: particle_from_lcio_particle
<<HEP events: procedures>>=
subroutine particle_from_lcio_particle &
(prt, lprt, model, daughters, parents, polarization)
type(particle_t), intent(out) :: prt
type(lcio_particle_t), intent(in) :: lprt
type(model_data_t), intent(in), target :: model
integer, dimension(:), intent(in) :: daughters, parents
type(vector4_t) :: vtx4
type(flavor_t) :: flv
type(color_t) :: col
type(helicity_t) :: hel
type(polarization_t) :: pol
integer, intent(in) :: polarization
select case (lcio_particle_get_status (lprt))
case (1); call prt%set_status (PRT_OUTGOING)
case (2); call prt%set_status (PRT_RESONANT)
case (3)
select case (size (parents))
case (0)
call prt%set_status (PRT_INCOMING)
case default
call prt%set_status (PRT_VIRTUAL)
end select
case (4); call prt%set_status (PRT_BEAM)
end select
call flv%init (lcio_particle_get_pdg (lprt), model)
call col%init (lcio_particle_get_flow (lprt))
if (flv%is_beam_remnant ()) call prt%set_status (PRT_BEAM_REMNANT)
call prt%set_flavor (flv)
call prt%set_color (col)
call prt%set_polarization (polarization)
select case (polarization)
case (PRT_DEFINITE_HELICITY)
call lcio_particle_to_hel (lprt, prt%get_flv (), hel)
call prt%set_helicity (hel)
case (PRT_GENERIC_POLARIZATION)
call lcio_particle_to_pol (lprt, prt%get_flv (), pol)
call prt%set_pol (pol)
end select
call prt%set_momentum (lcio_particle_get_momentum (lprt), &
lcio_particle_get_mass_squared (lprt))
call prt%set_parents (parents)
call prt%set_children (daughters)
vtx4 = vector4_moving (lcio_particle_get_time (lprt), &
lcio_particle_get_vertex (lprt))
if (vtx4 /= vector4_null) call prt%set_vertex (vtx4)
end subroutine particle_from_lcio_particle
@ %def particle_from_lcio_particle
@
<<HEP events: public>>=
public :: lcio_event_from_particle_set
<<HEP events: procedures>>=
subroutine lcio_event_from_particle_set (evt, particle_set)
type(lcio_event_t), intent(inout) :: evt
type(particle_set_t), intent(in) :: particle_set
type(lcio_particle_t), dimension(:), allocatable :: lprt
type(particle_set_t), target :: pset_filtered
integer, dimension(:), allocatable :: parent
integer :: n_tot, i, j, n_beam, n_parents, type, beam_count
call particle_set%filter_particles ( pset_filtered, real_parents = .true. , &
keep_beams = .true. , keep_virtuals = .false.)
n_tot = pset_filtered%n_tot
n_beam = count (pset_filtered%prt%get_status () == PRT_BEAM)
if (n_beam == 0) then
type = PRT_INCOMING
else
type = PRT_BEAM
end if
beam_count = 0
allocate (lprt (n_tot))
do i = 1, n_tot
call particle_to_lcio (pset_filtered%prt(i), lprt(i))
n_parents = pset_filtered%prt(i)%get_n_parents ()
if (n_parents /= 0) then
allocate (parent (n_parents))
parent = pset_filtered%prt(i)%get_parents ()
do j = 1, n_parents
call lcio_particle_set_parent (lprt(i), lprt(parent(j)))
end do
deallocate (parent)
end if
if (pset_filtered%prt(i)%get_status () == type) then
beam_count = beam_count + 1
call lcio_event_set_beam &
(evt, pset_filtered%prt(i)%get_pdg (), beam_count)
end if
call lcio_particle_add_to_evt_coll (lprt(i), evt)
end do
call lcio_event_add_coll (evt)
end subroutine lcio_event_from_particle_set
@ %def lcio_event_from_particle_set
@ If a particle set is initialized from a LCIO event record, we have
to specify the treatment of polarization (unpolarized or density
matrix) which is common to all particles. Correlated polarization
information is not available.
<<HEP events: public>>=
public :: lcio_event_to_particle_set
<<HEP events: procedures>>=
subroutine lcio_event_to_particle_set &
(particle_set, evt, model, fallback_model, polarization)
type(particle_set_t), intent(inout), target :: particle_set
type(lcio_event_t), intent(in) :: evt
class(model_data_t), intent(in), target :: model, fallback_model
integer, intent(in) :: polarization
type(lcio_particle_t) :: prt
integer, dimension(:), allocatable :: parents, daughters
integer :: n_tot, i, j, n_parents, n_children
n_tot = lcio_event_get_n_tot (evt)
allocate (particle_set%prt (n_tot))
do i = 1, n_tot
prt = lcio_event_get_particle (evt, i-1)
n_parents = lcio_particle_get_n_parents (prt)
n_children = lcio_particle_get_n_children (prt)
allocate (daughters (n_children))
allocate (parents (n_parents))
if (n_children > 0) then
do j = 1, n_children
daughters(j) = lcio_get_n_children (evt,i,j)
end do
end if
if (n_parents > 0) then
do j = 1, n_parents
parents(j) = lcio_get_n_parents (evt,i,j)
end do
end if
call particle_from_lcio_particle (particle_set%prt(i), prt, model, &
daughters, parents, polarization)
deallocate (daughters, parents)
end do
do i = 1, n_tot
if (particle_set%prt(i)%get_status () == PRT_VIRTUAL) then
CHECK_BEAM: do j = 1, particle_set%prt(i)%get_n_parents ()
if (particle_set%prt(j)%get_status () == PRT_BEAM) &
call particle_set%prt(i)%set_status (PRT_INCOMING)
exit CHECK_BEAM
end do CHECK_BEAM
end if
end do
particle_set%n_tot = n_tot
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_in - particle_set%n_out
end subroutine lcio_event_to_particle_set
@ %def lcio_event_to_particle_set
@
<<HEP events: public>>=
public :: lcio_to_event
<<HEP events: procedures>>=
subroutine lcio_to_event &
(event, lcio_event, fallback_model, process_index, recover_beams, &
use_alpha_s, use_scale)
class(generic_event_t), intent(inout), target :: event
type(lcio_event_t), intent(inout) :: lcio_event
class(model_data_t), intent(in), target :: fallback_model
integer, intent(out), optional :: process_index
logical, intent(in), optional :: recover_beams
logical, intent(in), optional :: use_alpha_s
logical, intent(in), optional :: use_scale
class(model_data_t), pointer :: model
real(default) :: scale, alpha_qcd
type(particle_set_t) :: particle_set
model => event%get_model_ptr ()
call lcio_event_to_particle_set (particle_set, &
lcio_event, model, fallback_model, PRT_DEFINITE_HELICITY)
call event%set_hard_particle_set (particle_set)
call particle_set%final ()
call event%set_weight_ref (1._default)
alpha_qcd = lcio_event_get_alphas (lcio_event)
scale = lcio_event_get_scaleval (lcio_event)
if (present (use_alpha_s)) then
if (use_alpha_s .and. alpha_qcd > 0) &
call event%set_alpha_qcd_forced (alpha_qcd)
end if
if (present (use_scale)) then
if (use_scale .and. scale > 0) &
call event%set_scale_forced (scale)
end if
end subroutine lcio_to_event
@ %def lcio_to_event
@
\subsection{Unit tests}
Test module, followed by the corresponding implementation module.
<<[[hep_events_ut.f90]]>>=
<<File header>>
module hep_events_ut
use unit_tests
use hepmc_interface, only: HEPMC_IS_AVAILABLE
use system_dependencies, only: HEPMC2_AVAILABLE
use hep_events_uti
<<Standard module head>>
<<HEP events: public test>>
contains
<<HEP events: test driver>>
end module hep_events_ut
@ %def hep_events_ut
@
<<[[hep_events_uti.f90]]>>=
<<File header>>
module hep_events_uti
<<Use kinds>>
<<Use strings>>
use lorentz
use flavors
use colors
use helicities
use quantum_numbers
use state_matrices, only: FM_SELECT_HELICITY, FM_FACTOR_HELICITY
use interactions
use evaluators
use model_data
use particles
use subevents
use hepmc_interface
use hep_events
<<Standard module head>>
<<HEP events: test declarations>>
contains
<<HEP events: tests>>
end module hep_events_uti
@ %def hep_events_ut
@ API: driver for the unit tests below.
<<HEP events: public test>>=
public :: hep_events_test
<<HEP events: test driver>>=
subroutine hep_events_test (u, results)
integer, intent(in) :: u
type(test_results_t), intent(inout) :: results
<<HEP events: execute tests>>
end subroutine hep_events_test
@ %def particles_test
@ If [[HepMC]] is available, check the routines via [[HepMC]].
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$.
<<HEP events: execute tests>>=
if (hepmc_is_available ()) then
call test (hep_events_1, "hep_events_1", &
"check HepMC event routines", &
u, results)
end if
<<HEP events: test declarations>>=
public :: hep_events_1
<<HEP events: tests>>=
subroutine hep_events_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), pointer :: int
type(particle_set_t) :: particle_set1, particle_set2
type(hepmc_event_t) :: hepmc_event
type(hepmc_iostream_t) :: iostream
real(default) :: cross_section, error, weight
logical :: ok
write (u, "(A)") "* Test output: HEP events"
write (u, "(A)") "* Purpose: test HepMC event 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)") "* Transfer particle_set to HepMC, print, and output to"
write (u, "(A)") " hep_events.hepmc.dat"
write (u, "(A)")
cross_section = 42.0_default
error = 17.0_default
weight = 1.0_default
call hepmc_event_init (hepmc_event, 11, 127)
call hepmc_event_from_particle_set (hepmc_event, particle_set2, &
cross_section, error)
call hepmc_event_add_weight (hepmc_event, weight, .true.)
call hepmc_event_print (hepmc_event)
call hepmc_iostream_open_out &
(iostream , var_str ("hep_events.hepmc.dat"), 2)
call hepmc_iostream_write_event (iostream, hepmc_event)
call hepmc_iostream_close (iostream)
write (u, "(A)")
write (u, "(A)") "* Recover from HepMC file"
write (u, "(A)")
call particle_set2%final ()
call hepmc_event_final (hepmc_event)
call hepmc_event_init (hepmc_event)
call hepmc_iostream_open_in &
(iostream , var_str ("hep_events.hepmc.dat"), HEPMC3_MODE_HEPMC3)
call hepmc_iostream_read_event (iostream, hepmc_event, ok=ok)
call hepmc_iostream_close (iostream)
call hepmc_event_to_particle_set (particle_set2, &
hepmc_event, model, model, PRT_DEFINITE_HELICITY)
call particle_set2%write (u)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call particle_set1%final ()
call particle_set2%final ()
call eval%final ()
call int1%final ()
call int2%final ()
call hepmc_event_final (hepmc_event)
call model%final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: hep_events_1"
end subroutine hep_events_1
@
@ %def hep_events_1
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{LHEF Input/Output}
The LHEF event record is standardized. It is an ASCII format. We try
our best at using it for both input and output.
<<[[eio_lhef.f90]]>>=
<<File header>>
module eio_lhef
<<Use kinds>>
<<Use strings>>
use io_units
use string_utils
use numeric_utils
use diagnostics
use os_interface
use xml
use event_base
use event_handles, only: event_handle_t
use eio_data
use eio_base
use hep_common
use hep_events
<<Standard module head>>
<<EIO LHEF: public>>
<<EIO LHEF: types>>
contains
<<EIO LHEF: procedures>>
end module eio_lhef
@ %def eio_lhef
@
\subsection{Type}
With sufficient confidence that it will always be three characters, we
can store the version string with a default value.
<<EIO LHEF: public>>=
public :: eio_lhef_t
<<EIO LHEF: types>>=
type, extends (eio_t) :: eio_lhef_t
logical :: writing = .false.
logical :: reading = .false.
integer :: unit = 0
type(event_sample_data_t) :: data
type(cstream_t) :: cstream
character(3) :: version = "1.0"
logical :: keep_beams = .false.
logical :: keep_remnants = .true.
logical :: keep_virtuals = .false.
logical :: recover_beams = .true.
logical :: unweighted = .true.
logical :: write_sqme_ref = .false.
logical :: write_sqme_prc = .false.
logical :: write_sqme_alt = .false.
logical :: use_alphas_from_file = .false.
logical :: use_scale_from_file = .false.
integer :: n_alt = 0
integer, dimension(:), allocatable :: proc_num_id
integer :: i_weight_sqme = 0
type(xml_tag_t) :: tag_lhef, tag_head, tag_init, tag_event
type(xml_tag_t), allocatable :: tag_gen_n, tag_gen_v
type(xml_tag_t), allocatable :: tag_generator, tag_xsecinfo
type(xml_tag_t), allocatable :: tag_sqme_ref, tag_sqme_prc
type(xml_tag_t), dimension(:), allocatable :: tag_sqme_alt, tag_wgts_alt
type(xml_tag_t), allocatable :: tag_weight, tag_weightinfo, tag_weights
contains
<<EIO LHEF: eio lhef: TBP>>
end type eio_lhef_t
@ %def eio_lhef_t
@
\subsection{Specific Methods}
Set parameters that are specifically used with LHEF.
<<EIO LHEF: eio lhef: TBP>>=
procedure :: set_parameters => eio_lhef_set_parameters
<<EIO LHEF: procedures>>=
subroutine eio_lhef_set_parameters (eio, &
keep_beams, keep_remnants, recover_beams, &
use_alphas_from_file, use_scale_from_file, &
version, extension, write_sqme_ref, write_sqme_prc, write_sqme_alt)
class(eio_lhef_t), intent(inout) :: eio
logical, intent(in), optional :: keep_beams
logical, intent(in), optional :: keep_remnants
logical, intent(in), optional :: recover_beams
logical, intent(in), optional :: use_alphas_from_file
logical, intent(in), optional :: use_scale_from_file
character(*), intent(in), optional :: version
type(string_t), intent(in), optional :: extension
logical, intent(in), optional :: write_sqme_ref
logical, intent(in), optional :: write_sqme_prc
logical, intent(in), optional :: write_sqme_alt
if (present (keep_beams)) eio%keep_beams = keep_beams
if (present (keep_remnants)) eio%keep_remnants = keep_remnants
if (present (recover_beams)) eio%recover_beams = recover_beams
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 (version)) then
select case (version)
case ("1.0", "2.0", "3.0")
eio%version = version
case default
call msg_error ("LHEF version " // version &
// " is not supported. Inserting 2.0")
eio%version = "2.0"
end select
end if
if (present (extension)) then
eio%extension = extension
else
eio%extension = "lhe"
end if
if (present (write_sqme_ref)) eio%write_sqme_ref = write_sqme_ref
if (present (write_sqme_prc)) eio%write_sqme_prc = write_sqme_prc
if (present (write_sqme_alt)) eio%write_sqme_alt = write_sqme_alt
end subroutine eio_lhef_set_parameters
@ %def eio_lhef_set_parameters
@
\subsection{Common Methods}
Output. This is not the actual event format, but a readable account
of the current object status.
<<EIO LHEF: eio lhef: TBP>>=
procedure :: write => eio_lhef_write
<<EIO LHEF: procedures>>=
subroutine eio_lhef_write (object, unit)
class(eio_lhef_t), intent(in) :: object
integer, intent(in), optional :: unit
integer :: u, i
u = given_output_unit (unit)
write (u, "(1x,A)") "LHEF event stream:"
if (object%writing) then
write (u, "(3x,A,A)") "Writing to file = ", char (object%filename)
else if (object%reading) then
write (u, "(3x,A,A)") "Reading from file = ", char (object%filename)
else
write (u, "(3x,A)") "[closed]"
end if
write (u, "(3x,A,L1)") "Keep beams = ", object%keep_beams
write (u, "(3x,A,L1)") "Keep remnants = ", object%keep_remnants
write (u, "(3x,A,L1)") "Recover beams = ", object%recover_beams
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,A)") "Version = ", object%version
write (u, "(3x,A,A,A)") "File extension = '", &
char (object%extension), "'"
if (allocated (object%proc_num_id)) then
write (u, "(3x,A)") "Numerical process IDs:"
do i = 1, size (object%proc_num_id)
write (u, "(5x,I0,': ',I0)") i, object%proc_num_id(i)
end do
end if
end subroutine eio_lhef_write
@ %def eio_lhef_write
@ Finalizer: close any open file.
<<EIO LHEF: eio lhef: TBP>>=
procedure :: final => eio_lhef_final
<<EIO LHEF: procedures>>=
subroutine eio_lhef_final (object)
class(eio_lhef_t), intent(inout) :: object
if (allocated (object%proc_num_id)) deallocate (object%proc_num_id)
if (object%writing) then
write (msg_buffer, "(A,A,A)") "Events: closing LHEF file '", &
char (object%filename), "'"
call msg_message ()
call object%write_footer ()
close (object%unit)
object%writing = .false.
else if (object%reading) then
write (msg_buffer, "(A,A,A)") "Events: closing LHEF file '", &
char (object%filename), "'"
call msg_message ()
call object%cstream%final ()
close (object%unit)
object%reading = .false.
end if
end subroutine eio_lhef_final
@ %def eio_lhef_final
@ Common initialization for input and output.
<<EIO LHEF: eio lhef: TBP>>=
procedure :: common_init => eio_lhef_common_init
<<EIO LHEF: procedures>>=
subroutine eio_lhef_common_init (eio, sample, data, extension)
class(eio_lhef_t), intent(inout) :: eio
type(string_t), intent(in) :: sample
type(string_t), intent(in), optional :: extension
type(event_sample_data_t), intent(in), optional :: data
if (.not. present (data)) &
call msg_bug ("LHEF initialization: missing data")
eio%data = data
if (data%n_beam /= 2) &
call msg_fatal ("LHEF: defined for scattering processes only")
eio%unweighted = data%unweighted
if (eio%unweighted) then
select case (data%norm_mode)
case (NORM_UNIT)
case default; call msg_fatal &
("LHEF: normalization for unweighted events must be '1'")
end select
else
select case (data%norm_mode)
case (NORM_SIGMA)
case default; call msg_fatal &
("LHEF: normalization for weighted events must be 'sigma'")
end select
end if
eio%n_alt = data%n_alt
eio%sample = sample
if (present (extension)) then
eio%extension = extension
end if
call eio%set_filename ()
eio%unit = free_unit ()
call eio%init_tags (data)
allocate (eio%proc_num_id (data%n_proc), source = data%proc_num_id)
end subroutine eio_lhef_common_init
@ %def eio_lhef_common_init
@ Initialize the tag objects. Some tags depend on the LHEF
version. In particular, the tags that in LHEF 2.0 identify
individual weights by name in each event block, in LHEF 3.0 are
replaced by info tags in the init block and a single \texttt{weights}
tag in the event block. The name attributes of those tags
are specific for \whizard.
<<EIO LHEF: eio lhef: TBP>>=
procedure :: init_tags => eio_lhef_init_tags
<<EIO LHEF: procedures>>=
subroutine eio_lhef_init_tags (eio, data)
class(eio_lhef_t), intent(inout) :: eio
type(event_sample_data_t), intent(in) :: data
real(default), parameter :: pb_per_fb = 1.e-3_default
integer :: i
call eio%tag_lhef%init ( &
var_str ("LesHouchesEvents"), &
[xml_attribute (var_str ("version"), var_str (eio%version))], &
.true.)
call eio%tag_head%init ( &
var_str ("header"), &
.true.)
call eio%tag_init%init ( &
var_str ("init"), &
.true.)
call eio%tag_event%init (var_str ("event"), &
.true.)
select case (eio%version)
case ("1.0")
allocate (eio%tag_gen_n)
call eio%tag_gen_n%init ( &
var_str ("generator_name"), &
.true.)
allocate (eio%tag_gen_v)
call eio%tag_gen_v%init ( &
var_str ("generator_version"), &
.true.)
end select
select case (eio%version)
case ("2.0", "3.0")
allocate (eio%tag_generator)
call eio%tag_generator%init ( &
var_str ("generator"), &
[xml_attribute (var_str ("version"), var_str ("<<Version>>"))], &
.true.)
allocate (eio%tag_xsecinfo)
call eio%tag_xsecinfo%init ( &
var_str ("xsecinfo"), &
[xml_attribute (var_str ("neve"), str (data%n_evt)), &
xml_attribute (var_str ("totxsec"), &
str (data%total_cross_section * pb_per_fb))])
end select
select case (eio%version)
case ("2.0")
allocate (eio%tag_weight)
call eio%tag_weight%init (var_str ("weight"), &
[xml_attribute (var_str ("name"))])
if (eio%write_sqme_ref) then
allocate (eio%tag_sqme_ref)
call eio%tag_sqme_ref%init (var_str ("weight"), &
[xml_attribute (var_str ("name"), var_str ("sqme_ref"))], &
.true.)
end if
if (eio%write_sqme_prc) then
allocate (eio%tag_sqme_prc)
call eio%tag_sqme_prc%init (var_str ("weight"), &
[xml_attribute (var_str ("name"), var_str ("sqme_prc"))], &
.true.)
end if
if (eio%n_alt > 0) then
if (eio%write_sqme_alt) then
allocate (eio%tag_sqme_alt (1))
call eio%tag_sqme_alt(1)%init (var_str ("weight"), &
[xml_attribute (var_str ("name"), var_str ("sqme_alt"))], &
.true.)
end if
allocate (eio%tag_wgts_alt (1))
call eio%tag_wgts_alt(1)%init (var_str ("weight"), &
[xml_attribute (var_str ("name"), var_str ("wgts_alt"))], &
.true.)
end if
case ("3.0")
if (eio%write_sqme_ref) then
allocate (eio%tag_sqme_ref)
call eio%tag_sqme_ref%init (var_str ("weightinfo"), &
[xml_attribute (var_str ("name"), var_str ("sqme_ref"))])
end if
if (eio%write_sqme_prc) then
allocate (eio%tag_sqme_prc)
call eio%tag_sqme_prc%init (var_str ("weightinfo"), &
[xml_attribute (var_str ("name"), var_str ("sqme_prc"))])
end if
if (eio%n_alt > 0) then
if (eio%write_sqme_alt) then
allocate (eio%tag_sqme_alt (eio%n_alt))
do i = 1, eio%n_alt
call eio%tag_sqme_alt(i)%init (var_str ("weightinfo"), &
[xml_attribute (var_str ("name"), &
var_str ("sqme_alt") // str (i))])
end do
end if
allocate (eio%tag_wgts_alt (eio%n_alt))
do i = 1, eio%n_alt
call eio%tag_wgts_alt(i)%init (var_str ("weightinfo"), &
[xml_attribute (var_str ("name"), &
var_str ("wgts_alt") // str (i))])
end do
end if
allocate (eio%tag_weightinfo)
call eio%tag_weightinfo%init (var_str ("weightinfo"), &
[xml_attribute (var_str ("name"))])
allocate (eio%tag_weights)
call eio%tag_weights%init (var_str ("weights"), .true.)
end select
end subroutine eio_lhef_init_tags
@ %def eio_lhef_init_tags
@ Initialize event writing.
<<EIO LHEF: eio lhef: TBP>>=
procedure :: init_out => eio_lhef_init_out
<<EIO LHEF: procedures>>=
subroutine eio_lhef_init_out (eio, sample, data, success, extension)
class(eio_lhef_t), intent(inout) :: eio
type(string_t), intent(in) :: sample
type(string_t), intent(in), optional :: extension
type(event_sample_data_t), intent(in), optional :: data
logical, intent(out), optional :: success
integer :: u, i
call eio%set_splitting (data)
call eio%common_init (sample, data, extension)
write (msg_buffer, "(A,A,A)") "Events: writing to LHEF file '", &
char (eio%filename), "'"
call msg_message ()
eio%writing = .true.
u = eio%unit
open (u, file = char (eio%filename), &
action = "write", status = "replace")
call eio%write_header ()
call heprup_init &
(data%pdg_beam, &
data%energy_beam, &
n_processes = data%n_proc, &
unweighted = data%unweighted, &
negative_weights = data%negative_weights)
do i = 1, data%n_proc
call heprup_set_process_parameters (i = i, &
process_id = data%proc_num_id(i), &
cross_section = data%cross_section(i), &
error = data%error(i))
end do
call eio%tag_init%write (u); write (u, *)
call heprup_write_lhef (u)
select case (eio%version)
case ("2.0"); call eio%write_init_20 (data)
case ("3.0"); call eio%write_init_30 (data)
end select
call eio%tag_init%close (u); write (u, *)
if (present (success)) success = .true.
end subroutine eio_lhef_init_out
@ %def eio_lhef_init_out
@ Initialize event reading. First read the LHEF tag and version, then
read the header and skip over its contents, then read the init block.
(We require the opening and closing tags of the init block to be placed
on separate lines without extra stuff.)
For input, we do not (yet?) support split event files.
<<EIO LHEF: eio lhef: TBP>>=
procedure :: init_in => eio_lhef_init_in
<<EIO LHEF: procedures>>=
subroutine eio_lhef_init_in (eio, sample, data, success, extension)
class(eio_lhef_t), intent(inout) :: eio
type(string_t), intent(in) :: sample
type(string_t), intent(in), optional :: extension
type(event_sample_data_t), intent(inout), optional :: data
logical, intent(out), optional :: success
logical :: exist, ok, closing
type(event_sample_data_t) :: data_file
type(string_t) :: string
integer :: u
eio%split = .false.
call eio%common_init (sample, data, extension)
write (msg_buffer, "(A,A,A)") "Events: reading from LHEF file '", &
char (eio%filename), "'"
call msg_message ()
inquire (file = char (eio%filename), exist = exist)
if (.not. exist) call msg_fatal ("Events: LHEF file not found.")
eio%reading = .true.
u = eio%unit
open (u, file = char (eio%filename), &
action = "read", status = "old")
call eio%cstream%init (u)
call eio%read_header ()
call eio%tag_init%read (eio%cstream, ok)
if (.not. ok) call err_init
select case (eio%version)
case ("1.0"); call eio%read_init_10 (data_file)
call eio%tag_init%read_content (eio%cstream, string, closing)
if (string /= "" .or. .not. closing) call err_init
case ("2.0"); call eio%read_init_20 (data_file)
case ("3.0"); call eio%read_init_30 (data_file)
end select
call eio%merge_data (data, data_file)
if (present (success)) success = .true.
contains
subroutine err_init
call msg_fatal ("LHEF: syntax error in init tag")
end subroutine err_init
end subroutine eio_lhef_init_in
@ %def eio_lhef_init_in
@ Merge event sample data: we can check the data in the file against
our assumptions and set or reset parameters.
<<EIO LHEF: eio lhef: TBP>>=
procedure :: merge_data => eio_merge_data
<<EIO LHEF: procedures>>=
subroutine eio_merge_data (eio, data, data_file)
class(eio_lhef_t), intent(inout) :: eio
type(event_sample_data_t), intent(inout) :: data
type(event_sample_data_t), intent(in) :: data_file
real, parameter :: tolerance = 1000 * epsilon (1._default)
if (data%unweighted .neqv. data_file%unweighted) call err_weights
if (data%negative_weights .neqv. data_file%negative_weights) &
call err_weights
if (data%norm_mode /= data_file%norm_mode) call err_norm
if (data%n_beam /= data_file%n_beam) call err_beams
if (any (data%pdg_beam /= data_file%pdg_beam)) call err_beams
if (any (abs ((data%energy_beam - data_file%energy_beam)) &
> (data%energy_beam + data_file%energy_beam) * tolerance)) &
call err_beams
if (data%n_proc /= data_file%n_proc) call err_proc
if (any (data%proc_num_id /= data_file%proc_num_id)) call err_proc
where (data%cross_section == 0)
data%cross_section = data_file%cross_section
data%error = data_file%error
end where
data%total_cross_section = sum (data%cross_section)
if (data_file%n_evt > 0) then
if (data%n_evt > 0 .and. data_file%n_evt /= data%n_evt) call err_n_evt
data%n_evt = data_file%n_evt
end if
contains
subroutine err_weights
call msg_fatal ("LHEF: mismatch in event weight properties")
end subroutine err_weights
subroutine err_norm
call msg_fatal ("LHEF: mismatch in event normalization")
end subroutine err_norm
subroutine err_beams
call msg_fatal ("LHEF: mismatch in beam properties")
end subroutine err_beams
subroutine err_proc
call msg_fatal ("LHEF: mismatch in process definitions")
end subroutine err_proc
subroutine err_n_evt
call msg_error ("LHEF: mismatch in specified number of events (ignored)")
end subroutine err_n_evt
end subroutine eio_merge_data
@ %def eio_merge_data
@ Switch from input to output: reopen the file for reading.
<<EIO LHEF: eio lhef: TBP>>=
procedure :: switch_inout => eio_lhef_switch_inout
<<EIO LHEF: procedures>>=
subroutine eio_lhef_switch_inout (eio, success)
class(eio_lhef_t), intent(inout) :: eio
logical, intent(out), optional :: success
call msg_bug ("LHEF: in-out switch not supported")
if (present (success)) success = .false.
end subroutine eio_lhef_switch_inout
@ %def eio_lhef_switch_inout
@ Split event file: increment the counter, close the current file, open a new
one. If the file needs a header, repeat it for the new file. (We assume that
the common block contents are still intact.)
<<EIO LHEF: eio lhef: TBP>>=
procedure :: split_out => eio_lhef_split_out
<<EIO LHEF: procedures>>=
subroutine eio_lhef_split_out (eio)
class(eio_lhef_t), intent(inout) :: eio
integer :: u
if (eio%split) then
eio%split_index = eio%split_index + 1
call eio%set_filename ()
write (msg_buffer, "(A,A,A)") "Events: writing to LHEF file '", &
char (eio%filename), "'"
call msg_message ()
call eio%write_footer ()
u = eio%unit
close (u)
open (u, file = char (eio%filename), &
action = "write", status = "replace")
call eio%write_header ()
call eio%tag_init%write (u); write (u, *)
call heprup_write_lhef (u)
select case (eio%version)
case ("2.0"); call eio%write_init_20 (eio%data)
case ("3.0"); call eio%write_init_30 (eio%data)
end select
call eio%tag_init%close (u); write (u, *)
end if
end subroutine eio_lhef_split_out
@ %def eio_lhef_split_out
@ Output an event. Write first the event indices, then weight and
squared matrix element, then the particle set.
<<EIO LHEF: eio lhef: TBP>>=
procedure :: output => eio_lhef_output
<<EIO LHEF: procedures>>=
subroutine eio_lhef_output &
(eio, event, i_prc, reading, passed, pacify, event_handle)
class(eio_lhef_t), intent(inout) :: eio
class(generic_event_t), intent(in), target :: event
integer, intent(in) :: i_prc
logical, intent(in), optional :: reading, passed, pacify
class(event_handle_t), intent(inout), optional :: event_handle
integer :: u
u = given_output_unit (eio%unit); if (u < 0) return
if (present (passed)) then
if (.not. passed) return
end if
if (eio%writing) then
call hepeup_from_event (event, &
process_index = eio%proc_num_id (i_prc), &
keep_beams = eio%keep_beams, &
keep_remnants = eio%keep_remnants)
write (u, '(A)') "<event>"
call hepeup_write_lhef (eio%unit)
select case (eio%version)
case ("2.0"); call eio%write_event_20 (event)
case ("3.0"); call eio%write_event_30 (event)
end select
write (u, '(A)') "</event>"
else
call eio%write ()
call msg_fatal ("LHEF file is not open for writing")
end if
end subroutine eio_lhef_output
@ %def eio_lhef_output
@ Input an event. Upon input of [[i_prc]], we can just read in the
whole HEPEUP common block. These data are known to come first. The
[[i_prc]] value can be deduced from the IDPRUP value by a table
lookup.
Reading the common block bypasses the [[cstream]] which accesses the
input unit. This is consistent with the LHEF specification. After
the common-block data have been swallowed, we can resume reading from
stream.
We don't catch actual I/O errors. However, we return a negative value in
[[iostat]] if we reached the terminating [[</LesHouchesEvents>]] tag.
<<EIO LHEF: eio lhef: TBP>>=
procedure :: input_i_prc => eio_lhef_input_i_prc
<<EIO LHEF: procedures>>=
subroutine eio_lhef_input_i_prc (eio, i_prc, iostat)
class(eio_lhef_t), intent(inout) :: eio
integer, intent(out) :: i_prc
integer, intent(out) :: iostat
integer :: i, proc_num_id
type(string_t) :: s
logical :: ok
iostat = 0
call eio%tag_lhef%read_content (eio%cstream, s, ok)
if (ok) then
if (s == "") then
iostat = -1
else
call err_close
end if
return
else
call eio%cstream%revert_record (s)
end if
call eio%tag_event%read (eio%cstream, ok)
if (.not. ok) then
call err_evt1
return
end if
call hepeup_read_lhef (eio%unit)
call hepeup_get_event_parameters (proc_id = proc_num_id)
i_prc = 0
FIND_I_PRC: do i = 1, size (eio%proc_num_id)
if (eio%proc_num_id(i) == proc_num_id) then
i_prc = i
exit FIND_I_PRC
end if
end do FIND_I_PRC
if (i_prc == 0) call err_index
contains
subroutine err_close
call msg_error ("LHEF: reading events: syntax error in closing tag")
iostat = 1
end subroutine
subroutine err_evt1
call msg_error ("LHEF: reading events: invalid event tag, &
&aborting read")
iostat = 2
end subroutine err_evt1
subroutine err_index
call msg_error ("LHEF: reading events: undefined process ID " &
// char (str (proc_num_id)) // ", aborting read")
iostat = 3
end subroutine err_index
end subroutine eio_lhef_input_i_prc
@ %def eio_lhef_input_i_prc
@ Since we have already read the event information from file, this
input routine can transfer the common-block contents to the event
record. Also, we read any further information in the event record.
Since LHEF doesn't give this information, we must assume that the MCI
group, term, and channel can all be safely set to 1. This works if
there is only one MCI group and term. The channel doesn't matter for
the matrix element.
The event index is incremented, as if the event was generated. The
LHEF format does not support event indices.
<<EIO LHEF: eio lhef: TBP>>=
procedure :: input_event => eio_lhef_input_event
<<EIO LHEF: procedures>>=
subroutine eio_lhef_input_event (eio, event, iostat, event_handle)
class(eio_lhef_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
type(string_t) :: s
logical :: closing
iostat = 0
call event%reset_contents ()
call event%select (1, 1, 1)
call hepeup_to_event (event, eio%fallback_model, &
recover_beams = eio%recover_beams, &
use_alpha_s = eio%use_alphas_from_file, &
use_scale = eio%use_scale_from_file)
select case (eio%version)
case ("1.0")
call eio%tag_event%read_content (eio%cstream, s, closing = closing)
if (s /= "" .or. .not. closing) call err_evt2
case ("2.0"); call eio%read_event_20 (event)
case ("3.0"); call eio%read_event_30 (event)
end select
call event%increment_index ()
contains
subroutine err_evt2
call msg_error ("LHEF: reading events: syntax error in event record, &
&aborting read")
iostat = 2
end subroutine err_evt2
end subroutine eio_lhef_input_event
@ %def eio_lhef_input_event
@
<<EIO LHEF: eio lhef: TBP>>=
procedure :: skip => eio_lhef_skip
<<EIO LHEF: procedures>>=
subroutine eio_lhef_skip (eio, iostat)
class(eio_lhef_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_lhef_skip
@ %def eio_lhef_skip
@
\subsection{Les Houches Event File: header/footer}
These two routines write the header and footer for the Les Houches
Event File format (LHEF).
The current version writes no information except for the generator
name and version (v.1.0 only).
<<EIO LHEF: eio lhef: TBP>>=
procedure :: write_header => eio_lhef_write_header
procedure :: write_footer => eio_lhef_write_footer
<<EIO LHEF: procedures>>=
subroutine eio_lhef_write_header (eio)
class(eio_lhef_t), intent(in) :: eio
integer :: u
u = given_output_unit (eio%unit); if (u < 0) return
call eio%tag_lhef%write (u); write (u, *)
call eio%tag_head%write (u); write (u, *)
select case (eio%version)
case ("1.0")
write (u, "(2x)", advance = "no")
call eio%tag_gen_n%write (var_str ("WHIZARD"), u)
write (u, *)
write (u, "(2x)", advance = "no")
call eio%tag_gen_v%write (var_str ("<<Version>>"), u)
write (u, *)
end select
call eio%tag_head%close (u); write (u, *)
end subroutine eio_lhef_write_header
subroutine eio_lhef_write_footer (eio)
class(eio_lhef_t), intent(in) :: eio
integer :: u
u = given_output_unit (eio%unit); if (u < 0) return
call eio%tag_lhef%close (u)
end subroutine eio_lhef_write_footer
@ %def eio_lhef_write_header eio_lhef_write_footer
@ Reading the header just means finding the tags and ignoring any
contents. When done, we should stand just after the header tag.
<<EIO LHEF: eio lhef: TBP>>=
procedure :: read_header => eio_lhef_read_header
<<EIO LHEF: procedures>>=
subroutine eio_lhef_read_header (eio)
class(eio_lhef_t), intent(inout) :: eio
logical :: success, closing
type(string_t) :: content
call eio%tag_lhef%read (eio%cstream, success)
if (.not. success .or. .not. eio%tag_lhef%has_content) call err_lhef
if (eio%tag_lhef%get_attribute (1) /= eio%version) call err_version
call eio%tag_head%read (eio%cstream, success)
if (.not. success) call err_header
if (eio%tag_head%has_content) then
SKIP_HEADER_CONTENT: do
call eio%tag_head%read_content (eio%cstream, content, closing)
if (closing) exit SKIP_HEADER_CONTENT
end do SKIP_HEADER_CONTENT
end if
contains
subroutine err_lhef
call msg_fatal ("LHEF: LesHouchesEvents tag absent or corrupted")
end subroutine err_lhef
subroutine err_header
call msg_fatal ("LHEF: header tag absent or corrupted")
end subroutine err_header
subroutine err_version
call msg_error ("LHEF: version mismatch: expected " &
// eio%version // ", found " &
// char (eio%tag_lhef%get_attribute (1)))
end subroutine err_version
end subroutine eio_lhef_read_header
@ %def eio_lhef_read_header
@
\subsection{Version-Specific Code: 1.0}
In version 1.0, the init tag contains just HEPRUP data. While a
[[cstream]] is connected to the input unit, we bypass it temporarily
for the purpose of reading the HEPRUP contents. This is consistent
with the LHEF standard.
This routine does not read the closing tag of the init block.
<<EIO LHEF: eio lhef: TBP>>=
procedure :: read_init_10 => eio_lhef_read_init_10
<<EIO LHEF: procedures>>=
subroutine eio_lhef_read_init_10 (eio, data)
class(eio_lhef_t), intent(in) :: eio
type(event_sample_data_t), intent(out) :: data
integer :: n_proc, i
call heprup_read_lhef (eio%unit)
call heprup_get_run_parameters (n_processes = n_proc)
call data%init (n_proc)
data%n_beam = 2
call heprup_get_run_parameters ( &
unweighted = data%unweighted, &
negative_weights = data%negative_weights, &
beam_pdg = data%pdg_beam, &
beam_energy = data%energy_beam)
if (data%unweighted) then
data%norm_mode = NORM_UNIT
else
data%norm_mode = NORM_SIGMA
end if
do i = 1, n_proc
call heprup_get_process_parameters (i, &
process_id = data%proc_num_id(i), &
cross_section = data%cross_section(i), &
error = data%error(i))
end do
end subroutine eio_lhef_read_init_10
@ %def eio_lhef_read_init_10
@
\subsection{Version-Specific Code: 2.0}
This is the init information for the 2.0 format, after the HEPRUP
data. We have the following tags:
\begin{itemize}
\item \texttt{generator} Generator name and version.
\item \texttt{xsecinfo} Cross section and weights data. We have the
total cross section and number of events (assuming that the event
file is intact), but information on minimum and maximum weights is
not available before the file is complete. We just write the
mandatory tags. (Note that the default values of the other tags
describe a uniform unit weight, but we can determine most values
only after the sample is complete.)
\item \texttt{cutsinfo} This optional tag is too specific to represent the
possibilities of WHIZARD, so we skip it.
\item \texttt{procinfo} This optional tag is useful for giving
details of NLO calculations. Skipped.
\item \texttt{mergetype} Optional, also not applicable.
\end{itemize}
<<EIO LHEF: eio lhef: TBP>>=
procedure :: write_init_20 => eio_lhef_write_init_20
<<EIO LHEF: procedures>>=
subroutine eio_lhef_write_init_20 (eio, data)
class(eio_lhef_t), intent(in) :: eio
type(event_sample_data_t), intent(in) :: data
integer :: u
u = eio%unit
call eio%tag_generator%write (u)
write (u, "(A)", advance="no") "WHIZARD"
call eio%tag_generator%close (u); write (u, *)
call eio%tag_xsecinfo%write (u); write (u, *)
end subroutine eio_lhef_write_init_20
@ %def eio_lhef_write_init_20
@ When reading the init block, we first call the 1.0 routine that
fills HEPRUP. Then we consider the possible tags. Only the
\texttt{generator} and \texttt{xsecinfo} tags are of interest. We
skip everything else except for the closing tag.
<<EIO LHEF: eio lhef: TBP>>=
procedure :: read_init_20 => eio_lhef_read_init_20
<<EIO LHEF: procedures>>=
subroutine eio_lhef_read_init_20 (eio, data)
class(eio_lhef_t), intent(inout) :: eio
type(event_sample_data_t), intent(out) :: data
real(default), parameter :: pb_per_fb = 1.e-3_default
type(string_t) :: content
logical :: found, closing
call eio_lhef_read_init_10 (eio, data)
SCAN_INIT_TAGS: do
call eio%tag_generator%read (eio%cstream, found)
if (found) then
if (.not. eio%tag_generator%has_content) call err_generator
call eio%tag_generator%read_content (eio%cstream, content, closing)
call msg_message ("LHEF: Event file has been generated by " &
// char (content) // " " &
// char (eio%tag_generator%get_attribute (1)))
cycle SCAN_INIT_TAGS
end if
call eio%tag_xsecinfo%read (eio%cstream, found)
if (found) then
if (eio%tag_xsecinfo%has_content) call err_xsecinfo
cycle SCAN_INIT_TAGS
end if
call eio%tag_init%read_content (eio%cstream, content, closing)
if (closing) then
if (content /= "") call err_init
exit SCAN_INIT_TAGS
end if
end do SCAN_INIT_TAGS
data%n_evt = &
read_ival (eio%tag_xsecinfo%get_attribute (1))
data%total_cross_section = &
read_rval (eio%tag_xsecinfo%get_attribute (2)) / pb_per_fb
contains
subroutine err_generator
call msg_fatal ("LHEF: invalid generator tag")
end subroutine err_generator
subroutine err_xsecinfo
call msg_fatal ("LHEF: invalid xsecinfo tag")
end subroutine err_xsecinfo
subroutine err_init
call msg_fatal ("LHEF: syntax error after init tag")
end subroutine err_init
end subroutine eio_lhef_read_init_20
@ %def eio_lhef_read_init_20
@ This is additional event-specific information for the 2.0 format,
after the HEPEUP data. We can specify weights, starting from the
master weight and adding alternative weights. The alternative weights
are collected in a common tag.
<<EIO LHEF: eio lhef: TBP>>=
procedure :: write_event_20 => eio_lhef_write_event_20
<<EIO LHEF: procedures>>=
subroutine eio_lhef_write_event_20 (eio, event)
class(eio_lhef_t), intent(in) :: eio
class(generic_event_t), intent(in) :: event
type(string_t) :: s
integer :: i, u
u = eio%unit
if (eio%write_sqme_ref) then
s = str (event%get_sqme_ref ())
call eio%tag_sqme_ref%write (s, u); write (u, *)
end if
if (eio%write_sqme_prc) then
s = str (event%get_sqme_prc ())
call eio%tag_sqme_prc%write (s, u); write (u, *)
end if
if (eio%n_alt > 0) then
if (eio%write_sqme_alt) then
s = str (event%get_sqme_alt(1))
do i = 2, eio%n_alt
s = s // " " // str (event%get_sqme_alt(i)); write (u, *)
end do
call eio%tag_sqme_alt(1)%write (s, u)
end if
s = str (event%get_weight_alt(1))
do i = 2, eio%n_alt
s = s // " " // str (event%get_weight_alt(i)); write (u, *)
end do
call eio%tag_wgts_alt(1)%write (s, u)
end if
end subroutine eio_lhef_write_event_20
@ %def eio_lhef_write_event_20
@ Read extra event data. If there is a weight entry labeled [[sqme_prc]], we
take this as the squared matrix-element value (the new
\emph{reference} value [[sqme_ref]]). Other tags, including
tags written by the above writer, are skipped.
<<EIO LHEF: eio lhef: TBP>>=
procedure :: read_event_20 => eio_lhef_read_event_20
<<EIO LHEF: procedures>>=
subroutine eio_lhef_read_event_20 (eio, event)
class(eio_lhef_t), intent(inout) :: eio
class(generic_event_t), intent(inout) :: event
type(string_t) :: content
logical :: found, closing
SCAN_EVENT_TAGS: do
call eio%tag_weight%read (eio%cstream, found)
if (found) then
if (.not. eio%tag_weight%has_content) call err_weight
call eio%tag_weight%read_content (eio%cstream, content, closing)
if (.not. closing) call err_weight
if (eio%tag_weight%get_attribute (1) == "sqme_prc") then
call event%set_sqme_ref (read_rval (content))
end if
cycle SCAN_EVENT_TAGS
end if
call eio%tag_event%read_content (eio%cstream, content, closing)
if (closing) then
if (content /= "") call err_event
exit SCAN_EVENT_TAGS
end if
end do SCAN_EVENT_TAGS
contains
subroutine err_weight
call msg_fatal ("LHEF: invalid weight tag in event record")
end subroutine err_weight
subroutine err_event
call msg_fatal ("LHEF: syntax error after event tag")
end subroutine err_event
end subroutine eio_lhef_read_event_20
@ %def eio_lhef_read_event_20
@
\subsection{Version-Specific Code: 3.0}
This is the init information for the 3.0 format, after the HEPRUP
data. We have the following tags:
\begin{itemize}
\item \texttt{generator} Generator name and version.
\item \texttt{xsecinfo} Cross section and weights data. We have the
total cross section and number of events (assuming that the event
file is intact), but information on minimum and maximum weights is
not available before the file is complete. We just write the
mandatory tags. (Note that the default values of the other tags
describe a uniform unit weight, but we can determine most values
only after the sample is complete.)
\item \texttt{cutsinfo} This optional tag is too specific to represent the
possibilities of WHIZARD, so we skip it.
\item \texttt{procinfo} This optional tag is useful for giving
details of NLO calculations. Skipped.
\item \texttt{weightinfo} Determine the meaning of optional weights, whose
values are given in the event record.
\end{itemize}
<<EIO LHEF: eio lhef: TBP>>=
procedure :: write_init_30 => eio_lhef_write_init_30
<<EIO LHEF: procedures>>=
subroutine eio_lhef_write_init_30 (eio, data)
class(eio_lhef_t), intent(in) :: eio
type(event_sample_data_t), intent(in) :: data
integer :: u, i
u = given_output_unit (eio%unit)
call eio%tag_generator%write (u)
write (u, "(A)", advance="no") "WHIZARD"
call eiO%tag_generator%close (u); write (u, *)
call eio%tag_xsecinfo%write (u); write (u, *)
if (eio%write_sqme_ref) then
call eio%tag_sqme_ref%write (u); write (u, *)
end if
if (eio%write_sqme_prc) then
call eio%tag_sqme_prc%write (u); write (u, *)
end if
if (eio%write_sqme_alt) then
do i = 1, eio%n_alt
call eio%tag_sqme_alt(i)%write (u); write (u, *)
end do
end if
do i = 1, eio%n_alt
call eio%tag_wgts_alt(i)%write (u); write (u, *)
end do
end subroutine eio_lhef_write_init_30
@ %def eio_lhef_write_init_30
@ When reading the init block, we first call the 1.0 routine that
fills HEPRUP. Then we consider the possible tags. Only the
\texttt{generator} and \texttt{xsecinfo} tags are of interest. We
skip everything else except for the closing tag.
<<EIO LHEF: eio lhef: TBP>>=
procedure :: read_init_30 => eio_lhef_read_init_30
<<EIO LHEF: procedures>>=
subroutine eio_lhef_read_init_30 (eio, data)
class(eio_lhef_t), intent(inout) :: eio
type(event_sample_data_t), intent(out) :: data
real(default), parameter :: pb_per_fb = 1.e-3_default
type(string_t) :: content
logical :: found, closing
integer :: n_weightinfo
call eio_lhef_read_init_10 (eio, data)
n_weightinfo = 0
eio%i_weight_sqme = 0
SCAN_INIT_TAGS: do
call eio%tag_generator%read (eio%cstream, found)
if (found) then
if (.not. eio%tag_generator%has_content) call err_generator
call eio%tag_generator%read_content (eio%cstream, content, closing)
call msg_message ("LHEF: Event file has been generated by " &
// char (content) // " " &
// char (eio%tag_generator%get_attribute (1)))
cycle SCAN_INIT_TAGS
end if
call eio%tag_xsecinfo%read (eio%cstream, found)
if (found) then
if (eio%tag_xsecinfo%has_content) call err_xsecinfo
cycle SCAN_INIT_TAGS
end if
call eio%tag_weightinfo%read (eio%cstream, found)
if (found) then
if (eio%tag_weightinfo%has_content) call err_xsecinfo
n_weightinfo = n_weightinfo + 1
if (eio%tag_weightinfo%get_attribute (1) == "sqme_prc") then
eio%i_weight_sqme = n_weightinfo
end if
cycle SCAN_INIT_TAGS
end if
call eio%tag_init%read_content (eio%cstream, content, closing)
if (closing) then
if (content /= "") call err_init
exit SCAN_INIT_TAGS
end if
end do SCAN_INIT_TAGS
data%n_evt = &
read_ival (eio%tag_xsecinfo%get_attribute (1))
data%total_cross_section = &
read_rval (eio%tag_xsecinfo%get_attribute (2)) / pb_per_fb
contains
subroutine err_generator
call msg_fatal ("LHEF: invalid generator tag")
end subroutine err_generator
subroutine err_xsecinfo
call msg_fatal ("LHEF: invalid xsecinfo tag")
end subroutine err_xsecinfo
subroutine err_init
call msg_fatal ("LHEF: syntax error after init tag")
end subroutine err_init
end subroutine eio_lhef_read_init_30
@ %def eio_lhef_read_init_30
@ This is additional event-specific information for the 3.0 format,
after the HEPEUP data. We can specify weights, starting from the
master weight and adding alternative weights. The weight tags are
already allocated, so we just have to transfer the weight values to
strings, assemble them and write them to file. All weights are
collected in a single tag.
Note: If efficiency turns out to be an issue, we may revert to
traditional character buffer writing. However, we need to know the
maximum length.
<<EIO LHEF: eio lhef: TBP>>=
procedure :: write_event_30 => eio_lhef_write_event_30
<<EIO LHEF: procedures>>=
subroutine eio_lhef_write_event_30 (eio, event)
class(eio_lhef_t), intent(in) :: eio
class(generic_event_t), intent(in) :: event
type(string_t) :: s
integer :: u, i
u = eio%unit
s = ""
if (eio%write_sqme_ref) then
s = s // str (event%get_sqme_ref ()) // " "
end if
if (eio%write_sqme_prc) then
s = s // str (event%get_sqme_prc ()) // " "
end if
if (eio%n_alt > 0) then
if (eio%write_sqme_alt) then
s = s // str (event%get_sqme_alt(1)) // " "
do i = 2, eio%n_alt
s = s // str (event%get_sqme_alt(i)) // " "
end do
end if
s = s // str (event%get_weight_alt(1)) // " "
do i = 2, eio%n_alt
s = s // str (event%get_weight_alt(i)) // " "
end do
end if
if (len_trim (s) > 0) then
call eio%tag_weights%write (trim (s), u); write (u, *)
end if
end subroutine eio_lhef_write_event_30
@ %def eio_lhef_write_event_30
@ Read extra event data. If there is a [[weights]] tag and if there
was a [[weightinfo]] entry labeled [[sqme_prc]], we extract the
corresponding entry from the weights string and store this as the
event's squared matrix-element value. Other tags, including
tags written by the above writer, are skipped.
<<EIO LHEF: eio lhef: TBP>>=
procedure :: read_event_30 => eio_lhef_read_event_30
<<EIO LHEF: procedures>>=
subroutine eio_lhef_read_event_30 (eio, event)
class(eio_lhef_t), intent(inout) :: eio
class(generic_event_t), intent(inout) :: event
type(string_t) :: content, string
logical :: found, closing
integer :: i
SCAN_EVENT_TAGS: do
call eio%tag_weights%read (eio%cstream, found)
if (found) then
if (.not. eio%tag_weights%has_content) call err_weights
call eio%tag_weights%read_content (eio%cstream, content, closing)
if (.not. closing) call err_weights
if (eio%i_weight_sqme > 0) then
SCAN_WEIGHTS: do i = 1, eio%i_weight_sqme
call split (content, string, " ")
content = adjustl (content)
if (i == eio%i_weight_sqme) then
call event%set_sqme_ref (read_rval (string))
exit SCAN_WEIGHTS
end if
end do SCAN_WEIGHTS
end if
cycle SCAN_EVENT_TAGS
end if
call eio%tag_event%read_content (eio%cstream, content, closing)
if (closing) then
if (content /= "") call err_event
exit SCAN_EVENT_TAGS
end if
end do SCAN_EVENT_TAGS
contains
subroutine err_weights
call msg_fatal ("LHEF: invalid weights tag in event record")
end subroutine err_weights
subroutine err_event
call msg_fatal ("LHEF: syntax error after event tag")
end subroutine err_event
end subroutine eio_lhef_read_event_30
@ %def eio_lhef_read_event_30
@
\subsection{Unit tests}
Test module, followed by the corresponding implementation module.
<<[[eio_lhef_ut.f90]]>>=
<<File header>>
module eio_lhef_ut
use unit_tests
use eio_lhef_uti
<<Standard module head>>
<<EIO LHEF: public test>>
contains
<<EIO LHEF: test driver>>
end module eio_lhef_ut
@ %def eio_lhef_ut
@
<<[[eio_lhef_uti.f90]]>>=
<<File header>>
module eio_lhef_uti
<<Use kinds>>
<<Use strings>>
use io_units
use model_data
use event_base
use eio_data
use eio_base
use eio_lhef
use eio_base_ut, only: eio_prepare_test, eio_cleanup_test
use eio_base_ut, only: eio_prepare_fallback_model, eio_cleanup_fallback_model
<<Standard module head>>
<<EIO LHEF: test declarations>>
contains
<<EIO LHEF: tests>>
end module eio_lhef_uti
@ %def eio_lhef_ut
@ API: driver for the unit tests below.
<<EIO LHEF: public test>>=
public :: eio_lhef_test
<<EIO LHEF: test driver>>=
subroutine eio_lhef_test (u, results)
integer, intent(in) :: u
type(test_results_t), intent(inout) :: results
<<EIO LHEF: execute tests>>
end subroutine eio_lhef_test
@ %def eio_lhef_test
@
\subsubsection{Version 1.0 Output}
We test the implementation of all I/O methods. We start with output
according to version 1.0.
<<EIO LHEF: execute tests>>=
call test (eio_lhef_1, "eio_lhef_1", &
"write version 1.0", &
u, results)
<<EIO LHEF: test declarations>>=
public :: eio_lhef_1
<<EIO LHEF: tests>>=
subroutine eio_lhef_1 (u)
integer, intent(in) :: u
class(generic_event_t), pointer :: event
type(event_sample_data_t) :: data
class(eio_t), allocatable :: eio
type(string_t) :: sample
integer :: u_file, iostat
character(80) :: buffer
write (u, "(A)") "* Test output: eio_lhef_1"
write (u, "(A)") "* Purpose: generate an event and write weight to file"
write (u, "(A)")
write (u, "(A)") "* Initialize test process"
call eio_prepare_test (event, unweighted = .false.)
call data%init (1)
data%n_evt = 1
data%n_beam = 2
data%unweighted = .true.
data%norm_mode = NORM_UNIT
data%pdg_beam = 25
data%energy_beam = 500
data%proc_num_id = [42]
data%cross_section(1) = 100
data%error(1) = 1
data%total_cross_section = sum (data%cross_section)
write (u, "(A)")
write (u, "(A)") "* Generate and write an event"
write (u, "(A)")
sample = "eio_lhef_1"
allocate (eio_lhef_t :: eio)
select type (eio)
type is (eio_lhef_t)
call eio%set_parameters ()
end select
call eio%init_out (sample, data)
call event%generate (1, [0._default, 0._default])
call eio%output (event, i_prc = 1)
call eio%write (u)
call eio%final ()
write (u, "(A)")
write (u, "(A)") "* File contents:"
write (u, "(A)")
u_file = free_unit ()
open (u_file, file = char (sample // "." // eio%extension), &
action = "read", status = "old")
do
read (u_file, "(A)", iostat = iostat) buffer
if (buffer(1:21) == " <generator_version>") buffer = "[...]"
if (iostat /= 0) exit
write (u, "(A)") trim (buffer)
end do
close (u_file)
write (u, "(A)")
write (u, "(A)") "* Reset data"
write (u, "(A)")
deallocate (eio)
allocate (eio_lhef_t :: eio)
select type (eio)
type is (eio_lhef_t)
call eio%set_parameters ()
end select
select type (eio)
type is (eio_lhef_t)
call eio%set_parameters (keep_beams = .true.)
end select
call eio%write (u)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call eio_cleanup_test (event)
write (u, "(A)")
write (u, "(A)") "* Test output end: eio_lhef_1"
end subroutine eio_lhef_1
@ %def eio_lhef_1
@
\subsubsection{Version 2.0 Output}
Version 2.0 has added a lot of options to the LHEF format. We
implement some of them.
<<EIO LHEF: execute tests>>=
call test (eio_lhef_2, "eio_lhef_2", &
"write version 2.0", &
u, results)
<<EIO LHEF: test declarations>>=
public :: eio_lhef_2
<<EIO LHEF: tests>>=
subroutine eio_lhef_2 (u)
integer, intent(in) :: u
class(generic_event_t), pointer :: event
type(event_sample_data_t) :: data
class(eio_t), allocatable :: eio
type(string_t) :: sample
integer :: u_file, iostat
character(80) :: buffer
write (u, "(A)") "* Test output: eio_lhef_2"
write (u, "(A)") "* Purpose: generate an event and write weight to file"
write (u, "(A)")
write (u, "(A)") "* Initialize test process"
call eio_prepare_test (event, unweighted = .false.)
call data%init (1)
data%unweighted = .false.
data%norm_mode = NORM_SIGMA
data%n_evt = 1
data%n_beam = 2
data%pdg_beam = 25
data%energy_beam = 500
data%proc_num_id = [42]
data%cross_section(1) = 100
data%error(1) = 1
data%total_cross_section = sum (data%cross_section)
write (u, "(A)")
write (u, "(A)") "* Generate and write an event"
write (u, "(A)")
sample = "eio_lhef_2"
allocate (eio_lhef_t :: eio)
select type (eio)
type is (eio_lhef_t)
call eio%set_parameters (version = "2.0", write_sqme_prc = .true.)
end select
call eio%init_out (sample, data)
call event%generate (1, [0._default, 0._default])
call eio%output (event, i_prc = 1)
call eio%write (u)
call eio%final ()
write (u, "(A)")
write (u, "(A)") "* File contents:"
write (u, "(A)")
u_file = free_unit ()
open (u_file, file = char (sample // "." // eio%extension), &
action = "read", status = "old")
do
read (u_file, "(A)", iostat = iostat) buffer
if (buffer(1:10) == "<generator") buffer = "[...]"
if (iostat /= 0) exit
write (u, "(A)") trim (buffer)
end do
close (u_file)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call eio_cleanup_test (event)
write (u, "(A)")
write (u, "(A)") "* Test output end: eio_lhef_2"
end subroutine eio_lhef_2
@ %def eio_lhef_2
@
\subsubsection{Version 3.0 Output}
Version 3.0 is an update which removes some tags (which we didn't use anyway)
and suggests a new treatment of weights.
<<EIO LHEF: execute tests>>=
call test (eio_lhef_3, "eio_lhef_3", &
"write version 3.0", &
u, results)
<<EIO LHEF: test declarations>>=
public :: eio_lhef_3
<<EIO LHEF: tests>>=
subroutine eio_lhef_3 (u)
integer, intent(in) :: u
class(generic_event_t), pointer :: event
type(event_sample_data_t) :: data
class(eio_t), allocatable :: eio
type(string_t) :: sample
integer :: u_file, iostat
character(80) :: buffer
write (u, "(A)") "* Test output: eio_lhef_3"
write (u, "(A)") "* Purpose: generate an event and write weight to file"
write (u, "(A)")
write (u, "(A)") "* Initialize test process"
call eio_prepare_test (event, unweighted = .false.)
call data%init (1)
data%unweighted = .false.
data%norm_mode = NORM_SIGMA
data%n_evt = 1
data%n_beam = 2
data%pdg_beam = 25
data%energy_beam = 500
data%proc_num_id = [42]
data%cross_section(1) = 100
data%error(1) = 1
data%total_cross_section = sum (data%cross_section)
write (u, "(A)")
write (u, "(A)") "* Generate and write an event"
write (u, "(A)")
sample = "eio_lhef_3"
allocate (eio_lhef_t :: eio)
select type (eio)
type is (eio_lhef_t)
call eio%set_parameters (version = "3.0", write_sqme_prc = .true.)
end select
call eio%init_out (sample, data)
call event%generate (1, [0._default, 0._default])
call eio%output (event, i_prc = 1)
call eio%write (u)
call eio%final ()
write (u, "(A)")
write (u, "(A)") "* File contents:"
write (u, "(A)")
u_file = free_unit ()
open (u_file, file = char (sample // ".lhe"), &
action = "read", status = "old")
do
read (u_file, "(A)", iostat = iostat) buffer
if (buffer(1:10) == "<generator") buffer = "[...]"
if (iostat /= 0) exit
write (u, "(A)") trim (buffer)
end do
close (u_file)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call eio_cleanup_test (event)
write (u, "(A)")
write (u, "(A)") "* Test output end: eio_lhef_3"
end subroutine eio_lhef_3
@ %def eio_lhef_3
@
\subsubsection{Version 1.0 Input}
Check input of a version-1.0 conforming LHEF file.
<<EIO LHEF: execute tests>>=
call test (eio_lhef_4, "eio_lhef_4", &
"read version 1.0", &
u, results)
<<EIO LHEF: test declarations>>=
public :: eio_lhef_4
<<EIO LHEF: tests>>=
subroutine eio_lhef_4 (u)
integer, intent(in) :: u
class(model_data_t), pointer :: fallback_model
class(generic_event_t), pointer :: event
type(event_sample_data_t) :: data
class(eio_t), allocatable :: eio
type(string_t) :: sample
integer :: u_file, iostat, i_prc
write (u, "(A)") "* Test output: eio_lhef_4"
write (u, "(A)") "* Purpose: read a LHEF 1.0 file"
write (u, "(A)")
write (u, "(A)") "* Write a LHEF data file"
write (u, "(A)")
u_file = free_unit ()
sample = "eio_lhef_4"
open (u_file, file = char (sample // ".lhe"), &
status = "replace", action = "readwrite")
write (u_file, "(A)") '<LesHouchesEvents version="1.0">'
write (u_file, "(A)") '<header>'
write (u_file, "(A)") ' <arbitrary_tag opt="foo">content</arbitrary_tag>'
write (u_file, "(A)") ' Text'
write (u_file, "(A)") ' <another_tag />'
write (u_file, "(A)") '</header>'
write (u_file, "(A)") '<init>'
write (u_file, "(A)") ' 25 25 5.0000000000E+02 5.0000000000E+02 &
& -1 -1 -1 -1 3 1'
write (u_file, "(A)") ' 1.0000000000E-01 1.0000000000E-03 &
& 1.0000000000E+00 42'
write (u_file, "(A)") '</init>'
write (u_file, "(A)") '<event>'
write (u_file, "(A)") ' 4 42 3.0574068604E+08 1.0000000000E+03 &
& -1.0000000000E+00 -1.0000000000E+00'
write (u_file, "(A)") ' 25 -1 0 0 0 0 0.0000000000E+00 0.0000000000E+00 &
& 4.8412291828E+02 5.0000000000E+02 1.2500000000E+02 &
& 0.0000000000E+00 9.0000000000E+00'
write (u_file, "(A)") ' 25 -1 0 0 0 0 0.0000000000E+00 0.0000000000E+00 &
&-4.8412291828E+02 5.0000000000E+02 1.2500000000E+02 &
& 0.0000000000E+00 9.0000000000E+00'
write (u_file, "(A)") ' 25 1 1 2 0 0 -1.4960220911E+02 -4.6042825611E+02 &
& 0.0000000000E+00 5.0000000000E+02 1.2500000000E+02 &
& 0.0000000000E+00 9.0000000000E+00'
write (u_file, "(A)") ' 25 1 1 2 0 0 1.4960220911E+02 4.6042825611E+02 &
& 0.0000000000E+00 5.0000000000E+02 1.2500000000E+02 &
& 0.0000000000E+00 9.0000000000E+00'
write (u_file, "(A)") '</event>'
write (u_file, "(A)") '</LesHouchesEvents>'
close (u_file)
write (u, "(A)") "* Initialize test process"
write (u, "(A)")
allocate (fallback_model)
call eio_prepare_fallback_model (fallback_model)
call eio_prepare_test (event, unweighted = .false.)
allocate (eio_lhef_t :: eio)
select type (eio)
type is (eio_lhef_t)
call eio%set_parameters (recover_beams = .false.)
end select
call eio%set_fallback_model (fallback_model)
call data%init (1)
data%n_beam = 2
data%unweighted = .true.
data%norm_mode = NORM_UNIT
data%pdg_beam = 25
data%energy_beam = 500
data%proc_num_id = [42]
call data%write (u)
write (u, *)
write (u, "(A)") "* Initialize and read header"
write (u, "(A)")
call eio%init_in (sample, data)
call eio%write (u)
write (u, *)
select type (eio)
type is (eio_lhef_t)
call eio%tag_lhef%write (u); write (u, *)
end select
write (u, *)
call data%write (u)
write (u, "(A)")
write (u, "(A)") "* Read event"
write (u, "(A)")
call eio%input_i_prc (i_prc, iostat)
select type (eio)
type is (eio_lhef_t)
write (u, "(A,I0,A,I0)") "Found process #", i_prc, &
" with ID = ", eio%proc_num_id(i_prc)
end select
call eio%input_event (event, iostat)
call event%write (u)
write (u, "(A)")
write (u, "(A)") "* Read closing"
write (u, "(A)")
call eio%input_i_prc (i_prc, iostat)
write (u, "(A,I0)") "iostat = ", iostat
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call eio%final ()
call eio_cleanup_test (event)
call eio_cleanup_fallback_model (fallback_model)
deallocate (fallback_model)
write (u, "(A)")
write (u, "(A)") "* Test output end: eio_lhef_4"
end subroutine eio_lhef_4
@ %def eio_lhef_4
@
\subsubsection{Version 2.0 Input}
Check input of a version-2.0 conforming LHEF file.
<<EIO LHEF: execute tests>>=
call test (eio_lhef_5, "eio_lhef_5", &
"read version 2.0", &
u, results)
<<EIO LHEF: test declarations>>=
public :: eio_lhef_5
<<EIO LHEF: tests>>=
subroutine eio_lhef_5 (u)
integer, intent(in) :: u
class(model_data_t), pointer :: fallback_model
class(generic_event_t), pointer :: event
type(event_sample_data_t) :: data
class(eio_t), allocatable :: eio
type(string_t) :: sample
integer :: u_file, iostat, i_prc
write (u, "(A)") "* Test output: eio_lhef_5"
write (u, "(A)") "* Purpose: read a LHEF 2.0 file"
write (u, "(A)")
write (u, "(A)") "* Write a LHEF data file"
write (u, "(A)")
u_file = free_unit ()
sample = "eio_lhef_5"
open (u_file, file = char (sample // ".lhe"), &
status = "replace", action = "readwrite")
write (u_file, "(A)") '<LesHouchesEvents version="2.0">'
write (u_file, "(A)") '<header>'
write (u_file, "(A)") '</header>'
write (u_file, "(A)") '<init>'
write (u_file, "(A)") ' 25 25 5.0000000000E+02 5.0000000000E+02 &
&-1 -1 -1 -1 4 1'
write (u_file, "(A)") ' 1.0000000000E-01 1.0000000000E-03 &
& 0.0000000000E+00 42'
write (u_file, "(A)") '<generator version="2.2.3">WHIZARD&
&</generator>'
write (u_file, "(A)") '<xsecinfo neve="1" totxsec="1.0000000000E-01" />'
write (u_file, "(A)") '</init>'
write (u_file, "(A)") '<event>'
write (u_file, "(A)") ' 4 42 3.0574068604E+08 1.0000000000E+03 &
&-1.0000000000E+00 -1.0000000000E+00'
write (u_file, "(A)") ' 25 -1 0 0 0 0 0.0000000000E+00 &
& 0.0000000000E+00 4.8412291828E+02 5.0000000000E+02 &
& 1.2500000000E+02 0.0000000000E+00 9.0000000000E+00'
write (u_file, "(A)") ' 25 -1 0 0 0 0 0.0000000000E+00 &
& 0.0000000000E+00 -4.8412291828E+02 5.0000000000E+02 &
& 1.2500000000E+02 0.0000000000E+00 9.0000000000E+00'
write (u_file, "(A)") ' 25 1 1 2 0 0 -1.4960220911E+02 &
&-4.6042825611E+02 0.0000000000E+00 5.0000000000E+02 &
& 1.2500000000E+02 0.0000000000E+00 9.0000000000E+00'
write (u_file, "(A)") ' 25 1 1 2 0 0 1.4960220911E+02 &
& 4.6042825611E+02 0.0000000000E+00 5.0000000000E+02 &
& 1.2500000000E+02 0.0000000000E+00 9.0000000000E+00'
write (u_file, "(A)") '<weight name="sqme_prc">1.0000000000E+00</weight>'
write (u_file, "(A)") '</event>'
write (u_file, "(A)") '</LesHouchesEvents>'
close (u_file)
write (u, "(A)") "* Initialize test process"
write (u, "(A)")
allocate (fallback_model)
call eio_prepare_fallback_model (fallback_model)
call eio_prepare_test (event, unweighted = .false.)
allocate (eio_lhef_t :: eio)
select type (eio)
type is (eio_lhef_t)
call eio%set_parameters (version = "2.0", recover_beams = .false.)
end select
call eio%set_fallback_model (fallback_model)
call data%init (1)
data%unweighted = .false.
data%norm_mode = NORM_SIGMA
data%n_beam = 2
data%pdg_beam = 25
data%energy_beam = 500
data%proc_num_id = [42]
call data%write (u)
write (u, *)
write (u, "(A)") "* Initialize and read header"
write (u, "(A)")
call eio%init_in (sample, data)
call eio%write (u)
write (u, *)
select type (eio)
type is (eio_lhef_t)
call eio%tag_lhef%write (u); write (u, *)
end select
write (u, *)
call data%write (u)
write (u, "(A)")
write (u, "(A)") "* Read event"
write (u, "(A)")
call eio%input_i_prc (i_prc, iostat)
select type (eio)
type is (eio_lhef_t)
write (u, "(A,I0,A,I0)") "Found process #", i_prc, &
" with ID = ", eio%proc_num_id(i_prc)
end select
call eio%input_event (event, iostat)
call event%write (u)
write (u, "(A)")
write (u, "(A)") "* Read closing"
write (u, "(A)")
call eio%input_i_prc (i_prc, iostat)
write (u, "(A,I0)") "iostat = ", iostat
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call eio%final ()
call eio_cleanup_test (event)
call eio_cleanup_fallback_model (fallback_model)
deallocate (fallback_model)
write (u, "(A)")
write (u, "(A)") "* Test output end: eio_lhef_5"
end subroutine eio_lhef_5
@ %def eio_lhef_5
@
\subsubsection{Version 3.0 Input}
Check input of a version-3.0 conforming LHEF file.
<<EIO LHEF: execute tests>>=
call test (eio_lhef_6, "eio_lhef_6", &
"read version 3.0", &
u, results)
<<EIO LHEF: test declarations>>=
public :: eio_lhef_6
<<EIO LHEF: tests>>=
subroutine eio_lhef_6 (u)
integer, intent(in) :: u
class(model_data_t), pointer :: fallback_model
class(generic_event_t), pointer :: event
type(event_sample_data_t) :: data
class(eio_t), allocatable :: eio
type(string_t) :: sample
integer :: u_file, iostat, i_prc
write (u, "(A)") "* Test output: eio_lhef_6"
write (u, "(A)") "* Purpose: read a LHEF 3.0 file"
write (u, "(A)")
write (u, "(A)") "* Write a LHEF data file"
write (u, "(A)")
u_file = free_unit ()
sample = "eio_lhef_6"
open (u_file, file = char (sample // ".lhe"), &
status = "replace", action = "readwrite")
write (u_file, "(A)") '<LesHouchesEvents version="3.0">'
write (u_file, "(A)") '<header>'
write (u_file, "(A)") '</header>'
write (u_file, "(A)") '<init>'
write (u_file, "(A)") ' 25 25 5.0000000000E+02 5.0000000000E+02 &
&-1 -1 -1 -1 4 1'
write (u_file, "(A)") ' 1.0000000000E-01 1.0000000000E-03 &
& 0.0000000000E+00 42'
write (u_file, "(A)") '<generator version="2.2.3">WHIZARD&
&</generator>'
write (u_file, "(A)") '<xsecinfo neve="1" totxsec="1.0000000000E-01" />'
write (u_file, "(A)") '<weightinfo name="sqme_prc" />'
write (u_file, "(A)") '</init>'
write (u_file, "(A)") '<event>'
write (u_file, "(A)") ' 4 42 3.0574068604E+08 1.0000000000E+03 &
&-1.0000000000E+00 -1.0000000000E+00'
write (u_file, "(A)") ' 25 -1 0 0 0 0 0.0000000000E+00 &
& 0.0000000000E+00 4.8412291828E+02 5.0000000000E+02 &
& 1.2500000000E+02 0.0000000000E+00 9.0000000000E+00'
write (u_file, "(A)") ' 25 -1 0 0 0 0 0.0000000000E+00 &
& 0.0000000000E+00 -4.8412291828E+02 5.0000000000E+02 &
& 1.2500000000E+02 0.0000000000E+00 9.0000000000E+00'
write (u_file, "(A)") ' 25 1 1 2 0 0 -1.4960220911E+02 &
&-4.6042825611E+02 0.0000000000E+00 5.0000000000E+02 &
& 1.2500000000E+02 0.0000000000E+00 9.0000000000E+00'
write (u_file, "(A)") ' 25 1 1 2 0 0 1.4960220911E+02 &
& 4.6042825611E+02 0.0000000000E+00 5.0000000000E+02 &
& 1.2500000000E+02 0.0000000000E+00 9.0000000000E+00'
write (u_file, "(A)") '<weights>1.0000000000E+00</weights>'
write (u_file, "(A)") '</event>'
write (u_file, "(A)") '</LesHouchesEvents>'
close (u_file)
write (u, "(A)") "* Initialize test process"
write (u, "(A)")
allocate (fallback_model)
call eio_prepare_fallback_model (fallback_model)
call eio_prepare_test (event, unweighted = .false.)
allocate (eio_lhef_t :: eio)
select type (eio)
type is (eio_lhef_t)
call eio%set_parameters (version = "3.0", recover_beams = .false.)
end select
call eio%set_fallback_model (fallback_model)
call data%init (1)
data%unweighted = .false.
data%norm_mode = NORM_SIGMA
data%n_beam = 2
data%pdg_beam = 25
data%energy_beam = 500
data%proc_num_id = [42]
call data%write (u)
write (u, *)
write (u, "(A)") "* Initialize and read header"
write (u, "(A)")
call eio%init_in (sample, data)
call eio%write (u)
write (u, *)
select type (eio)
type is (eio_lhef_t)
call eio%tag_lhef%write (u); write (u, *)
end select
write (u, *)
call data%write (u)
write (u, "(A)")
write (u, "(A)") "* Read event"
write (u, "(A)")
call eio%input_i_prc (i_prc, iostat)
select type (eio)
type is (eio_lhef_t)
write (u, "(A,I0,A,I0)") "Found process #", i_prc, &
" with ID = ", eio%proc_num_id(i_prc)
end select
call eio%input_event (event, iostat)
call event%write (u)
write (u, "(A)")
write (u, "(A)") "* Read closing"
write (u, "(A)")
call eio%input_i_prc (i_prc, iostat)
write (u, "(A,I0)") "iostat = ", iostat
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call eio%final ()
call eio_cleanup_test (event)
call eio_cleanup_fallback_model (fallback_model)
deallocate (fallback_model)
write (u, "(A)")
write (u, "(A)") "* Test output end: eio_lhef_6"
end subroutine eio_lhef_6
@ %def eio_lhef_6
@
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{STDHEP File Formats}
Here, we implement the two existing STDHEP file formats, one based on the
HEPRUP/HEPEUP common blocks, the other based on the HEPEVT common block.
The second one is actually the standard STDHEP format.
<<[[eio_stdhep.f90]]>>=
<<File header>>
module eio_stdhep
use kinds, only: i32, i64
<<Use strings>>
use io_units
use string_utils
use diagnostics
use event_base
use event_handles, only: event_handle_t
use hep_common
use hep_events
use eio_data
use eio_base
<<Standard module head>>
<<EIO stdhep: public>>
<<EIO stdhep: types>>
<<EIO stdhep: variables>>
contains
<<EIO stdhep: procedures>>
end module eio_stdhep
@ %def eio_stdhep
@
\subsection{Type}
<<EIO stdhep: public>>=
public :: eio_stdhep_t
<<EIO stdhep: types>>=
type, abstract, extends (eio_t) :: eio_stdhep_t
logical :: writing = .false.
logical :: reading = .false.
integer :: unit = 0
logical :: keep_beams = .false.
logical :: keep_remnants = .true.
logical :: ensure_order = .false.
logical :: recover_beams = .false.
logical :: use_alphas_from_file = .false.
logical :: use_scale_from_file = .false.
integer, dimension(:), allocatable :: proc_num_id
integer(i64) :: n_events_expected = 0
contains
<<EIO stdhep: eio stdhep: TBP>>
end type eio_stdhep_t
@ %def eio_stdhep_t
@
<<EIO stdhep: public>>=
public :: eio_stdhep_hepevt_t
<<EIO stdhep: types>>=
type, extends (eio_stdhep_t) :: eio_stdhep_hepevt_t
end type eio_stdhep_hepevt_t
@ %def eio_stdhep_hepevt_t
@
<<EIO stdhep: public>>=
public :: eio_stdhep_hepeup_t
<<EIO stdhep: types>>=
type, extends (eio_stdhep_t) :: eio_stdhep_hepeup_t
end type eio_stdhep_hepeup_t
@ %def eio_stdhep_hepeup_t
@
<<EIO stdhep: public>>=
public :: eio_stdhep_hepev4_t
<<EIO stdhep: types>>=
type, extends (eio_stdhep_t) :: eio_stdhep_hepev4_t
end type eio_stdhep_hepev4_t
@ %def eio_stdhep_hepev4_t
@
\subsection{Specific Methods}
Set parameters that are specifically used with STDHEP file formats.
<<EIO stdhep: eio stdhep: TBP>>=
procedure :: set_parameters => eio_stdhep_set_parameters
<<EIO stdhep: procedures>>=
subroutine eio_stdhep_set_parameters (eio, &
keep_beams, keep_remnants, ensure_order, recover_beams, &
use_alphas_from_file, use_scale_from_file, extension)
class(eio_stdhep_t), intent(inout) :: eio
logical, intent(in), optional :: keep_beams
logical, intent(in), optional :: keep_remnants
logical, intent(in), optional :: ensure_order
logical, intent(in), optional :: recover_beams
logical, intent(in), optional :: use_alphas_from_file
logical, intent(in), optional :: use_scale_from_file
type(string_t), intent(in), optional :: extension
if (present (keep_beams)) eio%keep_beams = keep_beams
if (present (keep_remnants)) eio%keep_remnants = keep_remnants
if (present (ensure_order)) eio%ensure_order = ensure_order
if (present (recover_beams)) eio%recover_beams = recover_beams
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 (extension)) then
eio%extension = extension
else
select type (eio)
type is (eio_stdhep_hepevt_t)
eio%extension = "hep"
type is (eio_stdhep_hepev4_t)
eio%extension = "ev4.hep"
type is (eio_stdhep_hepeup_t)
eio%extension = "up.hep"
end select
end if
end subroutine eio_stdhep_set_parameters
@ %def eio_ascii_stdhep_parameters
@
\subsection{Common Methods}
Output. This is not the actual event format, but a readable account
of the current object status.
<<EIO stdhep: eio stdhep: TBP>>=
procedure :: write => eio_stdhep_write
<<EIO stdhep: procedures>>=
subroutine eio_stdhep_write (object, unit)
class(eio_stdhep_t), intent(in) :: object
integer, intent(in), optional :: unit
integer :: u, i
u = given_output_unit (unit)
write (u, "(1x,A)") "STDHEP event stream:"
if (object%writing) then
write (u, "(3x,A,A)") "Writing to file = ", char (object%filename)
else if (object%reading) then
write (u, "(3x,A,A)") "Reading from file = ", char (object%filename)
else
write (u, "(3x,A)") "[closed]"
end if
write (u, "(3x,A,L1)") "Keep beams = ", object%keep_beams
write (u, "(3x,A,L1)") "Keep remnants = ", object%keep_remnants
write (u, "(3x,A,L1)") "Recover beams = ", object%recover_beams
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
if (allocated (object%proc_num_id)) then
write (u, "(3x,A)") "Numerical process IDs:"
do i = 1, size (object%proc_num_id)
write (u, "(5x,I0,': ',I0)") i, object%proc_num_id(i)
end do
end if
end subroutine eio_stdhep_write
@ %def eio_stdhep_write
@ Finalizer: close any open file.
<<EIO stdhep: eio stdhep: TBP>>=
procedure :: final => eio_stdhep_final
<<EIO stdhep: procedures>>=
subroutine eio_stdhep_final (object)
class(eio_stdhep_t), intent(inout) :: object
if (allocated (object%proc_num_id)) deallocate (object%proc_num_id)
if (object%writing) then
write (msg_buffer, "(A,A,A)") "Events: closing STDHEP file '", &
char (object%filename), "'"
call msg_message ()
call stdhep_write (200)
call stdhep_end ()
object%writing = .false.
else if (object%reading) then
write (msg_buffer, "(A,A,A)") "Events: closing STDHEP file '", &
char (object%filename), "'"
call msg_message ()
object%reading = .false.
end if
end subroutine eio_stdhep_final
@ %def eio_stdhep_final
@ Common initialization for input and output.
<<EIO stdhep: eio stdhep: TBP>>=
procedure :: common_init => eio_stdhep_common_init
<<EIO stdhep: procedures>>=
subroutine eio_stdhep_common_init (eio, sample, data, extension)
class(eio_stdhep_t), intent(inout) :: eio
type(string_t), intent(in) :: sample
type(string_t), intent(in), optional :: extension
type(event_sample_data_t), intent(in), optional :: data
if (.not. present (data)) &
call msg_bug ("STDHEP initialization: missing data")
if (data%n_beam /= 2) &
call msg_fatal ("STDHEP: defined for scattering processes only")
if (present (extension)) then
eio%extension = extension
end if
eio%sample = sample
call eio%set_filename ()
eio%unit = free_unit ()
allocate (eio%proc_num_id (data%n_proc), source = data%proc_num_id)
end subroutine eio_stdhep_common_init
@ %def eio_stdhep_common_init
@ Split event file: increment the counter, close the current file, open a new
one. If the file needs a header, repeat it for the new file. (We assume that
the common block contents are still intact.)
<<EIO stdhep: eio stdhep: TBP>>=
procedure :: split_out => eio_stdhep_split_out
<<EIO stdhep: procedures>>=
subroutine eio_stdhep_split_out (eio)
class(eio_stdhep_t), intent(inout) :: eio
if (eio%split) then
eio%split_index = eio%split_index + 1
call eio%set_filename ()
write (msg_buffer, "(A,A,A)") "Events: writing to STDHEP file '", &
char (eio%filename), "'"
call msg_message ()
call stdhep_write (200)
call stdhep_end ()
select type (eio)
type is (eio_stdhep_hepeup_t)
call stdhep_init_out (char (eio%filename), &
"WHIZARD <<Version>>", eio%n_events_expected)
call stdhep_write (100)
call stdhep_write (STDHEP_HEPRUP)
type is (eio_stdhep_hepevt_t)
call stdhep_init_out (char (eio%filename), &
"WHIZARD <<Version>>", eio%n_events_expected)
call stdhep_write (100)
type is (eio_stdhep_hepev4_t)
call stdhep_init_out (char (eio%filename), &
"WHIZARD <<Version>>", eio%n_events_expected)
call stdhep_write (100)
end select
end if
end subroutine eio_stdhep_split_out
@ %def eio_stdhep_split_out
@ Initialize event writing.
<<EIO stdhep: eio stdhep: TBP>>=
procedure :: init_out => eio_stdhep_init_out
<<EIO stdhep: procedures>>=
subroutine eio_stdhep_init_out (eio, sample, data, success, extension)
class(eio_stdhep_t), intent(inout) :: eio
type(string_t), intent(in) :: sample
type(string_t), intent(in), optional :: extension
type(event_sample_data_t), intent(in), optional :: data
logical, intent(out), optional :: success
integer :: i
if (.not. present (data)) &
call msg_bug ("STDHEP initialization: missing data")
call eio%set_splitting (data)
call eio%common_init (sample, data, extension)
eio%n_events_expected = data%n_evt
write (msg_buffer, "(A,A,A)") "Events: writing to STDHEP file '", &
char (eio%filename), "'"
call msg_message ()
eio%writing = .true.
select type (eio)
type is (eio_stdhep_hepeup_t)
call heprup_init &
(data%pdg_beam, &
data%energy_beam, &
n_processes = data%n_proc, &
unweighted = data%unweighted, &
negative_weights = data%negative_weights)
do i = 1, data%n_proc
call heprup_set_process_parameters (i = i, &
process_id = data%proc_num_id(i), &
cross_section = data%cross_section(i), &
error = data%error(i))
end do
call stdhep_init_out (char (eio%filename), &
"WHIZARD <<Version>>", eio%n_events_expected)
call stdhep_write (100)
call stdhep_write (STDHEP_HEPRUP)
type is (eio_stdhep_hepevt_t)
call stdhep_init_out (char (eio%filename), &
"WHIZARD <<Version>>", eio%n_events_expected)
call stdhep_write (100)
type is (eio_stdhep_hepev4_t)
call stdhep_init_out (char (eio%filename), &
"WHIZARD <<Version>>", eio%n_events_expected)
call stdhep_write (100)
end select
if (present (success)) success = .true.
end subroutine eio_stdhep_init_out
@ %def eio_stdhep_init_out
@ Initialize event reading.
<<EIO stdhep: eio stdhep: TBP>>=
procedure :: init_in => eio_stdhep_init_in
<<EIO stdhep: procedures>>=
subroutine eio_stdhep_init_in (eio, sample, data, success, extension)
class(eio_stdhep_t), intent(inout) :: eio
type(string_t), intent(in) :: sample
type(string_t), intent(in), optional :: extension
type(event_sample_data_t), intent(inout), optional :: data
logical, intent(out), optional :: success
integer :: ilbl, lok
logical :: exist
call eio%common_init (sample, data, extension)
write (msg_buffer, "(A,A,A)") "Events: reading from STDHEP file '", &
char (eio%filename), "'"
call msg_message ()
inquire (file = char (eio%filename), exist = exist)
if (.not. exist) call msg_fatal ("Events: STDHEP file not found.")
eio%reading = .true.
call stdhep_init_in (char (eio%filename), eio%n_events_expected)
call stdhep_read (ilbl, lok)
if (lok /= 0) then
call stdhep_end ()
write (msg_buffer, "(A)") "Events: STDHEP file appears to" // &
" be empty."
call msg_message ()
end if
if (ilbl == 100) then
write (msg_buffer, "(A)") "Events: reading in STDHEP events"
call msg_message ()
end if
if (present (success)) success = .false.
end subroutine eio_stdhep_init_in
@ %def eio_stdhep_init_in
@ Switch from input to output: reopen the file for reading.
<<EIO stdhep: eio stdhep: TBP>>=
procedure :: switch_inout => eio_stdhep_switch_inout
<<EIO stdhep: procedures>>=
subroutine eio_stdhep_switch_inout (eio, success)
class(eio_stdhep_t), intent(inout) :: eio
logical, intent(out), optional :: success
call msg_bug ("STDHEP: in-out switch not supported")
if (present (success)) success = .false.
end subroutine eio_stdhep_switch_inout
@ %def eio_stdhep_switch_inout
@ Output an event. Write first the event indices, then weight and
squared matrix element, then the particle set.
<<EIO stdhep: eio stdhep: TBP>>=
procedure :: output => eio_stdhep_output
<<EIO stdhep: procedures>>=
subroutine eio_stdhep_output &
(eio, event, i_prc, reading, passed, pacify, event_handle)
class(eio_stdhep_t), intent(inout) :: eio
class(generic_event_t), intent(in), target :: event
integer, intent(in) :: i_prc
logical, intent(in), optional :: reading, passed, pacify
class(event_handle_t), intent(inout), optional :: event_handle
if (present (passed)) then
if (.not. passed) return
end if
if (eio%writing) then
select type (eio)
type is (eio_stdhep_hepeup_t)
call hepeup_from_event (event, &
process_index = eio%proc_num_id (i_prc), &
keep_beams = eio%keep_beams, &
keep_remnants = eio%keep_remnants)
call stdhep_write (STDHEP_HEPEUP)
type is (eio_stdhep_hepevt_t)
call hepevt_from_event (event, &
keep_beams = eio%keep_beams, &
keep_remnants = eio%keep_remnants, &
ensure_order = eio%ensure_order)
call stdhep_write (STDHEP_HEPEVT)
type is (eio_stdhep_hepev4_t)
call hepevt_from_event (event, &
process_index = eio%proc_num_id (i_prc), &
keep_beams = eio%keep_beams, &
keep_remnants = eio%keep_remnants, &
ensure_order = eio%ensure_order, &
fill_hepev4 = .true.)
call stdhep_write (STDHEP_HEPEV4)
end select
else
call eio%write ()
call msg_fatal ("STDHEP file is not open for writing")
end if
end subroutine eio_stdhep_output
@ %def eio_stdhep_output
@ Input an event. We do not allow to read in STDHEP files written via
the HEPEVT common block as there is no control on the process ID.
This implies that the event index cannot be read; it is simply
incremented to count the current event sample.
<<EIO stdhep: eio stdhep: TBP>>=
procedure :: input_i_prc => eio_stdhep_input_i_prc
procedure :: input_event => eio_stdhep_input_event
<<EIO stdhep: procedures>>=
subroutine eio_stdhep_input_i_prc (eio, i_prc, iostat)
class(eio_stdhep_t), intent(inout) :: eio
integer, intent(out) :: i_prc
integer, intent(out) :: iostat
integer :: i, ilbl, proc_num_id
iostat = 0
select type (eio)
type is (eio_stdhep_hepevt_t)
if (size (eio%proc_num_id) > 1) then
call msg_fatal ("Events: only single processes allowed " // &
"with the STDHEP HEPEVT format.")
else
proc_num_id = eio%proc_num_id (1)
call stdhep_read (ilbl, lok)
end if
type is (eio_stdhep_hepev4_t)
call stdhep_read (ilbl, lok)
proc_num_id = idruplh
type is (eio_stdhep_hepeup_t)
call stdhep_read (ilbl, lok)
if (lok /= 0) call msg_error ("Events: STDHEP appears to be " // &
"empty or corrupted.")
if (ilbl == 12) then
call stdhep_read (ilbl, lok)
end if
if (ilbl == 11) then
proc_num_id = IDPRUP
end if
end select
FIND_I_PRC: do i = 1, size (eio%proc_num_id)
if (eio%proc_num_id(i) == proc_num_id) then
i_prc = i
exit FIND_I_PRC
end if
end do FIND_I_PRC
if (i_prc == 0) call err_index
contains
subroutine err_index
call msg_error ("STDHEP: reading events: undefined process ID " &
// char (str (proc_num_id)) // ", aborting read")
iostat = 1
end subroutine err_index
end subroutine eio_stdhep_input_i_prc
subroutine eio_stdhep_input_event (eio, event, iostat, event_handle)
class(eio_stdhep_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
iostat = 0
call event%reset_contents ()
call event%select (1, 1, 1)
call hepeup_to_event (event, eio%fallback_model, &
recover_beams = eio%recover_beams, &
use_alpha_s = eio%use_alphas_from_file, &
use_scale = eio%use_scale_from_file)
call event%increment_index ()
end subroutine eio_stdhep_input_event
@ %def eio_stdhep_input_i_prc
@ %def eio_stdhep_input_event
<<EIO stdhep: eio stdhep: TBP>>=
procedure :: skip => eio_stdhep_skip
<<EIO stdhep: procedures>>=
subroutine eio_stdhep_skip (eio, iostat)
class(eio_stdhep_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_stdhep_skip
@ %def eio_stdhep_skip
@ STDHEP speficic routines.
<<EIO stdhep: public>>=
public :: stdhep_init_out
public :: stdhep_init_in
public :: stdhep_write
public :: stdhep_end
<<EIO stdhep: procedures>>=
subroutine stdhep_init_out (file, title, nevt)
character(len=*), intent(in) :: file, title
integer(i64), intent(in) :: nevt
integer(i32) :: nevt32
nevt32 = min (nevt, int (huge (1_i32), i64))
call stdxwinit (file, title, nevt32, istr, lok)
end subroutine stdhep_init_out
subroutine stdhep_init_in (file, nevt)
character(len=*), intent(in) :: file
integer(i64), intent(out) :: nevt
integer(i32) :: nevt32
call stdxrinit (file, nevt32, istr, lok)
if (lok /= 0) call msg_fatal ("STDHEP: error in reading file '" // &
file // "'.")
nevt = int (nevt32, i64)
end subroutine stdhep_init_in
subroutine stdhep_write (ilbl)
integer, intent(in) :: ilbl
call stdxwrt (ilbl, istr, lok)
end subroutine stdhep_write
subroutine stdhep_read (ilbl, lok)
integer, intent(out) :: ilbl, lok
call stdxrd (ilbl, istr, lok)
if (lok /= 0) return
end subroutine stdhep_read
subroutine stdhep_end
call stdxend (istr)
end subroutine stdhep_end
@ %def stdhep_init stdhep_read stdhep_write stdhep_end
@
\subsection{Variables}
<<EIO stdhep: variables>>=
integer, save :: istr, lok
integer, parameter :: &
STDHEP_HEPEVT = 1, STDHEP_HEPEV4 = 4, &
STDHEP_HEPEUP = 11, STDHEP_HEPRUP = 12
@
@
\subsection{Unit tests}
Test module, followed by the corresponding implementation module.
<<[[eio_stdhep_ut.f90]]>>=
<<File header>>
module eio_stdhep_ut
use unit_tests
use eio_stdhep_uti
<<Standard module head>>
<<EIO stdhep: public test>>
contains
<<EIO stdhep: test driver>>
end module eio_stdhep_ut
@ %def eio_stdhep_ut
@
<<[[eio_stdhep_uti.f90]]>>=
<<File header>>
module eio_stdhep_uti
<<Use kinds>>
<<Use strings>>
use io_units
use model_data
use event_base
use eio_data
use eio_base
use xdr_wo_stdhep
use eio_stdhep
use eio_base_ut, only: eio_prepare_test, eio_cleanup_test
use eio_base_ut, only: eio_prepare_fallback_model, eio_cleanup_fallback_model
<<Standard module head>>
<<EIO stdhep: test declarations>>
contains
<<EIO stdhep: tests>>
end module eio_stdhep_uti
@ %def eio_stdhep_ut
@ API: driver for the unit tests below.
<<EIO stdhep: public test>>=
public :: eio_stdhep_test
<<EIO stdhep: test driver>>=
subroutine eio_stdhep_test (u, results)
integer, intent(in) :: u
type(test_results_t), intent(inout) :: results
<<EIO stdhep: execute tests>>
end subroutine eio_stdhep_test
@ %def eio_stdhep_test
@
\subsubsection{Test I/O methods}
We test the implementation of the STDHEP HEPEVT I/O method:
<<EIO stdhep: execute tests>>=
call test (eio_stdhep_1, "eio_stdhep_1", &
"read and write event contents, format [stdhep]", &
u, results)
<<EIO stdhep: test declarations>>=
public :: eio_stdhep_1
<<EIO stdhep: tests>>=
subroutine eio_stdhep_1 (u)
integer, intent(in) :: u
class(generic_event_t), pointer :: event
type(event_sample_data_t) :: data
class(eio_t), allocatable :: eio
type(string_t) :: sample
integer :: u_file, iostat
character(215) :: buffer
write (u, "(A)") "* Test output: eio_stdhep_1"
write (u, "(A)") "* Purpose: generate an event in STDHEP HEPEVT format"
write (u, "(A)") "* and write weight to file"
write (u, "(A)")
write (u, "(A)") "* Initialize test process"
call eio_prepare_test (event)
call data%init (1)
data%n_evt = 1
data%n_beam = 2
data%pdg_beam = 25
data%energy_beam = 500
data%proc_num_id = [42]
data%cross_section(1) = 100
data%error(1) = 1
data%total_cross_section = sum (data%cross_section)
write (u, "(A)")
write (u, "(A)") "* Generate and write an event"
write (u, "(A)")
sample = "eio_stdhep_1"
allocate (eio_stdhep_hepevt_t :: eio)
select type (eio)
type is (eio_stdhep_hepevt_t)
call eio%set_parameters ()
end select
call eio%init_out (sample, data)
call event%generate (1, [0._default, 0._default])
call event%set_index (61) ! not supported by reader, actually
call event%evaluate_expressions ()
call event%pacify_particle_set ()
call eio%output (event, i_prc = 1)
call eio%write (u)
call eio%final ()
write (u, "(A)")
write (u, "(A)") "* Write STDHEP file contents to ASCII file"
write (u, "(A)")
call write_stdhep_event &
(sample // ".hep", var_str ("eio_stdhep_1.hep.out"), 1)
write (u, "(A)")
write (u, "(A)") "* Read in ASCII contents of STDHEP file"
write (u, "(A)")
u_file = free_unit ()
open (u_file, file = "eio_stdhep_1.hep.out", &
action = "read", status = "old")
do
read (u_file, "(A)", iostat = iostat) buffer
if (iostat /= 0) exit
if (trim (buffer) == "") cycle
if (buffer(1:18) == " total blocks: ") &
buffer = " total blocks: [...]"
if (buffer(1:25) == " title: WHIZARD") &
buffer = " title: WHIZARD [version]"
if (buffer(1:17) == " date:") &
buffer = " date: [...]"
if (buffer(1:17) == " closing date:") &
buffer = " closing date: [...]"
write (u, "(A)") trim (buffer)
end do
close (u_file)
write (u, "(A)")
write (u, "(A)") "* Reset data"
write (u, "(A)")
deallocate (eio)
allocate (eio_stdhep_hepevt_t :: eio)
select type (eio)
type is (eio_stdhep_hepevt_t)
call eio%set_parameters (keep_beams = .true.)
end select
call eio%write (u)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call eio_cleanup_test (event)
write (u, "(A)")
write (u, "(A)") "* Test output end: eio_stdhep_1"
end subroutine eio_stdhep_1
@ %def eio_stdhep_1
@
We test the implementation of the STDHEP HEPEUP I/O method:
<<EIO stdhep: execute tests>>=
call test (eio_stdhep_2, "eio_stdhep_2", &
"read and write event contents, format [stdhep]", &
u, results)
<<EIO stdhep: test declarations>>=
public :: eio_stdhep_2
<<EIO stdhep: tests>>=
subroutine eio_stdhep_2 (u)
integer, intent(in) :: u
class(generic_event_t), pointer :: event
type(event_sample_data_t) :: data
class(model_data_t), pointer :: fallback_model
class(eio_t), allocatable :: eio
type(string_t) :: sample
integer :: u_file, iostat
character(215) :: buffer
write (u, "(A)") "* Test output: eio_stdhep_2"
write (u, "(A)") "* Purpose: generate an event in STDHEP HEPEUP format"
write (u, "(A)") "* and write weight to file"
write (u, "(A)")
write (u, "(A)") "* Initialize test process"
allocate (fallback_model)
call eio_prepare_fallback_model (fallback_model)
call eio_prepare_test (event, unweighted = .false.)
call data%init (1)
data%n_evt = 1
data%n_beam = 2
data%pdg_beam = 25
data%energy_beam = 500
data%proc_num_id = [42]
data%cross_section(1) = 100
data%error(1) = 1
data%total_cross_section = sum (data%cross_section)
write (u, "(A)")
write (u, "(A)") "* Generate and write an event"
write (u, "(A)")
sample = "eio_stdhep_2"
allocate (eio_stdhep_hepeup_t :: eio)
select type (eio)
type is (eio_stdhep_hepeup_t)
call eio%set_parameters ()
end select
call eio%set_fallback_model (fallback_model)
call eio%init_out (sample, data)
call event%generate (1, [0._default, 0._default])
call event%set_index (62) ! not supported by reader, actually
call event%evaluate_expressions ()
call eio%output (event, i_prc = 1)
call eio%write (u)
call eio%final ()
write (u, "(A)")
write (u, "(A)") "* Write STDHEP file contents to ASCII file"
write (u, "(A)")
call write_stdhep_event &
(sample // ".up.hep", var_str ("eio_stdhep_2.hep.out"), 2)
write (u, "(A)")
write (u, "(A)") "* Read in ASCII contents of STDHEP file"
write (u, "(A)")
u_file = free_unit ()
open (u_file, file = "eio_stdhep_2.hep.out", &
action = "read", status = "old")
do
read (u_file, "(A)", iostat = iostat) buffer
if (iostat /= 0) exit
if (trim (buffer) == "") cycle
if (buffer(1:18) == " total blocks: ") &
buffer = " total blocks: [...]"
if (buffer(1:25) == " title: WHIZARD") &
buffer = " title: WHIZARD [version]"
if (buffer(1:17) == " date:") &
buffer = " date: [...]"
if (buffer(1:17) == " closing date:") &
buffer = " closing date: [...]"
write (u, "(A)") trim (buffer)
end do
close (u_file)
write (u, "(A)")
write (u, "(A)") "* Reset data"
write (u, "(A)")
deallocate (eio)
allocate (eio_stdhep_hepeup_t :: eio)
select type (eio)
type is (eio_stdhep_hepeup_t)
call eio%set_parameters (keep_beams = .true.)
end select
call eio%write (u)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call eio_cleanup_test (event)
call eio_cleanup_fallback_model (fallback_model)
deallocate (fallback_model)
write (u, "(A)")
write (u, "(A)") "* Test output end: eio_stdhep_2"
end subroutine eio_stdhep_2
@ %def eio_stdhep_2
@
Check input from a StdHep file, HEPEVT block.
<<EIO stdhep: execute tests>>=
call test (eio_stdhep_3, "eio_stdhep_3", &
"read StdHep file, HEPEVT block", &
u, results)
<<EIO stdhep: test declarations>>=
public :: eio_stdhep_3
<<EIO stdhep: tests>>=
subroutine eio_stdhep_3 (u)
integer, intent(in) :: u
class(model_data_t), pointer :: fallback_model
class(generic_event_t), pointer :: event
type(event_sample_data_t) :: data
class(eio_t), allocatable :: eio
type(string_t) :: sample
integer :: iostat, i_prc
write (u, "(A)") "* Test output: eio_stdhep_3"
write (u, "(A)") "* Purpose: read a StdHep file, HEPEVT block"
write (u, "(A)")
write (u, "(A)") "* Write a StdHep data file, HEPEVT block"
write (u, "(A)")
allocate (fallback_model)
call eio_prepare_fallback_model (fallback_model)
call eio_prepare_test (event)
call data%init (1)
data%n_evt = 1
data%n_beam = 2
data%pdg_beam = 25
data%energy_beam = 500
data%proc_num_id = [42]
data%cross_section(1) = 100
data%error(1) = 1
data%total_cross_section = sum (data%cross_section)
write (u, "(A)")
write (u, "(A)") "* Generate and write an event"
write (u, "(A)")
sample = "eio_stdhep_3"
allocate (eio_stdhep_hepevt_t :: eio)
select type (eio)
type is (eio_stdhep_hepevt_t)
call eio%set_parameters ()
end select
call eio%set_fallback_model (fallback_model)
call eio%init_out (sample, data)
call event%generate (1, [0._default, 0._default])
call event%set_index (63) ! not supported by reader, actually
call event%evaluate_expressions ()
call eio%output (event, i_prc = 1)
call eio%write (u)
call eio%final ()
call eio_cleanup_test (event)
call eio_cleanup_fallback_model (fallback_model)
deallocate (eio)
deallocate (fallback_model)
write (u, "(A)") "* Initialize test process"
write (u, "(A)")
allocate (fallback_model)
call eio_prepare_fallback_model (fallback_model)
call eio_prepare_test (event, unweighted = .false.)
allocate (eio_stdhep_hepevt_t :: eio)
select type (eio)
type is (eio_stdhep_hepevt_t)
call eio%set_parameters (recover_beams = .false.)
end select
call eio%set_fallback_model (fallback_model)
call data%init (1)
data%n_beam = 2
data%unweighted = .true.
data%norm_mode = NORM_UNIT
data%pdg_beam = 25
data%energy_beam = 500
data%proc_num_id = [42]
call data%write (u)
write (u, *)
write (u, "(A)") "* Initialize"
write (u, "(A)")
call eio%init_in (sample, data)
call eio%write (u)
write (u, "(A)")
write (u, "(A)") "* Read event"
write (u, "(A)")
call eio%input_i_prc (i_prc, iostat)
select type (eio)
type is (eio_stdhep_hepevt_t)
write (u, "(A,I0,A,I0)") "Found process #", i_prc, &
" with ID = ", eio%proc_num_id(i_prc)
end select
call eio%input_event (event, iostat)
call event%write (u)
write (u, "(A)")
write (u, "(A)") "* Read closing"
write (u, "(A)")
call eio%input_i_prc (i_prc, iostat)
write (u, "(A,I0)") "iostat = ", iostat
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call eio%final ()
call eio_cleanup_test (event)
call eio_cleanup_fallback_model (fallback_model)
deallocate (fallback_model)
write (u, "(A)")
write (u, "(A)") "* Test output end: eio_stdhep_3"
end subroutine eio_stdhep_3
@ %def eio_stdhep_3
@
Check input from a StdHep file, HEPEVT block.
<<EIO stdhep: execute tests>>=
call test (eio_stdhep_4, "eio_stdhep_4", &
"read StdHep file, HEPRUP/HEPEUP block", &
u, results)
<<EIO stdhep: test declarations>>=
public :: eio_stdhep_4
<<EIO stdhep: tests>>=
subroutine eio_stdhep_4 (u)
integer, intent(in) :: u
class(model_data_t), pointer :: fallback_model
class(generic_event_t), pointer :: event
type(event_sample_data_t) :: data
class(eio_t), allocatable :: eio
type(string_t) :: sample
integer :: iostat, i_prc
write (u, "(A)") "* Test output: eio_stdhep_3"
write (u, "(A)") "* Purpose: read a StdHep file, HEPRUP/HEPEUP block"
write (u, "(A)")
write (u, "(A)") "* Write a StdHep data file, HEPRUP/HEPEUP block"
write (u, "(A)")
allocate (fallback_model)
call eio_prepare_fallback_model (fallback_model)
call eio_prepare_test (event)
call data%init (1)
data%n_evt = 1
data%n_beam = 2
data%pdg_beam = 25
data%energy_beam = 500
data%proc_num_id = [42]
data%cross_section(1) = 100
data%error(1) = 1
data%total_cross_section = sum (data%cross_section)
write (u, "(A)")
write (u, "(A)") "* Generate and write an event, HEPEUP/HEPRUP"
write (u, "(A)")
sample = "eio_stdhep_4"
allocate (eio_stdhep_hepeup_t :: eio)
select type (eio)
type is (eio_stdhep_hepeup_t)
call eio%set_parameters ()
end select
call eio%set_fallback_model (fallback_model)
call eio%init_out (sample, data)
call event%generate (1, [0._default, 0._default])
call event%set_index (64) ! not supported by reader, actually
call event%evaluate_expressions ()
call event%pacify_particle_set ()
call eio%output (event, i_prc = 1)
call eio%write (u)
call eio%final ()
call eio_cleanup_test (event)
call eio_cleanup_fallback_model (fallback_model)
deallocate (eio)
deallocate (fallback_model)
write (u, "(A)") "* Initialize test process"
write (u, "(A)")
allocate (fallback_model)
call eio_prepare_fallback_model (fallback_model)
call eio_prepare_test (event, unweighted = .false.)
allocate (eio_stdhep_hepeup_t :: eio)
select type (eio)
type is (eio_stdhep_hepeup_t)
call eio%set_parameters (recover_beams = .false.)
end select
call eio%set_fallback_model (fallback_model)
call data%init (1)
data%n_beam = 2
data%unweighted = .true.
data%norm_mode = NORM_UNIT
data%pdg_beam = 25
data%energy_beam = 500
data%proc_num_id = [42]
call data%write (u)
write (u, *)
write (u, "(A)") "* Initialize"
write (u, "(A)")
call eio%init_in (sample, data)
call eio%write (u)
write (u, "(A)")
write (u, "(A)") "* Read event"
write (u, "(A)")
call eio%input_i_prc (i_prc, iostat)
select type (eio)
type is (eio_stdhep_hepeup_t)
write (u, "(A,I0,A,I0)") "Found process #", i_prc, &
" with ID = ", eio%proc_num_id(i_prc)
end select
call eio%input_event (event, iostat)
call event%write (u)
write (u, "(A)")
write (u, "(A)") "* Read closing"
write (u, "(A)")
call eio%input_i_prc (i_prc, iostat)
write (u, "(A,I0)") "iostat = ", iostat
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call eio%final ()
call eio_cleanup_test (event)
call eio_cleanup_fallback_model (fallback_model)
deallocate (fallback_model)
write (u, "(A)")
write (u, "(A)") "* Test output end: eio_stdhep_4"
end subroutine eio_stdhep_4
@ %def eio_stdhep_4
@
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{HepMC Output}
The HepMC event record is standardized. It is an ASCII format. We try
our best at using it for both input and output.
<<[[eio_hepmc.f90]]>>=
<<File header>>
module eio_hepmc
<<Use kinds>>
<<Use strings>>
use io_units
use string_utils
use diagnostics
use particles
use model_data
use event_base
use event_handles, only: event_handle_t
use hep_events
use eio_data
use eio_base
use hepmc_interface
<<Standard module head>>
<<EIO HepMC: public>>
<<EIO HepMC: types>>
contains
<<EIO HepMC: procedures>>
end module eio_hepmc
@ %def eio_hepmc
@
\subsection{Type}
A type [[hepmc_event]] is introduced as container to store HepMC event
data, particularly for splitting the reading into read out of the process
index and the proper event data.
Note: the [[keep_beams]] flag is not supported. Beams will always
be written. Tools like \texttt{Rivet} can use the cross section
information of a HepMC file for scaling plots. As there is no header in
HepMC and this is written for every event, we make it optional with
[[output_cross_section]].
<<EIO HepMC: public>>=
public :: eio_hepmc_t
<<EIO HepMC: types>>=
type, extends (eio_t) :: eio_hepmc_t
logical :: writing = .false.
logical :: reading = .false.
type(event_sample_data_t) :: data
! logical :: keep_beams = .false.
logical :: recover_beams = .false.
logical :: use_alphas_from_file = .false.
logical :: use_scale_from_file = .false.
logical :: output_cross_section = .false.
integer :: hepmc3_mode = HEPMC3_MODE_HEPMC3
type(hepmc_iostream_t) :: iostream
type(hepmc_event_t) :: hepmc_event
integer, dimension(:), allocatable :: proc_num_id
contains
<<EIO HepMC: eio hepmc: TBP>>
end type eio_hepmc_t
@ %def eio_hepmc_t
@
\subsection{Specific Methods}
Set parameters that are specifically used with HepMC.
<<EIO HepMC: eio hepmc: TBP>>=
procedure :: set_parameters => eio_hepmc_set_parameters
<<EIO HepMC: procedures>>=
subroutine eio_hepmc_set_parameters &
(eio, &
recover_beams, use_alphas_from_file, use_scale_from_file, &
extension, output_cross_section, hepmc3_mode)
class(eio_hepmc_t), intent(inout) :: eio
logical, intent(in), optional :: recover_beams
logical, intent(in), optional :: use_alphas_from_file
logical, intent(in), optional :: use_scale_from_file
logical, intent(in), optional :: output_cross_section
type(string_t), intent(in), optional :: extension
integer, intent(in), optional :: hepmc3_mode
if (present (recover_beams)) &
eio%recover_beams = recover_beams
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 (extension)) then
eio%extension = extension
else
eio%extension = "hepmc"
end if
if (present (output_cross_section)) &
eio%output_cross_section = output_cross_section
if (present (hepmc3_mode)) &
eio%hepmc3_mode = hepmc3_mode
end subroutine eio_hepmc_set_parameters
@ %def eio_hepmc_set_parameters
@
\subsection{Common Methods}
Output. This is not the actual event format, but a readable account
of the current object status.
<<EIO HepMC: eio hepmc: TBP>>=
procedure :: write => eio_hepmc_write
<<EIO HepMC: procedures>>=
subroutine eio_hepmc_write (object, unit)
class(eio_hepmc_t), intent(in) :: object
integer, intent(in), optional :: unit
integer :: u, i
u = given_output_unit (unit)
write (u, "(1x,A)") "HepMC event stream:"
if (object%writing) then
write (u, "(3x,A,A)") "Writing to file = ", char (object%filename)
else if (object%reading) then
write (u, "(3x,A,A)") "Reading from file = ", char (object%filename)
else
write (u, "(3x,A)") "[closed]"
end if
write (u, "(3x,A,L1)") "Recover beams = ", object%recover_beams
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,A,A)") "File extension = '", &
char (object%extension), "'"
write (u, "(3x,A,I0)") "HepMC3 mode = ", object%hepmc3_mode
if (allocated (object%proc_num_id)) then
write (u, "(3x,A)") "Numerical process IDs:"
do i = 1, size (object%proc_num_id)
write (u, "(5x,I0,': ',I0)") i, object%proc_num_id(i)
end do
end if
end subroutine eio_hepmc_write
@ %def eio_hepmc_write
@ Finalizer: close any open file.
<<EIO HepMC: eio hepmc: TBP>>=
procedure :: final => eio_hepmc_final
<<EIO HepMC: procedures>>=
subroutine eio_hepmc_final (object)
class(eio_hepmc_t), intent(inout) :: object
if (allocated (object%proc_num_id)) deallocate (object%proc_num_id)
if (object%writing) then
write (msg_buffer, "(A,A,A)") "Events: closing HepMC file '", &
char (object%filename), "'"
call msg_message ()
call hepmc_iostream_close (object%iostream)
object%writing = .false.
else if (object%reading) then
write (msg_buffer, "(A,A,A)") "Events: closing HepMC file '", &
char (object%filename), "'"
call msg_message ()
call hepmc_iostream_close (object%iostream)
object%reading = .false.
end if
end subroutine eio_hepmc_final
@ %def eio_hepmc_final
@ Split event file: increment the counter, close the current file, open a new
one. If the file needs a header, repeat it for the new file.
<<EIO HepMC: eio hepmc: TBP>>=
procedure :: split_out => eio_hepmc_split_out
<<EIO HepMC: procedures>>=
subroutine eio_hepmc_split_out (eio)
class(eio_hepmc_t), intent(inout) :: eio
if (eio%split) then
eio%split_index = eio%split_index + 1
call eio%set_filename ()
write (msg_buffer, "(A,A,A)") "Events: writing to HepMC file '", &
char (eio%filename), "'"
call msg_message ()
call hepmc_iostream_close (eio%iostream)
call hepmc_iostream_open_out (eio%iostream, &
eio%filename, eio%hepmc3_mode)
end if
end subroutine eio_hepmc_split_out
@ %def eio_hepmc_split_out
@ Common initialization for input and output.
<<EIO HepMC: eio hepmc: TBP>>=
procedure :: common_init => eio_hepmc_common_init
<<EIO HepMC: procedures>>=
subroutine eio_hepmc_common_init (eio, sample, data, extension)
class(eio_hepmc_t), intent(inout) :: eio
type(string_t), intent(in) :: sample
type(string_t), intent(in), optional :: extension
type(event_sample_data_t), intent(in), optional :: data
if (.not. present (data)) &
call msg_bug ("HepMC initialization: missing data")
eio%data = data
if (data%n_beam /= 2) &
call msg_fatal ("HepMC: defined for scattering processes only")
! We could relax this condition now with weighted hepmc events
if (data%unweighted) then
select case (data%norm_mode)
case (NORM_UNIT)
case default; call msg_fatal &
("HepMC: normalization for unweighted events must be '1'")
end select
end if
eio%sample = sample
if (present (extension)) then
eio%extension = extension
end if
call eio%set_filename ()
allocate (eio%proc_num_id (data%n_proc), source = data%proc_num_id)
end subroutine eio_hepmc_common_init
@ %def eio_hepmc_common_init
@ Initialize event writing.
<<EIO HepMC: eio hepmc: TBP>>=
procedure :: init_out => eio_hepmc_init_out
<<EIO HepMC: procedures>>=
subroutine eio_hepmc_init_out (eio, sample, data, success, extension)
class(eio_hepmc_t), intent(inout) :: eio
type(string_t), intent(in) :: sample
type(string_t), intent(in), optional :: extension
type(event_sample_data_t), intent(in), optional :: data
logical, intent(out), optional :: success
call eio%set_splitting (data)
call eio%common_init (sample, data, extension)
write (msg_buffer, "(A,A,A)") "Events: writing to HepMC file '", &
char (eio%filename), "'"
call msg_message ()
eio%writing = .true.
call hepmc_iostream_open_out (eio%iostream, &
eio%filename, eio%hepmc3_mode)
if (present (success)) success = .true.
end subroutine eio_hepmc_init_out
@ %def eio_hepmc_init_out
@ Initialize event reading. For input, we do not (yet) support split
event files.
<<EIO HepMC: eio hepmc: TBP>>=
procedure :: init_in => eio_hepmc_init_in
<<EIO HepMC: procedures>>=
subroutine eio_hepmc_init_in (eio, sample, data, success, extension)
class(eio_hepmc_t), intent(inout) :: eio
type(string_t), intent(in) :: sample
type(string_t), intent(in), optional :: extension
type(event_sample_data_t), intent(inout), optional :: data
logical, intent(out), optional :: success
logical :: exist
eio%split = .false.
call eio%common_init (sample, data, extension)
write (msg_buffer, "(A,A,A)") "Events: reading from HepMC file '", &
char (eio%filename), "'"
call msg_message ()
inquire (file = char (eio%filename), exist = exist)
if (.not. exist) call msg_fatal ("Events: HepMC file not found.")
eio%reading = .true.
call hepmc_iostream_open_in (eio%iostream, &
eio%filename, eio%hepmc3_mode)
if (present (success)) success = .true.
end subroutine eio_hepmc_init_in
@ %def eio_hepmc_init_in
@ Switch from input to output: reopen the file for reading.
<<EIO HepMC: eio hepmc: TBP>>=
procedure :: switch_inout => eio_hepmc_switch_inout
<<EIO HepMC: procedures>>=
subroutine eio_hepmc_switch_inout (eio, success)
class(eio_hepmc_t), intent(inout) :: eio
logical, intent(out), optional :: success
call msg_bug ("HepMC: in-out switch not supported")
if (present (success)) success = .false.
end subroutine eio_hepmc_switch_inout
@ %def eio_hepmc_switch_inout
@ Output an event to the allocated HepMC output stream. For the
moment, we set [[alpha_qed]] always to -1. There should be methods for
the handling of $\alpha$ in [[me_methods]] in the same way as for
$\alpha_s$.
If an [[event_handle]] is in the argument list, and it is of the correct HepMC
type, do not destroy the event but transfer it there (i.e., the enclosed C
pointer).
<<EIO HepMC: eio hepmc: TBP>>=
procedure :: output => eio_hepmc_output
<<EIO HepMC: procedures>>=
subroutine eio_hepmc_output &
(eio, event, i_prc, reading, passed, pacify, event_handle)
class(eio_hepmc_t), intent(inout) :: eio
class(generic_event_t), intent(in), target :: event
integer, intent(in) :: i_prc
logical, intent(in), optional :: reading, passed, pacify
class(event_handle_t), intent(inout), optional :: event_handle
type(particle_set_t), pointer :: pset_ptr
if (present (passed)) then
if (.not. passed) return
end if
if (eio%writing) then
pset_ptr => event%get_particle_set_ptr ()
call hepmc_event_init (eio%hepmc_event, &
proc_id = eio%proc_num_id(i_prc), &
event_id = event%get_index ())
if (eio%output_cross_section) then
call hepmc_event_from_particle_set (eio%hepmc_event, pset_ptr, &
eio%data%cross_section(i_prc), eio%data%error(i_prc))
else
call hepmc_event_from_particle_set (eio%hepmc_event, pset_ptr)
end if
call hepmc_event_set_scale (eio%hepmc_event, event%get_fac_scale ())
call hepmc_event_set_alpha_qcd (eio%hepmc_event, event%get_alpha_s ())
call hepmc_event_set_alpha_qed (eio%hepmc_event, -1._default)
if (.not. eio%data%unweighted) then
select case (eio%data%norm_mode)
case (NORM_UNIT,NORM_N_EVT)
call hepmc_event_add_weight &
(eio%hepmc_event, event%weight_prc, .false.)
case default
call hepmc_event_add_weight &
(eio%hepmc_event, event%weight_prc, .true.)
end select
end if
call hepmc_iostream_write_event (eio%iostream, &
eio%hepmc_event, eio%hepmc3_mode)
call maybe_transfer_event_to_handle (eio%hepmc_event, event_handle)
call hepmc_event_final (eio%hepmc_event)
else
call eio%write ()
call msg_fatal ("HepMC file is not open for writing")
end if
end subroutine eio_hepmc_output
@ %def eio_hepmc_output
@ Input an event.
<<EIO HepMC: eio hepmc: TBP>>=
procedure :: input_i_prc => eio_hepmc_input_i_prc
procedure :: input_event => eio_hepmc_input_event
<<EIO HepMC: procedures>>=
subroutine eio_hepmc_input_i_prc (eio, i_prc, iostat)
class(eio_hepmc_t), intent(inout) :: eio
integer, intent(out) :: i_prc
integer, intent(out) :: iostat
logical :: ok
integer :: i, proc_num_id
iostat = 0
call hepmc_event_init (eio%hepmc_event)
call hepmc_iostream_read_event (eio%iostream, &
eio%hepmc_event, ok=ok)
proc_num_id = hepmc_event_get_process_id (eio%hepmc_event)
if (.not. ok) then
iostat = -1
return
end if
i_prc = 0
FIND_I_PRC: do i = 1, size (eio%proc_num_id)
if (eio%proc_num_id(i) == proc_num_id) then
i_prc = i
exit FIND_I_PRC
end if
end do FIND_I_PRC
if (i_prc == 0) call err_index
contains
subroutine err_index
call msg_error ("HepMC: reading events: undefined process ID " &
// char (str (proc_num_id)) // ", aborting read")
iostat = 1
end subroutine err_index
end subroutine eio_hepmc_input_i_prc
subroutine eio_hepmc_input_event (eio, event, iostat, event_handle)
class(eio_hepmc_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
iostat = 0
call event%reset_contents ()
call event%select (1, 1, 1)
call hepmc_to_event (event, eio%hepmc_event, &
eio%fallback_model, &
recover_beams = eio%recover_beams, &
use_alpha_s = eio%use_alphas_from_file, &
use_scale = eio%use_scale_from_file)
call maybe_transfer_event_to_handle (eio%hepmc_event, event_handle)
call hepmc_event_final (eio%hepmc_event)
end subroutine eio_hepmc_input_event
@ %def eio_hepmc_input_i_prc
@ %def eio_hepmc_input_event
@
If an [[event_handle]] is in the argument list, and it is of the correct HepMC
type, do not destroy the event but transfer it to the handle (i.e., the
enclosed C pointer). Nullify the original pointer, so the event does not get
destroyed.
<<EIO HepMC: procedures>>=
subroutine maybe_transfer_event_to_handle (hepmc_event, event_handle)
type(hepmc_event_t), intent(inout) :: hepmc_event
class(event_handle_t), intent(inout), optional :: event_handle
if (present (event_handle)) then
select type (event_handle)
type is (hepmc_event_t)
call hepmc_event_final (event_handle) ! just in case
event_handle = hepmc_event
call hepmc_event_nullify (hepmc_event) ! avoid destructor call
end select
end if
end subroutine maybe_transfer_event_to_handle
@ %def transfer_event_to_handle
@
<<EIO HepMC: eio hepmc: TBP>>=
procedure :: skip => eio_hepmc_skip
<<EIO HepMC: procedures>>=
subroutine eio_hepmc_skip (eio, iostat)
class(eio_hepmc_t), intent(inout) :: eio
integer, intent(out) :: iostat
iostat = 0
end subroutine eio_hepmc_skip
@ %def eio_hepmc_skip
@
\subsection{Unit tests}
Test module, followed by the corresponding implementation module.
<<[[eio_hepmc_ut.f90]]>>=
<<File header>>
module eio_hepmc_ut
use unit_tests
use system_dependencies, only: HEPMC2_AVAILABLE
use system_dependencies, only: HEPMC3_AVAILABLE
use eio_hepmc_uti
<<Standard module head>>
<<EIO HepMC: public test>>
contains
<<EIO HepMC: test driver>>
end module eio_hepmc_ut
@ %def eio_hepmc_ut
@
<<[[eio_hepmc_uti.f90]]>>=
<<File header>>
module eio_hepmc_uti
<<Use kinds>>
<<Use strings>>
use system_dependencies, only: HEPMC2_AVAILABLE
use system_dependencies, only: HEPMC3_AVAILABLE
use io_units
use diagnostics
use model_data
use event_base
use eio_data
use eio_base
use eio_hepmc
use eio_base_ut, only: eio_prepare_test, eio_cleanup_test
use eio_base_ut, only: eio_prepare_fallback_model, eio_cleanup_fallback_model
<<Standard module head>>
<<EIO HepMC: test declarations>>
contains
<<EIO HepMC: tests>>
end module eio_hepmc_uti
@ %def eio_hepmc_ut
@ API: driver for the unit tests below.
<<EIO HepMC: public test>>=
public :: eio_hepmc_test
<<EIO HepMC: test driver>>=
subroutine eio_hepmc_test (u, results)
integer, intent(in) :: u
type(test_results_t), intent(inout) :: results
<<EIO HepMC: execute tests>>
end subroutine eio_hepmc_test
@ %def eio_hepmc_test
@
\subsubsection{Test I/O methods}
We test the implementation of all I/O methods.
<<EIO HepMC: execute tests>>=
if (HEPMC2_AVAILABLE) then
call test (eio_hepmc_1, "eio_hepmc2_1", &
"write event contents", &
u, results)
else if (HEPMC3_AVAILABLE) then
call test (eio_hepmc_1, "eio_hepmc3_1", &
"write event contents", &
u, results)
end if
<<EIO HepMC: test declarations>>=
public :: eio_hepmc_1
<<EIO HepMC: tests>>=
subroutine eio_hepmc_1 (u)
integer, intent(in) :: u
class(generic_event_t), pointer :: event
type(event_sample_data_t) :: data
class(eio_t), allocatable :: eio
type(string_t) :: sample
integer :: u_file, iostat
character(116) :: buffer
write (u, "(A)") "* Test output: eio_hepmc_1"
write (u, "(A)") "* Purpose: write a HepMC file"
write (u, "(A)")
write (u, "(A)") "* Initialize test process"
call eio_prepare_test (event, unweighted=.false.)
call data%init (1)
data%n_beam = 2
data%unweighted = .true.
data%norm_mode = NORM_UNIT
data%pdg_beam = 25
data%energy_beam = 500
data%proc_num_id = [42]
data%cross_section(1) = 100
data%error(1) = 1
data%total_cross_section = sum (data%cross_section)
write (u, "(A)")
write (u, "(A)") "* Generate and write an event"
write (u, "(A)")
sample = "eio_hepmc_1"
allocate (eio_hepmc_t :: eio)
select type (eio)
type is (eio_hepmc_t)
call eio%set_parameters ()
end select
call eio%init_out (sample, data)
call event%generate (1, [0._default, 0._default])
call event%set_index (55)
call eio%output (event, i_prc = 1)
call eio%write (u)
call eio%final ()
write (u, "(A)")
write (u, "(A)") "* File contents (blanking out last two digits):"
write (u, "(A)")
u_file = free_unit ()
open (u_file, file = char (sample // ".hepmc"), &
action = "read", status = "old")
do
read (u_file, "(A)", iostat = iostat) buffer
if (iostat /= 0) exit
if (trim (buffer) == "") cycle
if (buffer(1:14) == "HepMC::Version") cycle
if (HEPMC2_AVAILABLE) then
if (buffer(1:10) == "P 10001 25") &
call buffer_blanker (buffer, 32, 55, 78)
if (buffer(1:10) == "P 10002 25") &
call buffer_blanker (buffer, 33, 56, 79)
if (buffer(1:10) == "P 10003 25") &
call buffer_blanker (buffer, 29, 53, 78, 101)
if (buffer(1:10) == "P 10004 25") &
call buffer_blanker (buffer, 28, 51, 76, 99)
else if (HEPMC3_AVAILABLE) then
if (buffer(1:8) == "P 1 0 25") &
call buffer_blanker (buffer, 26, 49, 72)
if (buffer(1:8) == "P 2 0 25") &
call buffer_blanker (buffer, 26, 49, 73)
if (buffer(1:9) == "P 3 -1 25") &
call buffer_blanker (buffer, 28, 52, 75)
if (buffer(1:9) == "P 4 -1 25") &
call buffer_blanker (buffer, 27, 50, 73)
end if
write (u, "(A)") trim (buffer)
end do
close (u_file)
write (u, "(A)")
write (u, "(A)") "* Reset data"
write (u, "(A)")
deallocate (eio)
allocate (eio_hepmc_t :: eio)
select type (eio)
type is (eio_hepmc_t)
call eio%set_parameters ()
end select
call eio%write (u)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call eio_cleanup_test (event)
write (u, "(A)")
write (u, "(A)") "* Test output end: eio_hepmc_1"
contains
subroutine buffer_blanker (buf, pos1, pos2, pos3, pos4)
character(len=*), intent(inout) :: buf
integer, intent(in) :: pos1, pos2, pos3
integer, intent(in), optional :: pos4
type(string_t) :: line
line = var_str (trim (buf))
line = replace (line, pos1, "XX")
line = replace (line, pos2, "XX")
line = replace (line, pos3, "XX")
if (present (pos4)) then
line = replace (line, pos4, "XX")
end if
line = replace (line, "4999999999999", "5000000000000")
buf = char (line)
end subroutine buffer_blanker
end subroutine eio_hepmc_1
@ %def eio_hepmc_1
@ Test also the reading of HepMC events.
<<EIO HepMC: execute tests>>=
if (HEPMC2_AVAILABLE) then
call test (eio_hepmc_2, "eio_hepmc2_2", &
"read event contents", &
u, results)
else if (HEPMC3_AVAILABLE) then
call test (eio_hepmc_2, "eio_hepmc3_2", &
"read event contents", &
u, results)
end if
<<EIO HepMC: test declarations>>=
public :: eio_hepmc_2
<<EIO HepMC: tests>>=
subroutine eio_hepmc_2 (u)
integer, intent(in) :: u
class(model_data_t), pointer :: fallback_model
class(generic_event_t), pointer :: event
type(event_sample_data_t) :: data
class(eio_t), allocatable :: eio
type(string_t) :: sample
integer :: u_file, iostat, i_prc
write (u, "(A)") "* Test output: eio_hepmc_2"
write (u, "(A)") "* Purpose: read a HepMC event"
write (u, "(A)")
write (u, "(A)") "* Write a HepMC data file"
write (u, "(A)")
u_file = free_unit ()
sample = "eio_hepmc_2"
open (u_file, file = char (sample // ".hepmc"), &
status = "replace", action = "readwrite")
if (HEPMC2_AVAILABLE) then
write (u_file, "(A)") "HepMC::Version 2.06.09"
write (u_file, "(A)") "HepMC::IO_GenEvent-START_EVENT_LISTING"
write (u_file, "(A)") "E 66 -1 -1.0000000000000000e+00 &
&-1.0000000000000000e+00 &
&-1.0000000000000000e+00 42 0 1 10001 10002 0 0"
write (u_file, "(A)") "U GEV MM"
write (u_file, "(A)") "V -1 0 0 0 0 0 2 2 0"
write (u_file, "(A)") "P 10001 25 0 0 4.8412291827592713e+02 &
&5.0000000000000000e+02 &
&1.2499999999999989e+02 3 0 0 -1 0"
write (u_file, "(A)") "P 10002 25 0 0 -4.8412291827592713e+02 &
&5.0000000000000000e+02 &
&1.2499999999999989e+02 3 0 0 -1 0"
write (u_file, "(A)") "P 10003 25 -1.4960220911365536e+02 &
&-4.6042825611414656e+02 &
&0 5.0000000000000000e+02 1.2500000000000000e+02 1 0 0 0 0"
write (u_file, "(A)") "P 10004 25 1.4960220911365536e+02 &
&4.6042825611414656e+02 &
&0 5.0000000000000000e+02 1.2500000000000000e+02 1 0 0 0 0"
write (u_file, "(A)") "HepMC::IO_GenEvent-END_EVENT_LISTING"
else if (HEPMC3_AVAILABLE) then
write (u_file, "(A)") "HepMC::Version 3.01.01"
write (u_file, "(A)") "HepMC::Asciiv3-START_EVENT_LISTING"
write (u_file, "(A)") "E 55 1 4"
write (u_file, "(A)") "U GEV MM"
write (u_file, "(A)") "A 0 alphaQCD -1"
write (u_file, "(A)") "A 0 event_scale 1000"
write (u_file, "(A)") "A 0 signal_process_id 42"
write (u_file, "(A)") "P 1 0 25 0.0000000000000000e+00 &
&0.0000000000000000e+00 4.8412291827592713e+02 &
&5.0000000000000000e+02 1.2499999999999989e+02 3"
write (u_file, "(A)") "P 2 0 25 0.0000000000000000e+00 &
&0.0000000000000000e+00 -4.8412291827592713e+02 &
&5.0000000000000000e+02 1.2499999999999989e+02 3"
write (u_file, "(A)") "V -1 0 [1,2]"
write (u_file, "(A)") "P 3 -1 25 -1.4960220911365536e+02 &
&-4.6042825611414656e+02 0.0000000000000000e+00 &
&5.0000000000000000e+02 1.2500000000000000e+02 1"
write (u_file, "(A)") "P 4 -1 25 1.4960220911365536e+02 &
&4.6042825611414656e+02 0.0000000000000000e+00 &
&5.0000000000000000e+02 1.2500000000000000e+02 1"
write (u_file, "(A)") "HepMC::Asciiv3-END_EVENT_LISTING"
else
call msg_fatal &
("Trying to execute eio_hepmc unit tests without a linked HepMC")
end if
close (u_file)
write (u, "(A)") "* Initialize test process"
write (u, "(A)")
allocate (fallback_model)
call eio_prepare_fallback_model (fallback_model)
call eio_prepare_test (event, unweighted=.false.)
allocate (eio_hepmc_t :: eio)
select type (eio)
type is (eio_hepmc_t)
call eio%set_parameters (recover_beams = .false.)
end select
call eio%set_fallback_model (fallback_model)
call data%init (1)
data%n_beam = 2
data%unweighted = .true.
data%norm_mode = NORM_UNIT
data%pdg_beam = 25
data%energy_beam = 500
data%proc_num_id = [42]
call data%write (u)
write (u, "(A)")
write (u, "(A)") "* Initialize"
write (u, "(A)")
call eio%init_in (sample, data)
call eio%write (u)
write (u, "(A)")
write (u, "(A)") "* Read event"
write (u, "(A)")
call eio%input_i_prc (i_prc, iostat)
select type (eio)
type is (eio_hepmc_t)
write (u, "(A,I0,A,I0)") "Found process #", i_prc, &
" with ID = ", eio%proc_num_id(i_prc)
end select
call eio%input_event (event, iostat)
call event%write (u)
write (u, "(A)")
write (u, "(A)") "* Read closing"
write (u, "(A)")
call eio%input_i_prc (i_prc, iostat)
write (u, "(A,I0)") "iostat = ", iostat
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call eio%final ()
call eio_cleanup_test (event)
call eio_cleanup_fallback_model (fallback_model)
deallocate (fallback_model)
write (u, "(A)")
write (u, "(A)") "* Test output end: eio_hepmc_2"
end subroutine eio_hepmc_2
@ %def eio_hepmc_2
@
Test also the correct normalization of weighted HepMC events.
<<EIO HepMC: execute tests>>=
if (HEPMC2_AVAILABLE) then
call test (eio_hepmc_3, "eio_hepmc2_3", &
"write event contents", &
u, results)
else if (HEPMC3_AVAILABLE) then
call test (eio_hepmc_3, "eio_hepmc3_3", &
"event contents weighted, '1' normalization", &
u, results)
end if
<<EIO HepMC: test declarations>>=
public :: eio_hepmc_3
<<EIO HepMC: tests>>=
subroutine eio_hepmc_3 (u)
integer, intent(in) :: u
class(generic_event_t), pointer :: event
type(event_sample_data_t) :: data
class(eio_t), allocatable :: eio
type(string_t) :: sample
integer :: u_file, iostat
character(126) :: buffer
write (u, "(A)") "* Test output: eio_hepmc_3"
write (u, "(A)") "* Purpose: test correct HepMC normalization"
write (u, "(A)")
write (u, "(A)") "* Initialize test process"
call eio_prepare_test (event, unweighted=.false., &
sample_norm = var_str ("1"))
call data%init (1)
data%n_beam = 2
data%unweighted = .false.
data%norm_mode = NORM_UNIT
data%pdg_beam = 25
data%energy_beam = 500
data%proc_num_id = [42]
data%cross_section(1) = 20
data%error(1) = 1
data%total_cross_section = sum (data%cross_section)
write (u, "(A)")
write (u, "(A)") "* Generate and write an event"
write (u, "(A)")
sample = "eio_hepmc_3"
allocate (eio_hepmc_t :: eio)
select type (eio)
type is (eio_hepmc_t)
call eio%set_parameters ()
end select
call eio%init_out (sample, data)
call event%generate (1, [0._default, 0._default])
call event%set_index (55)
call eio%output (event, i_prc = 1)
call eio%write (u)
call eio%final ()
write (u, "(A)")
write (u, "(A)") "* File contents (blanking out last two digits):"
write (u, "(A)")
u_file = free_unit ()
open (u_file, file = char (sample // ".hepmc"), &
action = "read", status = "old")
do
read (u_file, "(A)", iostat = iostat) buffer
if (iostat /= 0) exit
if (trim (buffer) == "") cycle
if (buffer(1:14) == "HepMC::Version") cycle
if (HEPMC2_AVAILABLE) then
if (buffer(1:4) == "E 55") then
buffer = replace (buffer, 113, "XXXXXXXXX")
end if
if (buffer(1:10) == "P 10001 25") &
call buffer_blanker (buffer, 32, 55, 78)
if (buffer(1:10) == "P 10002 25") &
call buffer_blanker (buffer, 33, 56, 79)
if (buffer(1:10) == "P 10003 25") &
call buffer_blanker (buffer, 29, 53, 78, 101)
if (buffer(1:10) == "P 10004 25") &
call buffer_blanker (buffer, 28, 51, 76, 99)
else if (HEPMC3_AVAILABLE) then
if (buffer(1:4) == "W 3.") then
buffer = replace (buffer, 11, "XXXXXXXXXXXXXXXX")
end if
if (buffer(1:8) == "P 1 0 25") &
call buffer_blanker (buffer, 26, 49, 72, 118)
if (buffer(1:8) == "P 2 0 25") &
call buffer_blanker (buffer, 26, 49, 73, 119)
if (buffer(1:9) == "P 3 -1 25") &
call buffer_blanker (buffer, 28, 52, 75, 121)
if (buffer(1:9) == "P 4 -1 25") &
call buffer_blanker (buffer, 27, 50, 73, 119)
end if
write (u, "(A)") trim (buffer)
end do
close (u_file)
write (u, "(A)")
write (u, "(A)") "* Reset data"
write (u, "(A)")
deallocate (eio)
allocate (eio_hepmc_t :: eio)
select type (eio)
type is (eio_hepmc_t)
call eio%set_parameters ()
end select
call eio%write (u)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call eio_cleanup_test (event)
write (u, "(A)")
write (u, "(A)") "* Test output end: eio_hepmc_3"
contains
subroutine buffer_blanker (buf, pos1, pos2, pos3, pos4)
character(len=*), intent(inout) :: buf
integer, intent(in) :: pos1, pos2, pos3
integer, intent(in), optional :: pos4
type(string_t) :: line
line = var_str (trim (buf))
line = replace (line, pos1, "XX")
line = replace (line, pos2, "XX")
line = replace (line, pos3, "XX")
if (present (pos4)) then
line = replace (line, pos4, "XX")
end if
line = replace (line, "4999999999999", "5000000000000")
buf = char (line)
end subroutine buffer_blanker
end subroutine eio_hepmc_3
@ %def eio_hepmc_3
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{LCIO Output}
The LCIO event record is standardized for the use with Linear $e^+e^-$
colliders. It is a binary event format. We try our best at using it
for both input and output.
<<[[eio_lcio.f90]]>>=
<<File header>>
module eio_lcio
<<Use kinds>>
<<Use strings>>
use io_units
use string_utils
use diagnostics
use particles
use event_base
use event_handles, only: event_handle_t
use hep_events
use eio_data
use eio_base
use lcio_interface
<<Standard module head>>
<<EIO LCIO: public>>
<<EIO LCIO: types>>
contains
<<EIO LCIO: procedures>>
end module eio_lcio
@ %def eio_lcio
@
\subsection{Type}
A type [[lcio_event]] is introduced as container to store LCIO event
data, particularly for splitting the reading into read out of the process
index and the proper event data.
Note: the [[keep_beams]] flag is not supported.
<<EIO LCIO: public>>=
public :: eio_lcio_t
<<EIO LCIO: types>>=
type, extends (eio_t) :: eio_lcio_t
logical :: writing = .false.
logical :: reading = .false.
type(event_sample_data_t) :: data
logical :: recover_beams = .false.
logical :: use_alphas_from_file = .false.
logical :: use_scale_from_file = .false.
logical :: proc_as_run_id = .true.
integer :: n_alt = 0
integer :: lcio_run_id = 0
type(lcio_writer_t) :: lcio_writer
type(lcio_reader_t) :: lcio_reader
type(lcio_run_header_t) :: lcio_run_hdr
type(lcio_event_t) :: lcio_event
integer, dimension(:), allocatable :: proc_num_id
contains
<<EIO LCIO: eio lcio: TBP>>
end type eio_lcio_t
@ %def eio_lcio_t
@
\subsection{Specific Methods}
Set parameters that are specifically used with LCIO.
<<EIO LCIO: eio lcio: TBP>>=
procedure :: set_parameters => eio_lcio_set_parameters
<<EIO LCIO: procedures>>=
subroutine eio_lcio_set_parameters &
(eio, recover_beams, use_alphas_from_file, use_scale_from_file, &
extension, proc_as_run_id, lcio_run_id)
class(eio_lcio_t), intent(inout) :: eio
logical, intent(in), optional :: recover_beams
logical, intent(in), optional :: use_alphas_from_file
logical, intent(in), optional :: use_scale_from_file
logical, intent(in), optional :: proc_as_run_id
integer, intent(in), optional :: lcio_run_id
type(string_t), intent(in), optional :: extension
if (present (recover_beams)) eio%recover_beams = recover_beams
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 (proc_as_run_id)) &
eio%proc_as_run_id = proc_as_run_id
if (present (lcio_run_id)) &
eio%lcio_run_id = lcio_run_id
if (present (extension)) then
eio%extension = extension
else
eio%extension = "slcio"
end if
end subroutine eio_lcio_set_parameters
@ %def eio_lcio_set_parameters
@
\subsection{Common Methods}
Output. This is not the actual event format, but a readable account
of the current object status.
<<EIO LCIO: eio lcio: TBP>>=
procedure :: write => eio_lcio_write
<<EIO LCIO: procedures>>=
subroutine eio_lcio_write (object, unit)
class(eio_lcio_t), intent(in) :: object
integer, intent(in), optional :: unit
integer :: u, i
u = given_output_unit (unit)
write (u, "(1x,A)") "LCIO event stream:"
if (object%writing) then
write (u, "(3x,A,A)") "Writing to file = ", char (object%filename)
else if (object%reading) then
write (u, "(3x,A,A)") "Reading from file = ", char (object%filename)
else
write (u, "(3x,A)") "[closed]"
end if
write (u, "(3x,A,L1)") "Recover beams = ", object%recover_beams
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)") "Process as run ID = ", &
object%proc_as_run_id
write (u, "(3x,A,I0)") "LCIO run ID = ", &
object%lcio_run_id
write (u, "(3x,A,A,A)") "File extension = '", &
char (object%extension), "'"
if (allocated (object%proc_num_id)) then
write (u, "(3x,A)") "Numerical process IDs:"
do i = 1, size (object%proc_num_id)
write (u, "(5x,I0,': ',I0)") i, object%proc_num_id(i)
end do
end if
end subroutine eio_lcio_write
@ %def eio_lcio_write
@ Finalizer: close any open file.
<<EIO LCIO: eio lcio: TBP>>=
procedure :: final => eio_lcio_final
<<EIO LCIO: procedures>>=
subroutine eio_lcio_final (object)
class(eio_lcio_t), intent(inout) :: object
if (allocated (object%proc_num_id)) deallocate (object%proc_num_id)
if (object%writing) then
write (msg_buffer, "(A,A,A)") "Events: closing LCIO file '", &
char (object%filename), "'"
call msg_message ()
call lcio_writer_close (object%lcio_writer)
object%writing = .false.
else if (object%reading) then
write (msg_buffer, "(A,A,A)") "Events: closing LCIO file '", &
char (object%filename), "'"
call msg_message ()
call lcio_reader_close (object%lcio_reader)
object%reading = .false.
end if
end subroutine eio_lcio_final
@ %def eio_lcio_final
@ Split event file: increment the counter, close the current file, open a new
one. If the file needs a header, repeat it for the new file.
<<EIO LCIO: eio lcio: TBP>>=
procedure :: split_out => eio_lcio_split_out
<<EIO LCIO: procedures>>=
subroutine eio_lcio_split_out (eio)
class(eio_lcio_t), intent(inout) :: eio
if (eio%split) then
eio%split_index = eio%split_index + 1
call eio%set_filename ()
write (msg_buffer, "(A,A,A)") "Events: writing to LCIO file '", &
char (eio%filename), "'"
call msg_message ()
call lcio_writer_close (eio%lcio_writer)
call lcio_writer_open_out (eio%lcio_writer, eio%filename)
end if
end subroutine eio_lcio_split_out
@ %def eio_lcio_split_out
@ Common initialization for input and output.
<<EIO LCIO: eio lcio: TBP>>=
procedure :: common_init => eio_lcio_common_init
<<EIO LCIO: procedures>>=
subroutine eio_lcio_common_init (eio, sample, data, extension)
class(eio_lcio_t), intent(inout) :: eio
type(string_t), intent(in) :: sample
type(string_t), intent(in), optional :: extension
type(event_sample_data_t), intent(in), optional :: data
if (.not. present (data)) &
call msg_bug ("LCIO initialization: missing data")
eio%data = data
if (data%n_beam /= 2) &
call msg_fatal ("LCIO: defined for scattering processes only")
if (data%unweighted) then
select case (data%norm_mode)
case (NORM_UNIT)
case default; call msg_fatal &
("LCIO: normalization for unweighted events must be '1'")
end select
else
call msg_fatal ("LCIO: events must be unweighted")
end if
eio%n_alt = data%n_alt
eio%sample = sample
if (present (extension)) then
eio%extension = extension
end if
call eio%set_filename ()
allocate (eio%proc_num_id (data%n_proc), source = data%proc_num_id)
end subroutine eio_lcio_common_init
@ %def eio_lcio_common_init
@ Initialize event writing.
<<EIO LCIO: eio lcio: TBP>>=
procedure :: init_out => eio_lcio_init_out
<<EIO LCIO: procedures>>=
subroutine eio_lcio_init_out (eio, sample, data, success, extension)
class(eio_lcio_t), intent(inout) :: eio
type(string_t), intent(in) :: sample
type(string_t), intent(in), optional :: extension
type(event_sample_data_t), intent(in), optional :: data
logical, intent(out), optional :: success
call eio%set_splitting (data)
call eio%common_init (sample, data, extension)
write (msg_buffer, "(A,A,A)") "Events: writing to LCIO file '", &
char (eio%filename), "'"
call msg_message ()
eio%writing = .true.
call lcio_writer_open_out (eio%lcio_writer, eio%filename)
call lcio_run_header_init (eio%lcio_run_hdr)
call lcio_run_header_write (eio%lcio_writer, eio%lcio_run_hdr)
if (present (success)) success = .true.
end subroutine eio_lcio_init_out
@ %def eio_lcio_init_out
@ Initialize event reading. For input, we do not (yet) support split
event files.
<<EIO LCIO: eio lcio: TBP>>=
procedure :: init_in => eio_lcio_init_in
<<EIO LCIO: procedures>>=
subroutine eio_lcio_init_in (eio, sample, data, success, extension)
class(eio_lcio_t), intent(inout) :: eio
type(string_t), intent(in) :: sample
type(string_t), intent(in), optional :: extension
type(event_sample_data_t), intent(inout), optional :: data
logical, intent(out), optional :: success
logical :: exist
eio%split = .false.
call eio%common_init (sample, data, extension)
write (msg_buffer, "(A,A,A)") "Events: reading from LCIO file '", &
char (eio%filename), "'"
call msg_message ()
inquire (file = char (eio%filename), exist = exist)
if (.not. exist) call msg_fatal ("Events: LCIO file not found.")
eio%reading = .true.
call lcio_open_file (eio%lcio_reader, eio%filename)
if (present (success)) success = .true.
end subroutine eio_lcio_init_in
@ %def eio_lcio_init_in
@ Switch from input to output: reopen the file for reading.
<<EIO LCIO: eio lcio: TBP>>=
procedure :: switch_inout => eio_lcio_switch_inout
<<EIO LCIO: procedures>>=
subroutine eio_lcio_switch_inout (eio, success)
class(eio_lcio_t), intent(inout) :: eio
logical, intent(out), optional :: success
call msg_bug ("LCIO: in-out switch not supported")
if (present (success)) success = .false.
end subroutine eio_lcio_switch_inout
@ %def eio_lcio_switch_inout
@ Output an event to the allocated LCIO writer.
<<EIO LCIO: eio lcio: TBP>>=
procedure :: output => eio_lcio_output
<<EIO LCIO: procedures>>=
subroutine eio_lcio_output &
(eio, event, i_prc, reading, passed, pacify, event_handle)
class(eio_lcio_t), intent(inout) :: eio
class(generic_event_t), intent(in), target :: event
integer, intent(in) :: i_prc
logical, intent(in), optional :: reading, passed, pacify
class(event_handle_t), intent(inout), optional :: event_handle
type(particle_set_t), pointer :: pset_ptr
real(default) :: sqme_prc, weight
integer :: i
if (present (passed)) then
if (.not. passed) return
end if
if (eio%writing) then
pset_ptr => event%get_particle_set_ptr ()
if (eio%proc_as_run_id) then
call lcio_event_init (eio%lcio_event, &
proc_id = eio%proc_num_id (i_prc), &
event_id = event%get_index (), &
run_id = eio%proc_num_id (i_prc))
else
call lcio_event_init (eio%lcio_event, &
proc_id = eio%proc_num_id (i_prc), &
event_id = event%get_index (), &
run_id = eio%lcio_run_id)
end if
call lcio_event_from_particle_set (eio%lcio_event, pset_ptr)
call lcio_event_set_weight (eio%lcio_event, event%weight_prc)
call lcio_event_set_sqrts (eio%lcio_event, event%get_sqrts ())
call lcio_event_set_sqme (eio%lcio_event, event%get_sqme_prc ())
call lcio_event_set_scale (eio%lcio_event, event%get_fac_scale ())
call lcio_event_set_alpha_qcd (eio%lcio_event, event%get_alpha_s ())
call lcio_event_set_xsec (eio%lcio_event, eio%data%cross_section(i_prc), &
eio%data%error(i_prc))
call lcio_event_set_polarization (eio%lcio_event, &
event%get_polarization ())
call lcio_event_set_beam_file (eio%lcio_event, &
event%get_beam_file ())
call lcio_event_set_process_name (eio%lcio_event, &
event%get_process_name ())
do i = 1, eio%n_alt
sqme_prc = event%get_sqme_alt(i)
weight = event%get_weight_alt(i)
call lcio_event_set_alt_sqme (eio%lcio_event, sqme_prc, i)
call lcio_event_set_alt_weight (eio%lcio_event, weight, i)
end do
call lcio_event_write (eio%lcio_writer, eio%lcio_event)
call maybe_transfer_event_to_handle (eio%lcio_event, &
event_handle, .true.)
call lcio_event_final (eio%lcio_event, .true.)
else
call eio%write ()
call msg_fatal ("LCIO file is not open for writing")
end if
end subroutine eio_lcio_output
@ %def eio_lcio_output
@ Input an event.
<<EIO LCIO: eio lcio: TBP>>=
procedure :: input_i_prc => eio_lcio_input_i_prc
procedure :: input_event => eio_lcio_input_event
<<EIO LCIO: procedures>>=
subroutine eio_lcio_input_i_prc (eio, i_prc, iostat)
class(eio_lcio_t), intent(inout) :: eio
integer, intent(out) :: i_prc
integer, intent(out) :: iostat
logical :: ok
integer :: i, proc_num_id
iostat = 0
call lcio_read_event (eio%lcio_reader, eio%lcio_event, ok)
if (.not. ok) then
iostat = -1
return
end if
proc_num_id = lcio_event_get_process_id (eio%lcio_event)
i_prc = 0
FIND_I_PRC: do i = 1, size (eio%proc_num_id)
if (eio%proc_num_id(i) == proc_num_id) then
i_prc = i
exit FIND_I_PRC
end if
end do FIND_I_PRC
if (i_prc == 0) call err_index
contains
subroutine err_index
call msg_error ("LCIO: reading events: undefined process ID " &
// char (str (proc_num_id)) // ", aborting read")
iostat = 1
end subroutine err_index
end subroutine eio_lcio_input_i_prc
subroutine eio_lcio_input_event (eio, event, iostat, event_handle)
class(eio_lcio_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
iostat = 0
call event%reset_contents ()
call event%select (1, 1, 1)
call event%set_index (lcio_event_get_event_index (eio%lcio_event))
call lcio_to_event (event, eio%lcio_event, eio%fallback_model, &
recover_beams = eio%recover_beams, &
use_alpha_s = eio%use_alphas_from_file, &
use_scale = eio%use_scale_from_file)
call maybe_transfer_event_to_handle (eio%lcio_event, &
event_handle, .false.)
call lcio_event_final (eio%lcio_event, .false.)
end subroutine eio_lcio_input_event
@ %def eio_lcio_input_i_prc
@ %def eio_lcio_input_event
@
If an [[event_handle]] is in the argument list, and it is of the correct HepMC
type, do not destroy the event but transfer it to the handle (i.e., the
enclosed C pointer). Nullify the original pointer, so the event does not get
destroyed.
<<EIO LCIO: procedures>>=
subroutine maybe_transfer_event_to_handle (lcio_event, event_handle, delete)
type(lcio_event_t), intent(inout) :: lcio_event
class(event_handle_t), intent(inout), optional :: event_handle
logical, intent(in) :: delete
if (present (event_handle)) then
select type (event_handle)
type is (lcio_event_t)
call lcio_event_final (event_handle, delete) ! just in case
event_handle = lcio_event
call show_lcio_event (event_handle)
call lcio_event_nullify (lcio_event) ! avoid destructor call
end select
end if
end subroutine maybe_transfer_event_to_handle
@ %def transfer_event_to_handle
@
<<EIO LCIO: eio lcio: TBP>>=
procedure :: skip => eio_lcio_skip
<<EIO LCIO: procedures>>=
subroutine eio_lcio_skip (eio, iostat)
class(eio_lcio_t), intent(inout) :: eio
integer, intent(out) :: iostat
iostat = 0
end subroutine eio_lcio_skip
@ %def eio_lcio_skip
@
\subsection{Unit tests}
Test module, followed by the corresponding implementation module.
<<[[eio_lcio_ut.f90]]>>=
<<File header>>
module eio_lcio_ut
use unit_tests
use eio_lcio_uti
<<Standard module head>>
<<EIO LCIO: public test>>
contains
<<EIO LCIO: test driver>>
end module eio_lcio_ut
@ %def eio_lcio_ut
@
<<[[eio_lcio_uti.f90]]>>=
<<File header>>
module eio_lcio_uti
<<Use kinds>>
<<Use strings>>
use io_units
use model_data
use particles
use event_base
use eio_data
use eio_base
use hep_events
use lcio_interface
use eio_lcio
use eio_base_ut, only: eio_prepare_test, eio_cleanup_test
use eio_base_ut, only: eio_prepare_fallback_model, eio_cleanup_fallback_model
<<Standard module head>>
<<EIO LCIO: test declarations>>
contains
<<EIO LCIO: tests>>
end module eio_lcio_uti
@ %def eio_lcio_ut
@ API: driver for the unit tests below.
<<EIO LCIO: public test>>=
public :: eio_lcio_test
<<EIO LCIO: test driver>>=
subroutine eio_lcio_test (u, results)
integer, intent(in) :: u
type(test_results_t), intent(inout) :: results
<<EIO LCIO: execute tests>>
end subroutine eio_lcio_test
@ %def eio_lcio_test
@
\subsubsection{Test I/O methods}
We test the implementation of all I/O methods.
<<EIO LCIO: execute tests>>=
call test (eio_lcio_1, "eio_lcio_1", &
"write event contents", &
u, results)
<<EIO LCIO: test declarations>>=
public :: eio_lcio_1
<<EIO LCIO: tests>>=
subroutine eio_lcio_1 (u)
integer, intent(in) :: u
class(generic_event_t), pointer :: event
type(event_sample_data_t) :: data
class(eio_t), allocatable :: eio
type(particle_set_t), pointer :: pset_ptr
type(string_t) :: sample
integer :: u_file, iostat
character(215) :: buffer
write (u, "(A)") "* Test output: eio_lcio_1"
write (u, "(A)") "* Purpose: write a LCIO file"
write (u, "(A)")
write (u, "(A)") "* Initialize test process"
call eio_prepare_test (event)
call data%init (1)
data%n_beam = 2
data%unweighted = .true.
data%norm_mode = NORM_UNIT
data%pdg_beam = 25
data%energy_beam = 500
data%proc_num_id = [42]
data%cross_section(1) = 100
data%error(1) = 1
data%total_cross_section = sum (data%cross_section)
write (u, "(A)")
write (u, "(A)") "* Generate and write an event"
write (u, "(A)")
sample = "eio_lcio_1"
allocate (eio_lcio_t :: eio)
select type (eio)
type is (eio_lcio_t)
call eio%set_parameters ()
end select
call eio%init_out (sample, data)
call event%generate (1, [0._default, 0._default])
call event%set_index (77)
call event%pacify_particle_set ()
call eio%output (event, i_prc = 1)
call eio%write (u)
call eio%final ()
write (u, "(A)")
write (u, "(A)") "* Reset data"
write (u, "(A)")
deallocate (eio)
allocate (eio_lcio_t :: eio)
select type (eio)
type is (eio_lcio_t)
call eio%set_parameters ()
end select
call eio%write (u)
write (u, "(A)")
write (u, "(A)") "* Write LCIO file contents to ASCII file"
write (u, "(A)")
select type (eio)
type is (eio_lcio_t)
call lcio_event_init (eio%lcio_event, &
proc_id = 42, &
event_id = event%get_index ())
pset_ptr => event%get_particle_set_ptr ()
call lcio_event_from_particle_set &
(eio%lcio_event, pset_ptr)
call write_lcio_event (eio%lcio_event, var_str ("test_file.slcio"))
call lcio_event_final (eio%lcio_event, .true.)
end select
write (u, "(A)")
write (u, "(A)") "* Read in ASCII contents of LCIO file"
write (u, "(A)")
u_file = free_unit ()
open (u_file, file = "test_file.slcio", &
action = "read", status = "old")
do
read (u_file, "(A)", iostat = iostat) buffer
if (iostat /= 0) exit
if (trim (buffer) == "") cycle
if (buffer(1:12) == " - timestamp") cycle
if (buffer(1:6) == " date:") cycle
write (u, "(A)") trim (buffer)
end do
close (u_file)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call eio_cleanup_test (event)
write (u, "(A)")
write (u, "(A)") "* Test output end: eio_lcio_1"
end subroutine eio_lcio_1
@ %def eio_lcio_1
@ Test also the reading of LCIO events.
<<EIO LCIO: execute tests>>=
call test (eio_lcio_2, "eio_lcio_2", &
"read event contents", &
u, results)
<<EIO LCIO: test declarations>>=
public :: eio_lcio_2
<<EIO LCIO: tests>>=
subroutine eio_lcio_2 (u)
integer, intent(in) :: u
class(model_data_t), pointer :: fallback_model
class(generic_event_t), pointer :: event
type(event_sample_data_t) :: data
class(eio_t), allocatable :: eio
type(string_t) :: sample
integer :: iostat, i_prc
write (u, "(A)") "* Test output: eio_lcio_2"
write (u, "(A)") "* Purpose: read a LCIO event"
write (u, "(A)")
write (u, "(A)") "* Initialize test process"
allocate (fallback_model)
call eio_prepare_fallback_model (fallback_model)
call eio_prepare_test (event)
call data%init (1)
data%n_beam = 2
data%unweighted = .true.
data%norm_mode = NORM_UNIT
data%pdg_beam = 25
data%energy_beam = 500
data%proc_num_id = [42]
data%cross_section(1) = 100
data%error(1) = 1
data%total_cross_section = sum (data%cross_section)
write (u, "(A)")
write (u, "(A)") "* Generate and write an event"
write (u, "(A)")
sample = "eio_lcio_2"
allocate (eio_lcio_t :: eio)
select type (eio)
type is (eio_lcio_t)
call eio%set_parameters (recover_beams = .false.)
end select
call eio%set_fallback_model (fallback_model)
call eio%init_out (sample, data)
call event%generate (1, [0._default, 0._default])
call event%set_index (88)
call event%evaluate_expressions ()
call event%pacify_particle_set ()
call eio%output (event, i_prc = 1)
call eio%write (u)
call eio%final ()
deallocate (eio)
call event%reset_contents ()
call event%reset_index ()
write (u, "(A)")
write (u, "(A)") "* Initialize"
write (u, "(A)")
allocate (eio_lcio_t :: eio)
select type (eio)
type is (eio_lcio_t)
call eio%set_parameters (recover_beams = .false.)
end select
call eio%set_fallback_model (fallback_model)
call data%init (1)
data%n_beam = 2
data%unweighted = .true.
data%norm_mode = NORM_UNIT
data%pdg_beam = 25
data%energy_beam = 500
data%proc_num_id = [42]
call data%write (u)
write (u, *)
write (u, "(A)") "* Initialize"
write (u, "(A)")
call eio%init_in (sample, data)
call eio%write (u)
write (u, "(A)")
write (u, "(A)") "* Read event"
write (u, "(A)")
call eio%input_i_prc (i_prc, iostat)
select type (eio)
type is (eio_lcio_t)
write (u, "(A,I0,A,I0)") "Found process #", i_prc, &
" with ID = ", eio%proc_num_id(i_prc)
end select
call eio%input_event (event, iostat)
call event%write (u)
write (u, "(A)")
write (u, "(A)") "* Read closing"
write (u, "(A)")
call eio%input_i_prc (i_prc, iostat)
write (u, "(A,I0)") "iostat = ", iostat
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call eio%final ()
call eio_cleanup_test (event)
call eio_cleanup_fallback_model (fallback_model)
deallocate (fallback_model)
write (u, "(A)")
write (u, "(A)") "* Test output end: eio_lcio_2"
end subroutine eio_lcio_2
@ %def eio_lcio_2
Index: trunk/src/types/types.nw
===================================================================
--- trunk/src/types/types.nw (revision 8482)
+++ trunk/src/types/types.nw (revision 8483)
@@ -1,7940 +1,7940 @@
%% -*- ess-noweb-default-code-mode: f90-mode; noweb-default-code-mode: f90-mode; -*-
% WHIZARD code as NOWEB source: common types and objects
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\chapter{Sindarin Built-In Types}
\includemodulegraph{types}
Here, we define a couple of types and objects which are useful both
internally for \whizard, and visible to the user, so they correspond
to Sindarin types.
\begin{description}
\item[particle\_specifiers]
Expressions for particles and particle alternatives, involving
particle names.
\item[pdg\_arrays]
Integer (PDG) codes for particles. Useful for particle aliases
(e.g., 'quark' for $u,d,s$ etc.).
\item[jets]
Define (pseudo)jets as objects. Functional only if the [[fastjet]] library
is linked. (This may change in the future.)
\item[subevents]
Particle collections built from event records, for use in analysis and other
Sindarin expressions
\item[analysis]
Observables, histograms, and plots.
\end{description}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{Particle Specifiers}
In this module we introduce a type for specifying a particle or particle
alternative. In addition to the particle specifiers (strings separated by
colons), the type contains an optional flag [[polarized]] and a string
[[decay]]. If the [[polarized]] flag is set, particle polarization
information should be kept when generating events for this process. If the
[[decay]] string is set, it is the ID of a decay process which should be
applied to this particle when generating events.
In input/output form, the [[polarized]] flag is indicated by an asterisk
[[(*)]] in brackets, and the [[decay]] is indicated by its ID in brackets.
The [[read]] and [[write]] procedures in this module are not type-bound but
generic procedures which handle scalar and array arguments.
<<[[particle_specifiers.f90]]>>=
<<File header>>
module particle_specifiers
<<Use strings>>
use io_units
use diagnostics
<<Standard module head>>
<<Particle specifiers: public>>
<<Particle specifiers: types>>
<<Particle specifiers: interfaces>>
contains
<<Particle specifiers: procedures>>
end module particle_specifiers
@ %def particle_specifiers
@
\subsection{Base type}
This is an abstract type which can hold a single particle or an expression.
<<Particle specifiers: types>>=
type, abstract :: prt_spec_expr_t
contains
<<Particle specifiers: prt spec expr: TBP>>
end type prt_spec_expr_t
@ %def prt_expr_t
@ Output, as a string.
<<Particle specifiers: prt spec expr: TBP>>=
procedure (prt_spec_expr_to_string), deferred :: to_string
<<Particle specifiers: interfaces>>=
abstract interface
function prt_spec_expr_to_string (object) result (string)
import
class(prt_spec_expr_t), intent(in) :: object
type(string_t) :: string
end function prt_spec_expr_to_string
end interface
@ %def prt_spec_expr_to_string
@ Call an [[expand]] method for all enclosed subexpressions (before handling
the current expression).
<<Particle specifiers: prt spec expr: TBP>>=
procedure (prt_spec_expr_expand_sub), deferred :: expand_sub
<<Particle specifiers: interfaces>>=
abstract interface
subroutine prt_spec_expr_expand_sub (object)
import
class(prt_spec_expr_t), intent(inout) :: object
end subroutine prt_spec_expr_expand_sub
end interface
@ %def prt_spec_expr_expand_sub
@
\subsection{Wrapper type}
This wrapper can hold a particle expression of any kind. We need it so we can
make variadic arrays.
<<Particle specifiers: public>>=
public :: prt_expr_t
<<Particle specifiers: types>>=
type :: prt_expr_t
class(prt_spec_expr_t), allocatable :: x
contains
<<Particle specifiers: prt expr: TBP>>
end type prt_expr_t
@ %def prt_expr_t
@ Output as a string: delegate.
<<Particle specifiers: prt expr: TBP>>=
procedure :: to_string => prt_expr_to_string
<<Particle specifiers: procedures>>=
recursive function prt_expr_to_string (object) result (string)
class(prt_expr_t), intent(in) :: object
type(string_t) :: string
if (allocated (object%x)) then
string = object%x%to_string ()
else
string = ""
end if
end function prt_expr_to_string
@ %def prt_expr_to_string
@ Allocate the expression as a particle specifier and copy the value.
<<Particle specifiers: prt expr: TBP>>=
procedure :: init_spec => prt_expr_init_spec
<<Particle specifiers: procedures>>=
subroutine prt_expr_init_spec (object, spec)
class(prt_expr_t), intent(out) :: object
type(prt_spec_t), intent(in) :: spec
allocate (prt_spec_t :: object%x)
select type (x => object%x)
type is (prt_spec_t)
x = spec
end select
end subroutine prt_expr_init_spec
@ %def prt_expr_init_spec
@ Allocate as a list/sum and allocate for a given length
<<Particle specifiers: prt expr: TBP>>=
procedure :: init_list => prt_expr_init_list
procedure :: init_sum => prt_expr_init_sum
<<Particle specifiers: procedures>>=
subroutine prt_expr_init_list (object, n)
class(prt_expr_t), intent(out) :: object
integer, intent(in) :: n
allocate (prt_spec_list_t :: object%x)
select type (x => object%x)
type is (prt_spec_list_t)
allocate (x%expr (n))
end select
end subroutine prt_expr_init_list
subroutine prt_expr_init_sum (object, n)
class(prt_expr_t), intent(out) :: object
integer, intent(in) :: n
allocate (prt_spec_sum_t :: object%x)
select type (x => object%x)
type is (prt_spec_sum_t)
allocate (x%expr (n))
end select
end subroutine prt_expr_init_sum
@ %def prt_expr_init_list
@ %def prt_expr_init_sum
@ Return the number of terms. This is unity, except if the expression is a
sum.
<<Particle specifiers: prt expr: TBP>>=
procedure :: get_n_terms => prt_expr_get_n_terms
<<Particle specifiers: procedures>>=
function prt_expr_get_n_terms (object) result (n)
class(prt_expr_t), intent(in) :: object
integer :: n
if (allocated (object%x)) then
select type (x => object%x)
type is (prt_spec_sum_t)
n = size (x%expr)
class default
n = 1
end select
else
n = 0
end if
end function prt_expr_get_n_terms
@ %def prt_expr_get_n_terms
@ Transform one of the terms, as returned by the previous method, to an array
of particle specifiers. The array has more than one entry if the selected
term is a list. This makes sense only if the expression has been completely
expanded, so the list contains only atoms.
<<Particle specifiers: prt expr: TBP>>=
procedure :: term_to_array => prt_expr_term_to_array
<<Particle specifiers: procedures>>=
recursive subroutine prt_expr_term_to_array (object, array, i)
class(prt_expr_t), intent(in) :: object
type(prt_spec_t), dimension(:), intent(inout), allocatable :: array
integer, intent(in) :: i
integer :: j
if (allocated (array)) deallocate (array)
select type (x => object%x)
type is (prt_spec_t)
allocate (array (1))
array(1) = x
type is (prt_spec_list_t)
allocate (array (size (x%expr)))
do j = 1, size (array)
select type (y => x%expr(j)%x)
type is (prt_spec_t)
array(j) = y
end select
end do
type is (prt_spec_sum_t)
call x%expr(i)%term_to_array (array, 1)
end select
end subroutine prt_expr_term_to_array
@ %def prt_expr_term_to_array
@
\subsection{The atomic type}
The trivial case is a single particle, including optional decay and
polarization attributes.
\subsubsection{Definition}
The particle is unstable if the [[decay]] array is allocated. The
[[polarized]] flag and decays may not be set simultaneously.
<<Particle specifiers: public>>=
public :: prt_spec_t
<<Particle specifiers: types>>=
type, extends (prt_spec_expr_t) :: prt_spec_t
private
type(string_t) :: name
logical :: polarized = .false.
type(string_t), dimension(:), allocatable :: decay
contains
<<Particle specifiers: prt spec: TBP>>
end type prt_spec_t
@ %def prt_spec_t
@
\subsubsection{I/O}
Output. Old-style subroutines.
<<Particle specifiers: public>>=
public :: prt_spec_write
<<Particle specifiers: interfaces>>=
interface prt_spec_write
module procedure prt_spec_write1
module procedure prt_spec_write2
end interface prt_spec_write
<<Particle specifiers: procedures>>=
subroutine prt_spec_write1 (object, unit, advance)
type(prt_spec_t), intent(in) :: object
integer, intent(in), optional :: unit
character(len=*), intent(in), optional :: advance
character(3) :: adv
integer :: u
u = given_output_unit (unit)
adv = "yes"; if (present (advance)) adv = advance
write (u, "(A)", advance = adv) char (object%to_string ())
end subroutine prt_spec_write1
@ %def prt_spec_write1
@ Write an array as a list of particle specifiers.
<<Particle specifiers: procedures>>=
subroutine prt_spec_write2 (prt_spec, unit, advance)
type(prt_spec_t), dimension(:), intent(in) :: prt_spec
integer, intent(in), optional :: unit
character(len=*), intent(in), optional :: advance
character(3) :: adv
integer :: u, i
u = given_output_unit (unit)
adv = "yes"; if (present (advance)) adv = advance
do i = 1, size (prt_spec)
if (i > 1) write (u, "(A)", advance="no") ", "
call prt_spec_write (prt_spec(i), u, advance="no")
end do
write (u, "(A)", advance = adv)
end subroutine prt_spec_write2
@ %def prt_spec_write2
@ Read. Input may be string or array of strings.
<<Particle specifiers: public>>=
public :: prt_spec_read
<<Particle specifiers: interfaces>>=
interface prt_spec_read
module procedure prt_spec_read1
module procedure prt_spec_read2
end interface prt_spec_read
@ Read a single particle specifier
<<Particle specifiers: procedures>>=
pure subroutine prt_spec_read1 (prt_spec, string)
type(prt_spec_t), intent(out) :: prt_spec
type(string_t), intent(in) :: string
type(string_t) :: arg, buffer
integer :: b1, b2, c, n, i
b1 = scan (string, "(")
b2 = scan (string, ")")
if (b1 == 0) then
prt_spec%name = trim (adjustl (string))
else
prt_spec%name = trim (adjustl (extract (string, 1, b1-1)))
arg = trim (adjustl (extract (string, b1+1, b2-1)))
if (arg == "*") then
prt_spec%polarized = .true.
else
n = 0
buffer = arg
do
if (verify (buffer, " ") == 0) exit
n = n + 1
c = scan (buffer, "+")
if (c == 0) exit
buffer = extract (buffer, c+1)
end do
allocate (prt_spec%decay (n))
buffer = arg
do i = 1, n
c = scan (buffer, "+")
if (c == 0) c = len (buffer) + 1
prt_spec%decay(i) = trim (adjustl (extract (buffer, 1, c-1)))
buffer = extract (buffer, c+1)
end do
end if
end if
end subroutine prt_spec_read1
@ %def prt_spec_read1
@ Read a particle specifier array, given as a single string. The
array is allocated to the correct size.
<<Particle specifiers: procedures>>=
pure subroutine prt_spec_read2 (prt_spec, string)
type(prt_spec_t), dimension(:), intent(out), allocatable :: prt_spec
type(string_t), intent(in) :: string
type(string_t) :: buffer
integer :: c, i, n
n = 0
buffer = string
do
n = n + 1
c = scan (buffer, ",")
if (c == 0) exit
buffer = extract (buffer, c+1)
end do
allocate (prt_spec (n))
buffer = string
do i = 1, size (prt_spec)
c = scan (buffer, ",")
if (c == 0) c = len (buffer) + 1
call prt_spec_read (prt_spec(i), &
trim (adjustl (extract (buffer, 1, c-1))))
buffer = extract (buffer, c+1)
end do
end subroutine prt_spec_read2
@ %def prt_spec_read2
@
\subsubsection{Constructor}
Initialize a particle specifier.
<<Particle specifiers: public>>=
public :: new_prt_spec
<<Particle specifiers: interfaces>>=
interface new_prt_spec
module procedure new_prt_spec
module procedure new_prt_spec_polarized
module procedure new_prt_spec_unstable
end interface new_prt_spec
<<Particle specifiers: procedures>>=
elemental function new_prt_spec (name) result (prt_spec)
type(string_t), intent(in) :: name
type(prt_spec_t) :: prt_spec
prt_spec%name = name
end function new_prt_spec
elemental function new_prt_spec_polarized (name, polarized) result (prt_spec)
type(string_t), intent(in) :: name
logical, intent(in) :: polarized
type(prt_spec_t) :: prt_spec
prt_spec%name = name
prt_spec%polarized = polarized
end function new_prt_spec_polarized
pure function new_prt_spec_unstable (name, decay) result (prt_spec)
type(string_t), intent(in) :: name
type(string_t), dimension(:), intent(in) :: decay
type(prt_spec_t) :: prt_spec
prt_spec%name = name
allocate (prt_spec%decay (size (decay)))
prt_spec%decay = decay
end function new_prt_spec_unstable
@ %def new_prt_spec
@
\subsubsection{Access Methods}
Return the particle name without qualifiers
<<Particle specifiers: prt spec: TBP>>=
procedure :: get_name => prt_spec_get_name
<<Particle specifiers: procedures>>=
elemental function prt_spec_get_name (prt_spec) result (name)
class(prt_spec_t), intent(in) :: prt_spec
type(string_t) :: name
name = prt_spec%name
end function prt_spec_get_name
@ %def prt_spec_get_name
@ Return the name with qualifiers
<<Particle specifiers: prt spec: TBP>>=
procedure :: to_string => prt_spec_to_string
<<Particle specifiers: procedures>>=
function prt_spec_to_string (object) result (string)
class(prt_spec_t), intent(in) :: object
type(string_t) :: string
integer :: i
string = object%name
if (allocated (object%decay)) then
string = string // "("
do i = 1, size (object%decay)
if (i > 1) string = string // " + "
string = string // object%decay(i)
end do
string = string // ")"
else if (object%polarized) then
string = string // "(*)"
end if
end function prt_spec_to_string
@ %def prt_spec_to_string
@ Return the polarization flag
<<Particle specifiers: prt spec: TBP>>=
procedure :: is_polarized => prt_spec_is_polarized
<<Particle specifiers: procedures>>=
elemental function prt_spec_is_polarized (prt_spec) result (flag)
class(prt_spec_t), intent(in) :: prt_spec
logical :: flag
flag = prt_spec%polarized
end function prt_spec_is_polarized
@ %def prt_spec_is_polarized
@ The particle is unstable if there is a decay array.
<<Particle specifiers: prt spec: TBP>>=
procedure :: is_unstable => prt_spec_is_unstable
<<Particle specifiers: procedures>>=
elemental function prt_spec_is_unstable (prt_spec) result (flag)
class(prt_spec_t), intent(in) :: prt_spec
logical :: flag
flag = allocated (prt_spec%decay)
end function prt_spec_is_unstable
@ %def prt_spec_is_unstable
@ Return the number of decay channels
<<Particle specifiers: prt spec: TBP>>=
procedure :: get_n_decays => prt_spec_get_n_decays
<<Particle specifiers: procedures>>=
elemental function prt_spec_get_n_decays (prt_spec) result (n)
class(prt_spec_t), intent(in) :: prt_spec
integer :: n
if (allocated (prt_spec%decay)) then
n = size (prt_spec%decay)
else
n = 0
end if
end function prt_spec_get_n_decays
@ %def prt_spec_get_n_decays
@ Return the decay channels
<<Particle specifiers: prt spec: TBP>>=
procedure :: get_decays => prt_spec_get_decays
<<Particle specifiers: procedures>>=
subroutine prt_spec_get_decays (prt_spec, decay)
class(prt_spec_t), intent(in) :: prt_spec
type(string_t), dimension(:), allocatable, intent(out) :: decay
if (allocated (prt_spec%decay)) then
allocate (decay (size (prt_spec%decay)))
decay = prt_spec%decay
else
allocate (decay (0))
end if
end subroutine prt_spec_get_decays
@ %def prt_spec_get_decays
@
\subsubsection{Miscellaneous}
There is nothing to expand here:
<<Particle specifiers: prt spec: TBP>>=
procedure :: expand_sub => prt_spec_expand_sub
<<Particle specifiers: procedures>>=
subroutine prt_spec_expand_sub (object)
class(prt_spec_t), intent(inout) :: object
end subroutine prt_spec_expand_sub
@ %def prt_spec_expand_sub
@
\subsection{List}
A list of particle specifiers, indicating, e.g., the final state of a
process.
<<Particle specifiers: public>>=
public :: prt_spec_list_t
<<Particle specifiers: types>>=
type, extends (prt_spec_expr_t) :: prt_spec_list_t
type(prt_expr_t), dimension(:), allocatable :: expr
contains
<<Particle specifiers: prt spec list: TBP>>
end type prt_spec_list_t
@ %def prt_spec_list_t
@ Output: Concatenate the components. Insert brackets if the component is
also a list. The components of the [[expr]] array, if any, should all be
filled.
<<Particle specifiers: prt spec list: TBP>>=
procedure :: to_string => prt_spec_list_to_string
<<Particle specifiers: procedures>>=
recursive function prt_spec_list_to_string (object) result (string)
class(prt_spec_list_t), intent(in) :: object
type(string_t) :: string
integer :: i
string = ""
if (allocated (object%expr)) then
do i = 1, size (object%expr)
if (i > 1) string = string // ", "
select type (x => object%expr(i)%x)
type is (prt_spec_list_t)
string = string // "(" // x%to_string () // ")"
class default
string = string // x%to_string ()
end select
end do
end if
end function prt_spec_list_to_string
@ %def prt_spec_list_to_string
@ Flatten: if there is a subexpression which is also a list, include the
components as direct members of the current list.
<<Particle specifiers: prt spec list: TBP>>=
procedure :: flatten => prt_spec_list_flatten
<<Particle specifiers: procedures>>=
subroutine prt_spec_list_flatten (object)
class(prt_spec_list_t), intent(inout) :: object
type(prt_expr_t), dimension(:), allocatable :: tmp_expr
integer :: i, n_flat, i_flat
n_flat = 0
do i = 1, size (object%expr)
select type (y => object%expr(i)%x)
type is (prt_spec_list_t)
n_flat = n_flat + size (y%expr)
class default
n_flat = n_flat + 1
end select
end do
if (n_flat > size (object%expr)) then
allocate (tmp_expr (n_flat))
i_flat = 0
do i = 1, size (object%expr)
select type (y => object%expr(i)%x)
type is (prt_spec_list_t)
tmp_expr (i_flat + 1 : i_flat + size (y%expr)) = y%expr
i_flat = i_flat + size (y%expr)
class default
tmp_expr (i_flat + 1) = object%expr(i)
i_flat = i_flat + 1
end select
end do
end if
if (allocated (tmp_expr)) &
call move_alloc (from = tmp_expr, to = object%expr)
end subroutine prt_spec_list_flatten
@ %def prt_spec_list_flatten
@ Convert a list of sums into a sum of lists. (Subexpressions which are not
sums are left untouched.)
<<Particle specifiers: procedures>>=
subroutine distribute_prt_spec_list (object)
class(prt_spec_expr_t), intent(inout), allocatable :: object
class(prt_spec_expr_t), allocatable :: new_object
integer, dimension(:), allocatable :: n, ii
integer :: k, n_expr, n_terms, i_term
select type (object)
type is (prt_spec_list_t)
n_expr = size (object%expr)
allocate (n (n_expr), source = 1)
allocate (ii (n_expr), source = 1)
do k = 1, size (object%expr)
select type (y => object%expr(k)%x)
type is (prt_spec_sum_t)
n(k) = size (y%expr)
end select
end do
n_terms = product (n)
if (n_terms > 1) then
allocate (prt_spec_sum_t :: new_object)
select type (new_object)
type is (prt_spec_sum_t)
allocate (new_object%expr (n_terms))
do i_term = 1, n_terms
allocate (prt_spec_list_t :: new_object%expr(i_term)%x)
select type (x => new_object%expr(i_term)%x)
type is (prt_spec_list_t)
allocate (x%expr (n_expr))
do k = 1, n_expr
select type (y => object%expr(k)%x)
type is (prt_spec_sum_t)
x%expr(k) = y%expr(ii(k))
class default
x%expr(k) = object%expr(k)
end select
end do
end select
INCR_INDEX: do k = n_expr, 1, -1
if (ii(k) < n(k)) then
ii(k) = ii(k) + 1
exit INCR_INDEX
else
ii(k) = 1
end if
end do INCR_INDEX
end do
end select
end if
end select
if (allocated (new_object)) call move_alloc (from = new_object, to = object)
end subroutine distribute_prt_spec_list
@ %def distribute_prt_spec_list
@ Apply [[expand]] to all components of the list.
<<Particle specifiers: prt spec list: TBP>>=
procedure :: expand_sub => prt_spec_list_expand_sub
<<Particle specifiers: procedures>>=
recursive subroutine prt_spec_list_expand_sub (object)
class(prt_spec_list_t), intent(inout) :: object
integer :: i
if (allocated (object%expr)) then
do i = 1, size (object%expr)
call object%expr(i)%expand ()
end do
end if
end subroutine prt_spec_list_expand_sub
@ %def prt_spec_list_expand_sub
@
\subsection{Sum}
A sum of particle specifiers, indicating, e.g., a sum of final states.
<<Particle specifiers: public>>=
public :: prt_spec_sum_t
<<Particle specifiers: types>>=
type, extends (prt_spec_expr_t) :: prt_spec_sum_t
type(prt_expr_t), dimension(:), allocatable :: expr
contains
<<Particle specifiers: prt spec sum: TBP>>
end type prt_spec_sum_t
@ %def prt_spec_sum_t
@ Output: Concatenate the components. Insert brackets if the component is
a list or also a sum. The components of the [[expr]] array, if any, should
all be filled.
<<Particle specifiers: prt spec sum: TBP>>=
procedure :: to_string => prt_spec_sum_to_string
<<Particle specifiers: procedures>>=
recursive function prt_spec_sum_to_string (object) result (string)
class(prt_spec_sum_t), intent(in) :: object
type(string_t) :: string
integer :: i
string = ""
if (allocated (object%expr)) then
do i = 1, size (object%expr)
if (i > 1) string = string // " + "
select type (x => object%expr(i)%x)
type is (prt_spec_list_t)
string = string // "(" // x%to_string () // ")"
type is (prt_spec_sum_t)
string = string // "(" // x%to_string () // ")"
class default
string = string // x%to_string ()
end select
end do
end if
end function prt_spec_sum_to_string
@ %def prt_spec_sum_to_string
@ Flatten: if there is a subexpression which is also a sum, include the
components as direct members of the current sum.
This is identical to [[prt_spec_list_flatten]] above, except for the type.
<<Particle specifiers: prt spec sum: TBP>>=
procedure :: flatten => prt_spec_sum_flatten
<<Particle specifiers: procedures>>=
subroutine prt_spec_sum_flatten (object)
class(prt_spec_sum_t), intent(inout) :: object
type(prt_expr_t), dimension(:), allocatable :: tmp_expr
integer :: i, n_flat, i_flat
n_flat = 0
do i = 1, size (object%expr)
select type (y => object%expr(i)%x)
type is (prt_spec_sum_t)
n_flat = n_flat + size (y%expr)
class default
n_flat = n_flat + 1
end select
end do
if (n_flat > size (object%expr)) then
allocate (tmp_expr (n_flat))
i_flat = 0
do i = 1, size (object%expr)
select type (y => object%expr(i)%x)
type is (prt_spec_sum_t)
tmp_expr (i_flat + 1 : i_flat + size (y%expr)) = y%expr
i_flat = i_flat + size (y%expr)
class default
tmp_expr (i_flat + 1) = object%expr(i)
i_flat = i_flat + 1
end select
end do
end if
if (allocated (tmp_expr)) &
call move_alloc (from = tmp_expr, to = object%expr)
end subroutine prt_spec_sum_flatten
@ %def prt_spec_sum_flatten
@ Apply [[expand]] to all terms in the sum.
<<Particle specifiers: prt spec sum: TBP>>=
procedure :: expand_sub => prt_spec_sum_expand_sub
<<Particle specifiers: procedures>>=
recursive subroutine prt_spec_sum_expand_sub (object)
class(prt_spec_sum_t), intent(inout) :: object
integer :: i
if (allocated (object%expr)) then
do i = 1, size (object%expr)
call object%expr(i)%expand ()
end do
end if
end subroutine prt_spec_sum_expand_sub
@ %def prt_spec_sum_expand_sub
@
\subsection{Expression Expansion}
The [[expand]] method transforms each particle specifier expression into a sum
of lists, according to the rules
\begin{align}
a, (b, c) &\to a, b, c
\\
a + (b + c) &\to a + b + c
\\
a, b + c &\to (a, b) + (a, c)
\end{align}
Note that the precedence of comma and plus are opposite to this expansion, so
the parentheses in the final expression are necessary.
We assume that subexpressions are filled, i.e., arrays are allocated.
<<Particle specifiers: prt expr: TBP>>=
procedure :: expand => prt_expr_expand
<<Particle specifiers: procedures>>=
recursive subroutine prt_expr_expand (expr)
class(prt_expr_t), intent(inout) :: expr
if (allocated (expr%x)) then
call distribute_prt_spec_list (expr%x)
call expr%x%expand_sub ()
select type (x => expr%x)
type is (prt_spec_list_t)
call x%flatten ()
type is (prt_spec_sum_t)
call x%flatten ()
end select
end if
end subroutine prt_expr_expand
@ %def prt_expr_expand
@
\subsection{Unit Tests}
Test module, followed by the corresponding implementation module.
<<[[particle_specifiers_ut.f90]]>>=
<<File header>>
module particle_specifiers_ut
use unit_tests
use particle_specifiers_uti
<<Standard module head>>
<<Particle specifiers: public test>>
contains
<<Particle specifiers: test driver>>
end module particle_specifiers_ut
@ %def particle_specifiers_ut
@
<<[[particle_specifiers_uti.f90]]>>=
<<File header>>
module particle_specifiers_uti
<<Use strings>>
use particle_specifiers
<<Standard module head>>
<<Particle specifiers: test declarations>>
contains
<<Particle specifiers: tests>>
end module particle_specifiers_uti
@ %def particle_specifiers_ut
@ API: driver for the unit tests below.
<<Particle specifiers: public test>>=
public :: particle_specifiers_test
<<Particle specifiers: test driver>>=
subroutine particle_specifiers_test (u, results)
integer, intent(in) :: u
type(test_results_t), intent(inout) :: results
<<Particle specifiers: execute tests>>
end subroutine particle_specifiers_test
@ %def particle_specifiers_test
@
\subsubsection{Particle specifier array}
Define, read and write an array of particle specifiers.
<<Particle specifiers: execute tests>>=
call test (particle_specifiers_1, "particle_specifiers_1", &
"Handle particle specifiers", &
u, results)
<<Particle specifiers: test declarations>>=
public :: particle_specifiers_1
<<Particle specifiers: tests>>=
subroutine particle_specifiers_1 (u)
integer, intent(in) :: u
type(prt_spec_t), dimension(:), allocatable :: prt_spec
type(string_t), dimension(:), allocatable :: decay
type(string_t), dimension(0) :: no_decay
integer :: i, j
write (u, "(A)") "* Test output: particle_specifiers_1"
write (u, "(A)") "* Purpose: Read and write a particle specifier array"
write (u, "(A)")
allocate (prt_spec (5))
prt_spec = [ &
new_prt_spec (var_str ("a")), &
new_prt_spec (var_str ("b"), .true.), &
new_prt_spec (var_str ("c"), [var_str ("dec1")]), &
new_prt_spec (var_str ("d"), [var_str ("dec1"), var_str ("dec2")]), &
new_prt_spec (var_str ("e"), no_decay) &
]
do i = 1, size (prt_spec)
write (u, "(A)") char (prt_spec(i)%to_string ())
end do
write (u, "(A)")
call prt_spec_read (prt_spec, &
var_str (" a, b( *), c( dec1), d (dec1 + dec2 ), e()"))
call prt_spec_write (prt_spec, u)
do i = 1, size (prt_spec)
write (u, "(A)")
write (u, "(A,A)") char (prt_spec(i)%get_name ()), ":"
write (u, "(A,L1)") "polarized = ", prt_spec(i)%is_polarized ()
write (u, "(A,L1)") "unstable = ", prt_spec(i)%is_unstable ()
write (u, "(A,I0)") "n_decays = ", prt_spec(i)%get_n_decays ()
call prt_spec(i)%get_decays (decay)
write (u, "(A)", advance="no") "decays ="
do j = 1, size (decay)
write (u, "(1x,A)", advance="no") char (decay(j))
end do
write (u, "(A)")
end do
write (u, "(A)")
write (u, "(A)") "* Test output end: particle_specifiers_1"
end subroutine particle_specifiers_1
@ %def particle_specifiers_1
@
\subsubsection{Particle specifier expressions}
Nested expressions (only basic particles, no decay specs).
<<Particle specifiers: execute tests>>=
call test (particle_specifiers_2, "particle_specifiers_2", &
"Particle specifier expressions", &
u, results)
<<Particle specifiers: test declarations>>=
public :: particle_specifiers_2
<<Particle specifiers: tests>>=
subroutine particle_specifiers_2 (u)
integer, intent(in) :: u
type(prt_spec_t) :: a, b, c, d, e, f
type(prt_expr_t) :: pe1, pe2, pe3
type(prt_expr_t) :: pe4, pe5, pe6, pe7, pe8, pe9
integer :: i
type(prt_spec_t), dimension(:), allocatable :: pa
write (u, "(A)") "* Test output: particle_specifiers_2"
write (u, "(A)") "* Purpose: Create and display particle expressions"
write (u, "(A)")
write (u, "(A)") "* Basic expressions"
write (u, *)
a = new_prt_spec (var_str ("a"))
b = new_prt_spec (var_str ("b"))
c = new_prt_spec (var_str ("c"))
d = new_prt_spec (var_str ("d"))
e = new_prt_spec (var_str ("e"))
f = new_prt_spec (var_str ("f"))
call pe1%init_spec (a)
write (u, "(A)") char (pe1%to_string ())
call pe2%init_sum (2)
select type (x => pe2%x)
type is (prt_spec_sum_t)
call x%expr(1)%init_spec (a)
call x%expr(2)%init_spec (b)
end select
write (u, "(A)") char (pe2%to_string ())
call pe3%init_list (2)
select type (x => pe3%x)
type is (prt_spec_list_t)
call x%expr(1)%init_spec (a)
call x%expr(2)%init_spec (b)
end select
write (u, "(A)") char (pe3%to_string ())
write (u, *)
write (u, "(A)") "* Nested expressions"
write (u, *)
call pe4%init_list (2)
select type (x => pe4%x)
type is (prt_spec_list_t)
call x%expr(1)%init_sum (2)
select type (y => x%expr(1)%x)
type is (prt_spec_sum_t)
call y%expr(1)%init_spec (a)
call y%expr(2)%init_spec (b)
end select
call x%expr(2)%init_spec (c)
end select
write (u, "(A)") char (pe4%to_string ())
call pe5%init_list (2)
select type (x => pe5%x)
type is (prt_spec_list_t)
call x%expr(1)%init_list (2)
select type (y => x%expr(1)%x)
type is (prt_spec_list_t)
call y%expr(1)%init_spec (a)
call y%expr(2)%init_spec (b)
end select
call x%expr(2)%init_spec (c)
end select
write (u, "(A)") char (pe5%to_string ())
call pe6%init_sum (2)
select type (x => pe6%x)
type is (prt_spec_sum_t)
call x%expr(1)%init_spec (a)
call x%expr(2)%init_sum (2)
select type (y => x%expr(2)%x)
type is (prt_spec_sum_t)
call y%expr(1)%init_spec (b)
call y%expr(2)%init_spec (c)
end select
end select
write (u, "(A)") char (pe6%to_string ())
call pe7%init_list (2)
select type (x => pe7%x)
type is (prt_spec_list_t)
call x%expr(1)%init_sum (2)
select type (y => x%expr(1)%x)
type is (prt_spec_sum_t)
call y%expr(1)%init_spec (a)
call y%expr(2)%init_list (2)
select type (z => y%expr(2)%x)
type is (prt_spec_list_t)
call z%expr(1)%init_spec (b)
call z%expr(2)%init_spec (c)
end select
end select
call x%expr(2)%init_spec (d)
end select
write (u, "(A)") char (pe7%to_string ())
call pe8%init_sum (2)
select type (x => pe8%x)
type is (prt_spec_sum_t)
call x%expr(1)%init_list (2)
select type (y => x%expr(1)%x)
type is (prt_spec_list_t)
call y%expr(1)%init_spec (a)
call y%expr(2)%init_spec (b)
end select
call x%expr(2)%init_list (2)
select type (y => x%expr(2)%x)
type is (prt_spec_list_t)
call y%expr(1)%init_spec (c)
call y%expr(2)%init_spec (d)
end select
end select
write (u, "(A)") char (pe8%to_string ())
call pe9%init_list (3)
select type (x => pe9%x)
type is (prt_spec_list_t)
call x%expr(1)%init_sum (2)
select type (y => x%expr(1)%x)
type is (prt_spec_sum_t)
call y%expr(1)%init_spec (a)
call y%expr(2)%init_spec (b)
end select
call x%expr(2)%init_spec (c)
call x%expr(3)%init_sum (3)
select type (y => x%expr(3)%x)
type is (prt_spec_sum_t)
call y%expr(1)%init_spec (d)
call y%expr(2)%init_spec (e)
call y%expr(3)%init_spec (f)
end select
end select
write (u, "(A)") char (pe9%to_string ())
write (u, *)
write (u, "(A)") "* Expand as sum"
write (u, *)
call pe1%expand ()
write (u, "(A)") char (pe1%to_string ())
call pe4%expand ()
write (u, "(A)") char (pe4%to_string ())
call pe5%expand ()
write (u, "(A)") char (pe5%to_string ())
call pe6%expand ()
write (u, "(A)") char (pe6%to_string ())
call pe7%expand ()
write (u, "(A)") char (pe7%to_string ())
call pe8%expand ()
write (u, "(A)") char (pe8%to_string ())
call pe9%expand ()
write (u, "(A)") char (pe9%to_string ())
write (u, *)
write (u, "(A)") "* Transform to arrays:"
write (u, "(A)") "* Atomic specifier"
do i = 1, pe1%get_n_terms ()
call pe1%term_to_array (pa, i)
call prt_spec_write (pa, u)
end do
write (u, *)
write (u, "(A)") "* List"
do i = 1, pe5%get_n_terms ()
call pe5%term_to_array (pa, i)
call prt_spec_write (pa, u)
end do
write (u, *)
write (u, "(A)") "* Sum of atoms"
do i = 1, pe6%get_n_terms ()
call pe6%term_to_array (pa, i)
call prt_spec_write (pa, u)
end do
write (u, *)
write (u, "(A)") "* Sum of lists"
do i = 1, pe9%get_n_terms ()
call pe9%term_to_array (pa, i)
call prt_spec_write (pa, u)
end do
write (u, "(A)")
write (u, "(A)") "* Test output end: particle_specifiers_2"
end subroutine particle_specifiers_2
@ %def particle_specifiers_2
@
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{PDG arrays}
For defining aliases, we introduce a special type which holds a set of
(integer) PDG codes.
<<[[pdg_arrays.f90]]>>=
<<File header>>
module pdg_arrays
use io_units
use sorting
use physics_defs, only: UNDEFINED
<<Standard module head>>
<<PDG arrays: public>>
<<PDG arrays: types>>
<<PDG arrays: interfaces>>
contains
<<PDG arrays: procedures>>
end module pdg_arrays
@ %def pdg_arrays
@
\subsection{Type definition}
Using an allocatable array eliminates the need for initializer and/or
finalizer.
<<PDG arrays: public>>=
public :: pdg_array_t
<<PDG arrays: types>>=
type :: pdg_array_t
private
integer, dimension(:), allocatable :: pdg
contains
<<PDG arrays: pdg array: TBP>>
end type pdg_array_t
@ %def pdg_array_t
@ Output
<<PDG arrays: public>>=
public :: pdg_array_write
<<PDG arrays: pdg array: TBP>>=
procedure :: write => pdg_array_write
<<PDG arrays: procedures>>=
subroutine pdg_array_write (aval, unit)
class(pdg_array_t), intent(in) :: aval
integer, intent(in), optional :: unit
integer :: u, i
u = given_output_unit (unit); if (u < 0) return
write (u, "(A)", advance="no") "PDG("
if (allocated (aval%pdg)) then
do i = 1, size (aval%pdg)
if (i > 1) write (u, "(A)", advance="no") ", "
write (u, "(I0)", advance="no") aval%pdg(i)
end do
end if
write (u, "(A)", advance="no") ")"
end subroutine pdg_array_write
@ %def pdg_array_write
@
<<PDG arrays: public>>=
public :: pdg_array_write_set
<<PDG arrays: procedures>>=
subroutine pdg_array_write_set (aval, unit)
type(pdg_array_t), intent(in), dimension(:) :: aval
integer, intent(in), optional :: unit
integer :: i
do i = 1, size (aval)
call aval(i)%write (unit)
print *, ''
end do
end subroutine pdg_array_write_set
@ %def pdg_array_write_set
@
\subsection{Basic operations}
Assignment. We define assignment from and to an integer array.
Note that the integer array, if it is the l.h.s., must be declared
allocatable by the caller.
<<PDG arrays: public>>=
public :: assignment(=)
<<PDG arrays: interfaces>>=
interface assignment(=)
module procedure pdg_array_from_int_array
module procedure pdg_array_from_int
module procedure int_array_from_pdg_array
end interface
<<PDG arrays: procedures>>=
subroutine pdg_array_from_int_array (aval, iarray)
type(pdg_array_t), intent(out) :: aval
integer, dimension(:), intent(in) :: iarray
allocate (aval%pdg (size (iarray)))
aval%pdg = iarray
end subroutine pdg_array_from_int_array
elemental subroutine pdg_array_from_int (aval, int)
type(pdg_array_t), intent(out) :: aval
integer, intent(in) :: int
allocate (aval%pdg (1))
aval%pdg = int
end subroutine pdg_array_from_int
subroutine int_array_from_pdg_array (iarray, aval)
integer, dimension(:), allocatable, intent(out) :: iarray
type(pdg_array_t), intent(in) :: aval
if (allocated (aval%pdg)) then
allocate (iarray (size (aval%pdg)))
iarray = aval%pdg
else
allocate (iarray (0))
end if
end subroutine int_array_from_pdg_array
@ %def pdg_array_from_int_array pdg_array_from_int int_array_from_pdg_array
@ Allocate space for a PDG array
<<PDG arrays: public>>=
public :: pdg_array_init
<<PDG arrays: procedures>>=
subroutine pdg_array_init (aval, n_elements)
type(pdg_array_t), intent(inout) :: aval
integer, intent(in) :: n_elements
allocate(aval%pdg(n_elements))
end subroutine pdg_array_init
@ %def pdg_array_init
@ Deallocate a previously allocated pdg array
<<PDG arrays: public>>=
public :: pdg_array_delete
<<PDG arrays: procedures>>=
subroutine pdg_array_delete (aval)
type(pdg_array_t), intent(inout) :: aval
if (allocated (aval%pdg)) deallocate (aval%pdg)
end subroutine pdg_array_delete
@ %def pdg_array_delete
@ Merge two pdg arrays, i.e. append a particle string to another leaving out doublettes
<<PDG arrays: public>>=
public :: pdg_array_merge
<<PDG arrays: procedures>>=
subroutine pdg_array_merge (aval1, aval2)
type(pdg_array_t), intent(inout) :: aval1
type(pdg_array_t), intent(in) :: aval2
type(pdg_array_t) :: aval
if (allocated (aval1%pdg) .and. allocated (aval2%pdg)) then
if (.not. any (aval1%pdg == aval2%pdg)) aval = aval1 // aval2
else if (allocated (aval1%pdg)) then
aval = aval1
else if (allocated (aval2%pdg)) then
aval = aval2
end if
call pdg_array_delete (aval1)
aval1 = aval%pdg
end subroutine pdg_array_merge
@ %def pdg_array_merge
@ Length of the array.
<<PDG arrays: public>>=
public :: pdg_array_get_length
<<PDG arrays: pdg array: TBP>>=
procedure :: get_length => pdg_array_get_length
<<PDG arrays: procedures>>=
elemental function pdg_array_get_length (aval) result (n)
class(pdg_array_t), intent(in) :: aval
integer :: n
if (allocated (aval%pdg)) then
n = size (aval%pdg)
else
n = 0
end if
end function pdg_array_get_length
@ %def pdg_array_get_length
@ Return the element with index i.
<<PDG arrays: public>>=
public :: pdg_array_get
<<PDG arrays: pdg array: TBP>>=
procedure :: get => pdg_array_get
<<PDG arrays: procedures>>=
elemental function pdg_array_get (aval, i) result (pdg)
class(pdg_array_t), intent(in) :: aval
integer, intent(in), optional :: i
integer :: pdg
if (present (i)) then
pdg = aval%pdg(i)
else
pdg = aval%pdg(1)
end if
end function pdg_array_get
@ %def pdg_array_get
@ Explicitly set the element with index i.
<<PDG arrays: pdg array: TBP>>=
procedure :: set => pdg_array_set
<<PDG arrays: procedures>>=
subroutine pdg_array_set (aval, i, pdg)
class(pdg_array_t), intent(inout) :: aval
integer, intent(in) :: i
integer, intent(in) :: pdg
aval%pdg(i) = pdg
end subroutine pdg_array_set
@ %def pdg_array_set
@
<<PDG arrays: pdg array: TBP>>=
procedure :: add => pdg_array_add
<<PDG arrays: procedures>>=
function pdg_array_add (aval, aval_add) result (aval_out)
type(pdg_array_t) :: aval_out
class(pdg_array_t), intent(in) :: aval
type(pdg_array_t), intent(in) :: aval_add
integer :: n, n_add, i
n = size (aval%pdg)
n_add = size (aval_add%pdg)
allocate (aval_out%pdg (n + n_add))
aval_out%pdg(1:n) = aval%pdg
do i = 1, n_add
aval_out%pdg(n+i) = aval_add%pdg(i)
end do
end function pdg_array_add
@ %def pdg_array_add
@ Replace element with index [[i]] by a new array of elements.
<<PDG arrays: public>>=
public :: pdg_array_replace
<<PDG arrays: pdg array: TBP>>=
procedure :: replace => pdg_array_replace
<<PDG arrays: procedures>>=
function pdg_array_replace (aval, i, pdg_new) result (aval_new)
class(pdg_array_t), intent(in) :: aval
integer, intent(in) :: i
integer, dimension(:), intent(in) :: pdg_new
type(pdg_array_t) :: aval_new
integer :: n, l
n = size (aval%pdg)
l = size (pdg_new)
allocate (aval_new%pdg (n + l - 1))
aval_new%pdg(:i-1) = aval%pdg(:i-1)
aval_new%pdg(i:i+l-1) = pdg_new
aval_new%pdg(i+l:) = aval%pdg(i+1:)
end function pdg_array_replace
@ %def pdg_array_replace
@ Concatenate two PDG arrays
<<PDG arrays: public>>=
public :: operator(//)
<<PDG arrays: interfaces>>=
interface operator(//)
module procedure concat_pdg_arrays
end interface
<<PDG arrays: procedures>>=
function concat_pdg_arrays (aval1, aval2) result (aval)
type(pdg_array_t) :: aval
type(pdg_array_t), intent(in) :: aval1, aval2
integer :: n1, n2
if (allocated (aval1%pdg) .and. allocated (aval2%pdg)) then
n1 = size (aval1%pdg)
n2 = size (aval2%pdg)
allocate (aval%pdg (n1 + n2))
aval%pdg(:n1) = aval1%pdg
aval%pdg(n1+1:) = aval2%pdg
else if (allocated (aval1%pdg)) then
aval = aval1
else if (allocated (aval2%pdg)) then
aval = aval2
end if
end function concat_pdg_arrays
@ %def concat_pdg_arrays
@
\subsection{Matching}
A PDG array matches a given PDG code if the code is present within the
array. If either one is zero (UNDEFINED), the match also succeeds.
<<PDG arrays: public>>=
public :: operator(.match.)
<<PDG arrays: interfaces>>=
interface operator(.match.)
module procedure pdg_array_match_integer
module procedure pdg_array_match_pdg_array
end interface
@ %def .match.
@ Match a single code against the array.
<<PDG arrays: procedures>>=
elemental function pdg_array_match_integer (aval, pdg) result (flag)
logical :: flag
type(pdg_array_t), intent(in) :: aval
integer, intent(in) :: pdg
if (allocated (aval%pdg)) then
flag = pdg == UNDEFINED &
.or. any (aval%pdg == UNDEFINED) &
.or. any (aval%pdg == pdg)
else
flag = .false.
end if
end function pdg_array_match_integer
@ %def pdg_array_match_integer
@ Check if the pdg-number corresponds to a quark
<<PDG arrays: public>>=
public :: is_quark
<<PDG arrays: procedures>>=
elemental function is_quark (pdg_nr)
logical :: is_quark
integer, intent(in) :: pdg_nr
if (abs (pdg_nr) >= 1 .and. abs (pdg_nr) <= 6) then
is_quark = .true.
else
is_quark = .false.
end if
end function is_quark
@ %def is_quark
@ Check if pdg-number corresponds to a gluon
<<PDG arrays: public>>=
public :: is_gluon
<<PDG arrays: procedures>>=
elemental function is_gluon (pdg_nr)
logical :: is_gluon
integer, intent(in) :: pdg_nr
if (pdg_nr == 21) then
is_gluon = .true.
else
is_gluon = .false.
end if
end function is_gluon
@ %def is_gluon
@ Check if pdg-number corresponds to a photon
<<PDG arrays: public>>=
public :: is_photon
<<PDG arrays: procedures>>=
elemental function is_photon (pdg_nr)
logical :: is_photon
integer, intent(in) :: pdg_nr
if (pdg_nr == 22) then
is_photon = .true.
else
is_photon = .false.
end if
end function is_photon
@ %def is_photon
@ Check if pdg-number corresponds to a colored particle
<<PDG arrays: public>>=
public :: is_colored
<<PDG arrays: procedures>>=
elemental function is_colored (pdg_nr)
logical :: is_colored
integer, intent(in) :: pdg_nr
is_colored = is_quark (pdg_nr) .or. is_gluon (pdg_nr)
end function is_colored
@ %def is_colored
@ Check if the pdg-number corresponds to a lepton
<<PDG arrays: public>>=
public :: is_lepton
<<PDG arrays: procedures>>=
elemental function is_lepton (pdg_nr)
logical :: is_lepton
integer, intent(in) :: pdg_nr
if (abs (pdg_nr) >= 11 .and. abs (pdg_nr) <= 16) then
is_lepton = .true.
else
is_lepton = .false.
end if
end function is_lepton
@ %def is_lepton
@
<<PDG arrays: public>>=
public :: is_fermion
<<PDG arrays: procedures>>=
elemental function is_fermion (pdg_nr)
logical :: is_fermion
integer, intent(in) :: pdg_nr
is_fermion = is_lepton(pdg_nr) .or. is_quark(pdg_nr)
end function is_fermion
@ %def is_fermion
@ Check if the pdg-number corresponds to a massless vector boson
<<PDG arrays: public>>=
public :: is_massless_vector
<<PDG arrays: procedures>>=
elemental function is_massless_vector (pdg_nr)
integer, intent(in) :: pdg_nr
logical :: is_massless_vector
if (pdg_nr == 21 .or. pdg_nr == 22) then
is_massless_vector = .true.
else
is_massless_vector = .false.
end if
end function is_massless_vector
@ %def is_massless_vector
@ Check if pdg-number corresponds to a massive vector boson
<<PDG arrays: public>>=
public :: is_massive_vector
<<PDG arrays: procedures>>=
elemental function is_massive_vector (pdg_nr)
integer, intent(in) :: pdg_nr
logical :: is_massive_vector
if (abs (pdg_nr) == 23 .or. abs (pdg_nr) == 24) then
is_massive_vector = .true.
else
is_massive_vector = .false.
end if
end function is_massive_vector
@ %def is massive_vector
@ Check if pdg-number corresponds to a vector boson
<<PDG arrays: public>>=
public :: is_vector
<<PDG arrays: procedures>>=
elemental function is_vector (pdg_nr)
integer, intent(in) :: pdg_nr
logical :: is_vector
if (is_massless_vector (pdg_nr) .or. is_massive_vector (pdg_nr)) then
is_vector = .true.
else
is_vector = .false.
end if
end function is_vector
@ %def is vector
@ Check if particle is elementary.
<<PDG arrays: public>>=
public :: is_elementary
<<PDG arrays: procedures>>=
elemental function is_elementary (pdg_nr)
integer, intent(in) :: pdg_nr
logical :: is_elementary
if (is_vector (pdg_nr) .or. is_fermion (pdg_nr) .or. pdg_nr == 25) then
is_elementary = .true.
else
is_elementary = .false.
end if
end function is_elementary
@ %def is_elementary
@ Check if particle is strongly interacting
<<PDG arrays: pdg array: TBP>>=
procedure :: has_colored_particles => pdg_array_has_colored_particles
<<PDG arrays: procedures>>=
function pdg_array_has_colored_particles (pdg) result (colored)
class(pdg_array_t), intent(in) :: pdg
logical :: colored
integer :: i, pdg_nr
colored = .false.
do i = 1, size (pdg%pdg)
pdg_nr = pdg%pdg(i)
if (is_quark (pdg_nr) .or. is_gluon (pdg_nr)) then
colored = .true.
exit
end if
end do
end function pdg_array_has_colored_particles
@ %def pdg_array_has_colored_particles
@ Match two arrays. Succeeds if any pair of entries matches.
<<PDG arrays: procedures>>=
function pdg_array_match_pdg_array (aval1, aval2) result (flag)
logical :: flag
type(pdg_array_t), intent(in) :: aval1, aval2
if (allocated (aval1%pdg) .and. allocated (aval2%pdg)) then
flag = any (aval1 .match. aval2%pdg)
else
flag = .false.
end if
end function pdg_array_match_pdg_array
@ %def pdg_array_match_pdg_array
@ Comparison. Here, we take the PDG arrays as-is, assuming that they
are sorted.
The ordering is a bit odd: first, we look only at the absolute values
of the PDG codes. If they all match, the particle comes before the
antiparticle, scanning from left to right.
<<PDG arrays: public>>=
public :: operator(<)
public :: operator(>)
public :: operator(<=)
public :: operator(>=)
public :: operator(==)
public :: operator(/=)
<<PDG arrays: interfaces>>=
interface operator(<)
module procedure pdg_array_lt
end interface
interface operator(>)
module procedure pdg_array_gt
end interface
interface operator(<=)
module procedure pdg_array_le
end interface
interface operator(>=)
module procedure pdg_array_ge
end interface
interface operator(==)
module procedure pdg_array_eq
end interface
interface operator(/=)
module procedure pdg_array_ne
end interface
<<PDG arrays: procedures>>=
elemental function pdg_array_lt (aval1, aval2) result (flag)
type(pdg_array_t), intent(in) :: aval1, aval2
logical :: flag
integer :: i
if (size (aval1%pdg) /= size (aval2%pdg)) then
flag = size (aval1%pdg) < size (aval2%pdg)
else
do i = 1, size (aval1%pdg)
if (abs (aval1%pdg(i)) /= abs (aval2%pdg(i))) then
flag = abs (aval1%pdg(i)) < abs (aval2%pdg(i))
return
end if
end do
do i = 1, size (aval1%pdg)
if (aval1%pdg(i) /= aval2%pdg(i)) then
flag = aval1%pdg(i) > aval2%pdg(i)
return
end if
end do
flag = .false.
end if
end function pdg_array_lt
elemental function pdg_array_gt (aval1, aval2) result (flag)
type(pdg_array_t), intent(in) :: aval1, aval2
logical :: flag
flag = .not. (aval1 < aval2 .or. aval1 == aval2)
end function pdg_array_gt
elemental function pdg_array_le (aval1, aval2) result (flag)
type(pdg_array_t), intent(in) :: aval1, aval2
logical :: flag
flag = aval1 < aval2 .or. aval1 == aval2
end function pdg_array_le
elemental function pdg_array_ge (aval1, aval2) result (flag)
type(pdg_array_t), intent(in) :: aval1, aval2
logical :: flag
flag = .not. (aval1 < aval2)
end function pdg_array_ge
elemental function pdg_array_eq (aval1, aval2) result (flag)
type(pdg_array_t), intent(in) :: aval1, aval2
logical :: flag
if (size (aval1%pdg) /= size (aval2%pdg)) then
flag = .false.
else
flag = all (aval1%pdg == aval2%pdg)
end if
end function pdg_array_eq
elemental function pdg_array_ne (aval1, aval2) result (flag)
type(pdg_array_t), intent(in) :: aval1, aval2
logical :: flag
flag = .not. (aval1 == aval2)
end function pdg_array_ne
@ Equivalence. Two PDG arrays are equivalent if either one contains
[[UNDEFINED]] or if each element of array 1 is present in array 2, and
vice versa.
<<PDG arrays: public>>=
public :: operator(.eqv.)
public :: operator(.neqv.)
<<PDG arrays: interfaces>>=
interface operator(.eqv.)
module procedure pdg_array_equivalent
end interface
interface operator(.neqv.)
module procedure pdg_array_inequivalent
end interface
<<PDG arrays: procedures>>=
elemental function pdg_array_equivalent (aval1, aval2) result (eq)
logical :: eq
type(pdg_array_t), intent(in) :: aval1, aval2
logical, dimension(:), allocatable :: match1, match2
integer :: i
if (allocated (aval1%pdg) .and. allocated (aval2%pdg)) then
eq = any (aval1%pdg == UNDEFINED) &
.or. any (aval2%pdg == UNDEFINED)
if (.not. eq) then
allocate (match1 (size (aval1%pdg)))
allocate (match2 (size (aval2%pdg)))
match1 = .false.
match2 = .false.
do i = 1, size (aval1%pdg)
match2 = match2 .or. aval1%pdg(i) == aval2%pdg
end do
do i = 1, size (aval2%pdg)
match1 = match1 .or. aval2%pdg(i) == aval1%pdg
end do
eq = all (match1) .and. all (match2)
end if
else
eq = .false.
end if
end function pdg_array_equivalent
elemental function pdg_array_inequivalent (aval1, aval2) result (neq)
logical :: neq
type(pdg_array_t), intent(in) :: aval1, aval2
neq = .not. pdg_array_equivalent (aval1, aval2)
end function pdg_array_inequivalent
@ %def pdg_array_equivalent
@
\subsection{Sorting}
Sort a PDG array by absolute value, particle before antiparticle. After
sorting, we eliminate double entries.
<<PDG arrays: public>>=
public :: sort_abs
<<PDG arrays: interfaces>>=
interface sort_abs
module procedure pdg_array_sort_abs
end interface
<<PDG arrays: pdg array: TBP>>=
procedure :: sort_abs => pdg_array_sort_abs
<<PDG arrays: procedures>>=
function pdg_array_sort_abs (aval1, unique) result (aval2)
class(pdg_array_t), intent(in) :: aval1
logical, intent(in), optional :: unique
type(pdg_array_t) :: aval2
integer, dimension(:), allocatable :: tmp
logical, dimension(:), allocatable :: mask
integer :: i, n
logical :: uni
uni = .false.; if (present (unique)) uni = unique
n = size (aval1%pdg)
if (uni) then
allocate (tmp (n), mask(n))
tmp = sort_abs (aval1%pdg)
mask(1) = .true.
do i = 2, n
mask(i) = tmp(i) /= tmp(i-1)
end do
allocate (aval2%pdg (count (mask)))
aval2%pdg = pack (tmp, mask)
else
allocate (aval2%pdg (n))
aval2%pdg = sort_abs (aval1%pdg)
end if
end function pdg_array_sort_abs
@ %def sort_abs
@
<<PDG arrays: pdg array: TBP>>=
procedure :: intersect => pdg_array_intersect
<<PDG arrays: procedures>>=
function pdg_array_intersect (aval1, match) result (aval2)
class(pdg_array_t), intent(in) :: aval1
integer, dimension(:) :: match
type(pdg_array_t) :: aval2
integer, dimension(:), allocatable :: isec
integer :: i
isec = pack (aval1%pdg, [(any(aval1%pdg(i) == match), i=1,size(aval1%pdg))])
aval2 = isec
end function pdg_array_intersect
@ %def pdg_array_intersect
@
<<PDG arrays: pdg array: TBP>>=
procedure :: search_for_particle => pdg_array_search_for_particle
<<PDG arrays: procedures>>=
elemental function pdg_array_search_for_particle (pdg, i_part) result (found)
class(pdg_array_t), intent(in) :: pdg
integer, intent(in) :: i_part
logical :: found
found = any (pdg%pdg == i_part)
end function pdg_array_search_for_particle
@ %def pdg_array_search_for_particle
@
<<PDG arrays: pdg array: TBP>>=
procedure :: invert => pdg_array_invert
<<PDG arrays: procedures>>=
function pdg_array_invert (pdg) result (pdg_inverse)
class(pdg_array_t), intent(in) :: pdg
type(pdg_array_t) :: pdg_inverse
integer :: i, n
n = size (pdg%pdg)
allocate (pdg_inverse%pdg (n))
do i = 1, n
select case (pdg%pdg(i))
case (21, 22, 23, 25)
pdg_inverse%pdg(i) = pdg%pdg(i)
case default
pdg_inverse%pdg(i) = -pdg%pdg(i)
end select
end do
end function pdg_array_invert
@ %def pdg_array_invert
@
\subsection{PDG array list}
A PDG array list, or PDG list, is an array of PDG-array objects with
some convenience methods.
<<PDG arrays: public>>=
public :: pdg_list_t
<<PDG arrays: types>>=
type :: pdg_list_t
type(pdg_array_t), dimension(:), allocatable :: a
contains
<<PDG arrays: pdg list: TBP>>
end type pdg_list_t
@ %def pdg_list_t
@ Output, as a comma-separated list without advancing I/O.
<<PDG arrays: pdg list: TBP>>=
procedure :: write => pdg_list_write
<<PDG arrays: procedures>>=
subroutine pdg_list_write (object, unit)
class(pdg_list_t), intent(in) :: object
integer, intent(in), optional :: unit
integer :: u, i
u = given_output_unit (unit)
if (allocated (object%a)) then
do i = 1, size (object%a)
if (i > 1) write (u, "(A)", advance="no") ", "
call object%a(i)%write (u)
end do
end if
end subroutine pdg_list_write
@ %def pdg_list_write
@ Initialize for a certain size. The entries are initially empty PDG arrays.
<<PDG arrays: pdg list: TBP>>=
generic :: init => pdg_list_init_size
procedure, private :: pdg_list_init_size
<<PDG arrays: procedures>>=
subroutine pdg_list_init_size (pl, n)
class(pdg_list_t), intent(out) :: pl
integer, intent(in) :: n
allocate (pl%a (n))
end subroutine pdg_list_init_size
@ %def pdg_list_init_size
@ Initialize with a definite array of PDG codes. That is, each entry
in the list becomes a single-particle PDG array.
<<PDG arrays: pdg list: TBP>>=
generic :: init => pdg_list_init_int_array
procedure, private :: pdg_list_init_int_array
<<PDG arrays: procedures>>=
subroutine pdg_list_init_int_array (pl, pdg)
class(pdg_list_t), intent(out) :: pl
integer, dimension(:), intent(in) :: pdg
integer :: i
allocate (pl%a (size (pdg)))
do i = 1, size (pdg)
pl%a(i) = pdg(i)
end do
end subroutine pdg_list_init_int_array
@ %def pdg_list_init_array
@ Set one of the entries. No bounds-check.
<<PDG arrays: pdg list: TBP>>=
generic :: set => pdg_list_set_int
generic :: set => pdg_list_set_int_array
generic :: set => pdg_list_set_pdg_array
procedure, private :: pdg_list_set_int
procedure, private :: pdg_list_set_int_array
procedure, private :: pdg_list_set_pdg_array
<<PDG arrays: procedures>>=
subroutine pdg_list_set_int (pl, i, pdg)
class(pdg_list_t), intent(inout) :: pl
integer, intent(in) :: i
integer, intent(in) :: pdg
pl%a(i) = pdg
end subroutine pdg_list_set_int
subroutine pdg_list_set_int_array (pl, i, pdg)
class(pdg_list_t), intent(inout) :: pl
integer, intent(in) :: i
integer, dimension(:), intent(in) :: pdg
pl%a(i) = pdg
end subroutine pdg_list_set_int_array
subroutine pdg_list_set_pdg_array (pl, i, pa)
class(pdg_list_t), intent(inout) :: pl
integer, intent(in) :: i
type(pdg_array_t), intent(in) :: pa
pl%a(i) = pa
end subroutine pdg_list_set_pdg_array
@ %def pdg_list_set
@ Array size, not the length of individual entries
<<PDG arrays: pdg list: TBP>>=
procedure :: get_size => pdg_list_get_size
<<PDG arrays: procedures>>=
function pdg_list_get_size (pl) result (n)
class(pdg_list_t), intent(in) :: pl
integer :: n
if (allocated (pl%a)) then
n = size (pl%a)
else
n = 0
end if
end function pdg_list_get_size
@ %def pdg_list_get_size
@ Return an entry, as a PDG array.
<<PDG arrays: pdg list: TBP>>=
procedure :: get => pdg_list_get
<<PDG arrays: procedures>>=
function pdg_list_get (pl, i) result (pa)
type(pdg_array_t) :: pa
class(pdg_list_t), intent(in) :: pl
integer, intent(in) :: i
pa = pl%a(i)
end function pdg_list_get
@ %def pdg_list_get
@ Check if the list entries are all either mutually disjoint or identical.
The individual entries (PDG arrays) should already be sorted, so we can test
for equality.
<<PDG arrays: pdg list: TBP>>=
procedure :: is_regular => pdg_list_is_regular
<<PDG arrays: procedures>>=
function pdg_list_is_regular (pl) result (flag)
class(pdg_list_t), intent(in) :: pl
logical :: flag
integer :: i, j, s
s = pl%get_size ()
flag = .true.
do i = 1, s
do j = i + 1, s
if (pl%a(i) .match. pl%a(j)) then
if (pl%a(i) /= pl%a(j)) then
flag = .false.
return
end if
end if
end do
end do
end function pdg_list_is_regular
@ %def pdg_list_is_regular
@ Sort the list. First, each entry gets sorted, including elimination
of doublers. Then, we sort the list, using the first member of each
PDG array as the marker. No removal of doublers at this stage.
If [[n_in]] is supplied, we do not reorder the first [[n_in]] particle
entries.
<<PDG arrays: pdg list: TBP>>=
procedure :: sort_abs => pdg_list_sort_abs
<<PDG arrays: procedures>>=
function pdg_list_sort_abs (pl, n_in) result (pl_sorted)
class(pdg_list_t), intent(in) :: pl
integer, intent(in), optional :: n_in
type(pdg_list_t) :: pl_sorted
type(pdg_array_t), dimension(:), allocatable :: pa
integer, dimension(:), allocatable :: pdg, map
integer :: i, n0
call pl_sorted%init (pl%get_size ())
if (allocated (pl%a)) then
allocate (pa (size (pl%a)))
do i = 1, size (pl%a)
pa(i) = pl%a(i)%sort_abs (unique = .true.)
end do
allocate (pdg (size (pa)), source = 0)
do i = 1, size (pa)
if (allocated (pa(i)%pdg)) then
if (size (pa(i)%pdg) > 0) then
pdg(i) = pa(i)%pdg(1)
end if
end if
end do
if (present (n_in)) then
n0 = n_in
else
n0 = 0
end if
allocate (map (size (pdg)))
map(:n0) = [(i, i = 1, n0)]
map(n0+1:) = n0 + order_abs (pdg(n0+1:))
do i = 1, size (pa)
call pl_sorted%set (i, pa(map(i)))
end do
end if
end function pdg_list_sort_abs
@ %def pdg_list_sort_abs
@ Compare sorted lists: equality. The result is undefined if some entries
are not allocated.
<<PDG arrays: pdg list: TBP>>=
generic :: operator (==) => pdg_list_eq
procedure, private :: pdg_list_eq
<<PDG arrays: procedures>>=
function pdg_list_eq (pl1, pl2) result (flag)
class(pdg_list_t), intent(in) :: pl1, pl2
logical :: flag
integer :: i
flag = .false.
if (allocated (pl1%a) .and. allocated (pl2%a)) then
if (size (pl1%a) == size (pl2%a)) then
do i = 1, size (pl1%a)
associate (a1 => pl1%a(i), a2 => pl2%a(i))
if (allocated (a1%pdg) .and. allocated (a2%pdg)) then
if (size (a1%pdg) == size (a2%pdg)) then
if (size (a1%pdg) > 0) then
if (a1%pdg(1) /= a2%pdg(1)) return
end if
else
return
end if
else
return
end if
end associate
end do
flag = .true.
end if
end if
end function pdg_list_eq
@ %def pdg_list_eq
@ Compare sorted lists. The result is undefined if some entries
are not allocated.
The ordering is quite complicated. First, a shorter list comes before
a longer list. Comparing entry by entry, a shorter entry comes
first. Next, we check the first PDG code within corresponding
entries. This is compared by absolute value. If equal, particle
comes before antiparticle. Finally, if all is equal, the result is
false.
<<PDG arrays: pdg list: TBP>>=
generic :: operator (<) => pdg_list_lt
procedure, private :: pdg_list_lt
<<PDG arrays: procedures>>=
function pdg_list_lt (pl1, pl2) result (flag)
class(pdg_list_t), intent(in) :: pl1, pl2
logical :: flag
integer :: i
flag = .false.
if (allocated (pl1%a) .and. allocated (pl2%a)) then
if (size (pl1%a) < size (pl2%a)) then
flag = .true.; return
else if (size (pl1%a) > size (pl2%a)) then
return
else
do i = 1, size (pl1%a)
associate (a1 => pl1%a(i), a2 => pl2%a(i))
if (allocated (a1%pdg) .and. allocated (a2%pdg)) then
if (size (a1%pdg) < size (a2%pdg)) then
flag = .true.; return
else if (size (a1%pdg) > size (a2%pdg)) then
return
else
if (size (a1%pdg) > 0) then
if (abs (a1%pdg(1)) < abs (a2%pdg(1))) then
flag = .true.; return
else if (abs (a1%pdg(1)) > abs (a2%pdg(1))) then
return
else if (a1%pdg(1) > 0 .and. a2%pdg(1) < 0) then
flag = .true.; return
else if (a1%pdg(1) < 0 .and. a2%pdg(1) > 0) then
return
end if
end if
end if
else
return
end if
end associate
end do
flag = .false.
end if
end if
end function pdg_list_lt
@ %def pdg_list_lt
@ Replace an entry. In the result, the entry [[#i]] is replaced by
the contents of the second argument. The result is not sorted.
If [[n_in]] is also set and [[i]] is less or equal to [[n_in]],
replace [[#i]] only by the first entry of [[pl_insert]], and insert
the remainder after entry [[n_in]].
<<PDG arrays: pdg list: TBP>>=
procedure :: replace => pdg_list_replace
<<PDG arrays: procedures>>=
function pdg_list_replace (pl, i, pl_insert, n_in) result (pl_out)
type(pdg_list_t) :: pl_out
class(pdg_list_t), intent(in) :: pl
integer, intent(in) :: i
class(pdg_list_t), intent(in) :: pl_insert
integer, intent(in), optional :: n_in
integer :: n, n_insert, n_out, k
n = pl%get_size ()
n_insert = pl_insert%get_size ()
n_out = n + n_insert - 1
call pl_out%init (n_out)
! if (allocated (pl%a)) then
do k = 1, i - 1
pl_out%a(k) = pl%a(k)
end do
! end if
if (present (n_in)) then
pl_out%a(i) = pl_insert%a(1)
do k = i + 1, n_in
pl_out%a(k) = pl%a(k)
end do
do k = 1, n_insert - 1
pl_out%a(n_in+k) = pl_insert%a(1+k)
end do
do k = 1, n - n_in
pl_out%a(n_in+k+n_insert-1) = pl%a(n_in+k)
end do
else
! if (allocated (pl_insert%a)) then
do k = 1, n_insert
pl_out%a(i-1+k) = pl_insert%a(k)
end do
! end if
! if (allocated (pl%a)) then
do k = 1, n - i
pl_out%a(i+n_insert-1+k) = pl%a(i+k)
end do
end if
! end if
end function pdg_list_replace
@ %def pdg_list_replace
@
<<PDG arrays: pdg list: TBP>>=
procedure :: fusion => pdg_list_fusion
<<PDG arrays: procedures>>=
function pdg_list_fusion (pl, pl_insert, i, check_if_existing) result (pl_out)
type(pdg_list_t) :: pl_out
class(pdg_list_t), intent(in) :: pl
type(pdg_list_t), intent(in) :: pl_insert
integer, intent(in) :: i
logical, intent(in) :: check_if_existing
integer :: n, n_insert, k, n_out
logical :: new_pdg
n = pl%get_size ()
n_insert = pl_insert%get_size ()
new_pdg = .not. check_if_existing .or. &
(.not. any (pl%search_for_particle (pl_insert%a(1)%pdg)))
call pl_out%init (n + n_insert - 1)
do k = 1, n
if (new_pdg .and. k == i) then
pl_out%a(k) = pl%a(k)%add (pl_insert%a(1))
else
pl_out%a(k) = pl%a(k)
end if
end do
do k = n + 1, n + n_insert - 1
pl_out%a(k) = pl_insert%a(k-n)
end do
end function pdg_list_fusion
@ %def pdg_list_fusion
@
<<PDG arrays: pdg list: TBP>>=
procedure :: get_pdg_sizes => pdg_list_get_pdg_sizes
<<PDG arrays: procedures>>=
function pdg_list_get_pdg_sizes (pl) result (i_size)
integer, dimension(:), allocatable :: i_size
class(pdg_list_t), intent(in) :: pl
integer :: i, n
n = pl%get_size ()
allocate (i_size (n))
do i = 1, n
i_size(i) = size (pl%a(i)%pdg)
end do
end function pdg_list_get_pdg_sizes
@ %def pdg_list_get_pdg_sizes
@ Replace the entries of [[pl]] by the matching entries of [[pl_match]], one by
one. This is done in-place. If there is no match, return failure.
<<PDG arrays: pdg list: TBP>>=
procedure :: match_replace => pdg_list_match_replace
<<PDG arrays: procedures>>=
subroutine pdg_list_match_replace (pl, pl_match, success)
class(pdg_list_t), intent(inout) :: pl
class(pdg_list_t), intent(in) :: pl_match
logical, intent(out) :: success
integer :: i, j
success = .true.
SCAN_ENTRIES: do i = 1, size (pl%a)
do j = 1, size (pl_match%a)
if (pl%a(i) .match. pl_match%a(j)) then
pl%a(i) = pl_match%a(j)
cycle SCAN_ENTRIES
end if
end do
success = .false.
return
end do SCAN_ENTRIES
end subroutine pdg_list_match_replace
@ %def pdg_list_match_replace
@ Just check if a PDG array matches any entry in the PDG list. The second
version returns the position of the match within the list. An optional mask
indicates the list elements that should be checked.
<<PDG arrays: pdg list: TBP>>=
generic :: operator (.match.) => pdg_list_match_pdg_array
procedure, private :: pdg_list_match_pdg_array
procedure :: find_match => pdg_list_find_match_pdg_array
<<PDG arrays: procedures>>=
function pdg_list_match_pdg_array (pl, pa) result (flag)
class(pdg_list_t), intent(in) :: pl
type(pdg_array_t), intent(in) :: pa
logical :: flag
flag = pl%find_match (pa) /= 0
end function pdg_list_match_pdg_array
function pdg_list_find_match_pdg_array (pl, pa, mask) result (i)
class(pdg_list_t), intent(in) :: pl
type(pdg_array_t), intent(in) :: pa
logical, dimension(:), intent(in), optional :: mask
integer :: i
do i = 1, size (pl%a)
if (present (mask)) then
if (.not. mask(i)) cycle
end if
if (pl%a(i) .match. pa) return
end do
i = 0
end function pdg_list_find_match_pdg_array
@ %def pdg_list_match_pdg_array
@ %def pdg_list_find_match_pdg_array
@ Some old compilers have problems with allocatable arrays as
intent(out) or as function result, so be conservative here:
<<PDG arrays: pdg list: TBP>>=
procedure :: create_pdg_array => pdg_list_create_pdg_array
<<PDG arrays: procedures>>=
subroutine pdg_list_create_pdg_array (pl, pdg)
class(pdg_list_t), intent(in) :: pl
type(pdg_array_t), dimension(:), intent(inout), allocatable :: pdg
integer :: n_elements
integer :: i
associate (a => pl%a)
n_elements = size (a)
if (allocated (pdg)) deallocate (pdg)
allocate (pdg (n_elements))
do i = 1, n_elements
pdg(i) = a(i)
end do
end associate
end subroutine pdg_list_create_pdg_array
@ %def pdg_list_create_pdg_array
@
<<PDG arrays: pdg list: TBP>>=
procedure :: create_antiparticles => pdg_list_create_antiparticles
<<PDG arrays: procedures>>=
subroutine pdg_list_create_antiparticles (pl, pl_anti, n_new_particles)
class(pdg_list_t), intent(in) :: pl
type(pdg_list_t), intent(out) :: pl_anti
integer, intent(out) :: n_new_particles
type(pdg_list_t) :: pl_inverse
integer :: i, n
integer :: n_identical
logical, dimension(:), allocatable :: collect
n = pl%get_size (); n_identical = 0
allocate (collect (n)); collect = .true.
call pl_inverse%init (n)
do i = 1, n
pl_inverse%a(i) = pl%a(i)%invert()
end do
do i = 1, n
if (any (pl_inverse%a(i) == pl%a)) then
collect(i) = .false.
n_identical = n_identical + 1
end if
end do
n_new_particles = n - n_identical
if (n_new_particles > 0) then
call pl_anti%init (n_new_particles)
do i = 1, n
if (collect (i)) pl_anti%a(i) = pl_inverse%a(i)
end do
end if
end subroutine pdg_list_create_antiparticles
@ %def pdg_list_create_antiparticles
@
<<PDG arrays: pdg list: TBP>>=
procedure :: search_for_particle => pdg_list_search_for_particle
<<PDG arrays: procedures>>=
elemental function pdg_list_search_for_particle (pl, i_part) result (found)
logical :: found
class(pdg_list_t), intent(in) :: pl
integer, intent(in) :: i_part
integer :: i_pl
do i_pl = 1, size (pl%a)
found = pl%a(i_pl)%search_for_particle (i_part)
if (found) return
end do
end function pdg_list_search_for_particle
@ %def pdg_list_search_for_particle
@
<<PDG arrays: pdg list: TBP>>=
procedure :: contains_colored_particles => pdg_list_contains_colored_particles
<<PDG arrays: procedures>>=
function pdg_list_contains_colored_particles (pl) result (colored)
class(pdg_list_t), intent(in) :: pl
logical :: colored
integer :: i
colored = .false.
do i = 1, size (pl%a)
if (pl%a(i)%has_colored_particles()) then
colored = .true.
exit
end if
end do
end function pdg_list_contains_colored_particles
@ %def pdg_list_contains_colored_particles
@
\subsection{Unit tests}
Test module, followed by the corresponding implementation module.
<<[[pdg_arrays_ut.f90]]>>=
<<File header>>
module pdg_arrays_ut
use unit_tests
use pdg_arrays_uti
<<Standard module head>>
<<PDG arrays: public test>>
contains
<<PDG arrays: test driver>>
end module pdg_arrays_ut
@ %def pdg_arrays_ut
@
<<[[pdg_arrays_uti.f90]]>>=
<<File header>>
module pdg_arrays_uti
use pdg_arrays
<<Standard module head>>
<<PDG arrays: test declarations>>
contains
<<PDG arrays: tests>>
end module pdg_arrays_uti
@ %def pdg_arrays_ut
@ API: driver for the unit tests below.
<<PDG arrays: public test>>=
public :: pdg_arrays_test
<<PDG arrays: test driver>>=
subroutine pdg_arrays_test (u, results)
integer, intent(in) :: u
type (test_results_t), intent(inout) :: results
<<PDG arrays: execute tests>>
end subroutine pdg_arrays_test
@ %def pdg_arrays_test
@ Basic functionality.
<<PDG arrays: execute tests>>=
call test (pdg_arrays_1, "pdg_arrays_1", &
"create and sort PDG array", &
u, results)
<<PDG arrays: test declarations>>=
public :: pdg_arrays_1
<<PDG arrays: tests>>=
subroutine pdg_arrays_1 (u)
integer, intent(in) :: u
type(pdg_array_t) :: pa, pa1, pa2, pa3, pa4, pa5, pa6
integer, dimension(:), allocatable :: pdg
write (u, "(A)") "* Test output: pdg_arrays_1"
write (u, "(A)") "* Purpose: create and sort PDG arrays"
write (u, "(A)")
write (u, "(A)") "* Assignment"
write (u, "(A)")
call pa%write (u)
write (u, *)
write (u, "(A,I0)") "length = ", pa%get_length ()
pdg = pa
write (u, "(A,3(1x,I0))") "contents = ", pdg
write (u, *)
pa = 1
call pa%write (u)
write (u, *)
write (u, "(A,I0)") "length = ", pa%get_length ()
pdg = pa
write (u, "(A,3(1x,I0))") "contents = ", pdg
write (u, *)
pa = [1, 2, 3]
call pa%write (u)
write (u, *)
write (u, "(A,I0)") "length = ", pa%get_length ()
pdg = pa
write (u, "(A,3(1x,I0))") "contents = ", pdg
write (u, "(A,I0)") "element #2 = ", pa%get (2)
write (u, *)
write (u, "(A)") "* Replace"
write (u, *)
pa = pa%replace (2, [-5, 5, -7])
call pa%write (u)
write (u, *)
write (u, *)
write (u, "(A)") "* Sort"
write (u, *)
pa = [1, -7, 3, -5, 5, 3]
call pa%write (u)
write (u, *)
pa1 = pa%sort_abs ()
pa2 = pa%sort_abs (unique = .true.)
call pa1%write (u)
write (u, *)
call pa2%write (u)
write (u, *)
write (u, *)
write (u, "(A)") "* Compare"
write (u, *)
pa1 = [1, 3]
pa2 = [1, 2, -2]
pa3 = [1, 2, 4]
pa4 = [1, 2, 4]
pa5 = [1, 2, -4]
pa6 = [1, 2, -3]
write (u, "(A,6(1x,L1))") "< ", &
pa1 < pa2, pa2 < pa3, pa3 < pa4, pa4 < pa5, pa5 < pa6, pa6 < pa1
write (u, "(A,6(1x,L1))") "> ", &
pa1 > pa2, pa2 > pa3, pa3 > pa4, pa4 > pa5, pa5 > pa6, pa6 > pa1
write (u, "(A,6(1x,L1))") "<=", &
pa1 <= pa2, pa2 <= pa3, pa3 <= pa4, pa4 <= pa5, pa5 <= pa6, pa6 <= pa1
write (u, "(A,6(1x,L1))") ">=", &
pa1 >= pa2, pa2 >= pa3, pa3 >= pa4, pa4 >= pa5, pa5 >= pa6, pa6 >= pa1
write (u, "(A,6(1x,L1))") "==", &
pa1 == pa2, pa2 == pa3, pa3 == pa4, pa4 == pa5, pa5 == pa6, pa6 == pa1
write (u, "(A,6(1x,L1))") "/=", &
pa1 /= pa2, pa2 /= pa3, pa3 /= pa4, pa4 /= pa5, pa5 /= pa6, pa6 /= pa1
write (u, *)
pa1 = [0]
pa2 = [1, 2]
pa3 = [1, -2]
write (u, "(A,6(1x,L1))") "eqv ", &
pa1 .eqv. pa1, pa1 .eqv. pa2, &
pa2 .eqv. pa2, pa2 .eqv. pa3
write (u, "(A,6(1x,L1))") "neqv", &
pa1 .neqv. pa1, pa1 .neqv. pa2, &
pa2 .neqv. pa2, pa2 .neqv. pa3
write (u, *)
write (u, "(A,6(1x,L1))") "match", &
pa1 .match. 0, pa1 .match. 1, &
pa2 .match. 0, pa2 .match. 1, pa2 .match. 3
write (u, "(A)")
write (u, "(A)") "* Test output end: pdg_arrays_1"
end subroutine pdg_arrays_1
@ %def pdg_arrays_1
@ PDG array list, i.e., arrays of arrays.
<<PDG arrays: execute tests>>=
call test (pdg_arrays_2, "pdg_arrays_2", &
"create and sort PDG lists", &
u, results)
<<PDG arrays: test declarations>>=
public :: pdg_arrays_2
<<PDG arrays: tests>>=
subroutine pdg_arrays_2 (u)
integer, intent(in) :: u
type(pdg_array_t) :: pa
type(pdg_list_t) :: pl, pl1
write (u, "(A)") "* Test output: pdg_arrays_2"
write (u, "(A)") "* Purpose: create and sort PDG lists"
write (u, "(A)")
write (u, "(A)") "* Assignment"
write (u, "(A)")
call pl%init (3)
call pl%set (1, 42)
call pl%set (2, [3, 2])
pa = [5, -5]
call pl%set (3, pa)
call pl%write (u)
write (u, *)
write (u, "(A,I0)") "size = ", pl%get_size ()
write (u, "(A)")
write (u, "(A)") "* Sort"
write (u, "(A)")
pl = pl%sort_abs ()
call pl%write (u)
write (u, *)
write (u, "(A)")
write (u, "(A)") "* Extract item #3"
write (u, "(A)")
pa = pl%get (3)
call pa%write (u)
write (u, *)
write (u, "(A)")
write (u, "(A)") "* Replace item #3"
write (u, "(A)")
call pl1%init (2)
call pl1%set (1, [2, 4])
call pl1%set (2, -7)
pl = pl%replace (3, pl1)
call pl%write (u)
write (u, *)
write (u, "(A)")
write (u, "(A)") "* Test output end: pdg_arrays_2"
end subroutine pdg_arrays_2
@ %def pdg_arrays_2
@ Check if a (sorted) PDG array lists is regular. The entries (PDG arrays)
must not overlap, unless they are identical.
<<PDG arrays: execute tests>>=
call test (pdg_arrays_3, "pdg_arrays_3", &
"check PDG lists", &
u, results)
<<PDG arrays: test declarations>>=
public :: pdg_arrays_3
<<PDG arrays: tests>>=
subroutine pdg_arrays_3 (u)
integer, intent(in) :: u
type(pdg_list_t) :: pl
write (u, "(A)") "* Test output: pdg_arrays_3"
write (u, "(A)") "* Purpose: check for regular PDG lists"
write (u, "(A)")
write (u, "(A)") "* Regular list"
write (u, "(A)")
call pl%init (4)
call pl%set (1, [1, 2])
call pl%set (2, [1, 2])
call pl%set (3, [5, -5])
call pl%set (4, 42)
call pl%write (u)
write (u, *)
write (u, "(L1)") pl%is_regular ()
write (u, "(A)")
write (u, "(A)") "* Irregular list"
write (u, "(A)")
call pl%init (4)
call pl%set (1, [1, 2])
call pl%set (2, [1, 2])
call pl%set (3, [2, 5, -5])
call pl%set (4, 42)
call pl%write (u)
write (u, *)
write (u, "(L1)") pl%is_regular ()
write (u, "(A)")
write (u, "(A)") "* Test output end: pdg_arrays_3"
end subroutine pdg_arrays_3
@ %def pdg_arrays_3
@ Compare PDG array lists. The lists must be regular, i.e., sorted and with
non-overlapping (or identical) entries.
<<PDG arrays: execute tests>>=
call test (pdg_arrays_4, "pdg_arrays_4", &
"compare PDG lists", &
u, results)
<<PDG arrays: test declarations>>=
public :: pdg_arrays_4
<<PDG arrays: tests>>=
subroutine pdg_arrays_4 (u)
integer, intent(in) :: u
type(pdg_list_t) :: pl1, pl2, pl3
write (u, "(A)") "* Test output: pdg_arrays_4"
write (u, "(A)") "* Purpose: check for regular PDG lists"
write (u, "(A)")
write (u, "(A)") "* Create lists"
write (u, "(A)")
call pl1%init (4)
call pl1%set (1, [1, 2])
call pl1%set (2, [1, 2])
call pl1%set (3, [5, -5])
call pl1%set (4, 42)
write (u, "(I1,1x)", advance = "no") 1
call pl1%write (u)
write (u, *)
call pl2%init (2)
call pl2%set (1, 3)
call pl2%set (2, [5, -5])
write (u, "(I1,1x)", advance = "no") 2
call pl2%write (u)
write (u, *)
call pl3%init (2)
call pl3%set (1, 4)
call pl3%set (2, [5, -5])
write (u, "(I1,1x)", advance = "no") 3
call pl3%write (u)
write (u, *)
write (u, "(A)")
write (u, "(A)") "* a == b"
write (u, "(A)")
write (u, "(2x,A)") "123"
write (u, *)
write (u, "(I1,1x,4L1)") 1, pl1 == pl1, pl1 == pl2, pl1 == pl3
write (u, "(I1,1x,4L1)") 2, pl2 == pl1, pl2 == pl2, pl2 == pl3
write (u, "(I1,1x,4L1)") 3, pl3 == pl1, pl3 == pl2, pl3 == pl3
write (u, "(A)")
write (u, "(A)") "* a < b"
write (u, "(A)")
write (u, "(2x,A)") "123"
write (u, *)
write (u, "(I1,1x,4L1)") 1, pl1 < pl1, pl1 < pl2, pl1 < pl3
write (u, "(I1,1x,4L1)") 2, pl2 < pl1, pl2 < pl2, pl2 < pl3
write (u, "(I1,1x,4L1)") 3, pl3 < pl1, pl3 < pl2, pl3 < pl3
write (u, "(A)")
write (u, "(A)") "* Test output end: pdg_arrays_4"
end subroutine pdg_arrays_4
@ %def pdg_arrays_4
@ Match-replace: translate all entries in the first list into the
matching entries of the second list, if there is a match.
<<PDG arrays: execute tests>>=
call test (pdg_arrays_5, "pdg_arrays_5", &
"match PDG lists", &
u, results)
<<PDG arrays: test declarations>>=
public :: pdg_arrays_5
<<PDG arrays: tests>>=
subroutine pdg_arrays_5 (u)
integer, intent(in) :: u
type(pdg_list_t) :: pl1, pl2, pl3
logical :: success
write (u, "(A)") "* Test output: pdg_arrays_5"
write (u, "(A)") "* Purpose: match-replace"
write (u, "(A)")
write (u, "(A)") "* Create lists"
write (u, "(A)")
call pl1%init (2)
call pl1%set (1, [1, 2])
call pl1%set (2, 42)
call pl1%write (u)
write (u, *)
call pl3%init (2)
call pl3%set (1, [42, -42])
call pl3%set (2, [1, 2, 3, 4])
call pl1%match_replace (pl3, success)
call pl3%write (u)
write (u, "(1x,A,1x,L1,':',1x)", advance="no") "=>", success
call pl1%write (u)
write (u, *)
write (u, *)
call pl2%init (2)
call pl2%set (1, 9)
call pl2%set (2, 42)
call pl2%write (u)
write (u, *)
call pl2%match_replace (pl3, success)
call pl3%write (u)
write (u, "(1x,A,1x,L1,':',1x)", advance="no") "=>", success
call pl2%write (u)
write (u, *)
write (u, "(A)")
write (u, "(A)") "* Test output end: pdg_arrays_5"
end subroutine pdg_arrays_5
@ %def pdg_arrays_5
@
\clearpage
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{Jets}
The FastJet library is linked externally, if available. The wrapper code is
also in a separate directory. Here, we define \whizard-specific procedures
and tests.
<<[[jets.f90]]>>=
<<File header>>
module jets
use fastjet !NODEP!
<<Standard module head>>
<<Jets: public>>
contains
<<Jets: procedures>>
end module jets
@ %def jets
@
\subsection{Re-exported symbols}
We use this module as a proxy for the FastJet interface, therefore we
re-export some symbols.
<<Jets: public>>=
public :: fastjet_available
public :: fastjet_init
public :: jet_definition_t
public :: pseudojet_t
public :: pseudojet_vector_t
public :: cluster_sequence_t
public :: assignment (=)
@ %def jet_definition_t pseudojet_t pseudojet_vector_t cluster_sequence_t
@ The initialization routine prints the banner.
<<Jets: procedures>>=
subroutine fastjet_init ()
call print_banner ()
end subroutine fastjet_init
@ %def fastjet_init
@ The jet algorithm codes (actually, integers)
<<Jets: public>>=
public :: kt_algorithm
public :: cambridge_algorithm
public :: antikt_algorithm
public :: genkt_algorithm
public :: cambridge_for_passive_algorithm
public :: genkt_for_passive_algorithm
public :: ee_kt_algorithm
public :: ee_genkt_algorithm
public :: plugin_algorithm
public :: undefined_jet_algorithm
@
\subsection{Unit tests}
Test module, followed by the corresponding implementation module.
<<[[jets_ut.f90]]>>=
<<File header>>
module jets_ut
use unit_tests
use jets_uti
<<Standard module head>>
<<Jets: public test>>
contains
<<Jets: test driver>>
end module jets_ut
@ %def jets_ut
@
<<[[jets_uti.f90]]>>=
<<File header>>
module jets_uti
<<Use kinds>>
use fastjet !NODEP!
use jets
<<Standard module head>>
<<Jets: test declarations>>
contains
<<Jets: tests>>
end module jets_uti
@ %def jets_ut
@ API: driver for the unit tests below.
<<Jets: public test>>=
public :: jets_test
<<Jets: test driver>>=
subroutine jets_test (u, results)
integer, intent(in) :: u
type (test_results_t), intent(inout) :: results
<<Jets: execute tests>>
end subroutine jets_test
@ %def jets_test
@ This test is actually the minimal example from the FastJet manual,
translated to Fortran.
Note that FastJet creates pseudojet vectors, which we mirror in the
[[pseudojet_vector_t]], but immediately assign to pseudojet arrays. Without
automatic finalization available in the compilers, we should avoid this in
actual code and rather introduce intermediate variables for those objects,
which we can finalize explicitly.
<<Jets: execute tests>>=
call test (jets_1, "jets_1", &
"basic FastJet functionality", &
u, results)
<<Jets: test declarations>>=
public :: jets_1
<<Jets: tests>>=
subroutine jets_1 (u)
integer, intent(in) :: u
type(pseudojet_t), dimension(:), allocatable :: prt, jets, constituents
type(jet_definition_t) :: jet_def
type(cluster_sequence_t) :: cs
integer, parameter :: dp = default
integer :: i, j
write (u, "(A)") "* Test output: jets_1"
write (u, "(A)") "* Purpose: test basic FastJet functionality"
write (u, "(A)")
write (u, "(A)") "* Print banner"
call print_banner ()
write (u, *)
write (u, "(A)") "* Prepare input particles"
allocate (prt (3))
call prt(1)%init ( 99._dp, 0.1_dp, 0._dp, 100._dp)
call prt(2)%init ( 4._dp,-0.1_dp, 0._dp, 5._dp)
call prt(3)%init (-99._dp, 0._dp, 0._dp, 99._dp)
write (u, *)
write (u, "(A)") "* Define jet algorithm"
call jet_def%init (antikt_algorithm, 0.7_dp)
write (u, *)
write (u, "(A)") "* Cluster particles according to jet algorithm"
write (u, *)
write (u, "(A,A)") "Clustering with ", jet_def%description ()
call cs%init (pseudojet_vector (prt), jet_def)
write (u, *)
write (u, "(A)") "* Sort output jets"
jets = sorted_by_pt (cs%inclusive_jets ())
write (u, *)
write (u, "(A)") "* Print jet observables and constituents"
write (u, *)
write (u, "(4x,3(7x,A3))") "pt", "y", "phi"
do i = 1, size (jets)
write (u, "(A,1x,I0,A,3(1x,F9.5))") &
"jet", i, ":", jets(i)%perp (), jets(i)%rap (), jets(i)%phi ()
constituents = jets(i)%constituents ()
do j = 1, size (constituents)
write (u, "(4x,A,1x,I0,A,F9.5)") &
"constituent", j, "'s pt:", constituents(j)%perp ()
end do
do j = 1, size (constituents)
call constituents(j)%final ()
end do
end do
write (u, *)
write (u, "(A)") "* Cleanup"
do i = 1, size (prt)
call prt(i)%final ()
end do
do i = 1, size (jets)
call jets(i)%final ()
end do
call jet_def%final ()
call cs%final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: jets_1"
end subroutine jets_1
@ %def jets_1
@
\clearpage
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{Subevents}
The purpose of subevents is to store the relevant part of the physical
event (either partonic or hadronic), and to hold particle selections
and combinations which are constructed in cut or analysis expressions.
<<[[subevents.f90]]>>=
<<File header>>
module subevents
use, intrinsic :: iso_c_binding !NODEP!
<<Use kinds>>
use io_units
use format_defs, only: FMT_14, FMT_19
use format_utils, only: pac_fmt
use physics_defs
use sorting
use c_particles
use lorentz
use pdg_arrays
use jets
<<Standard module head>>
<<Subevents: public>>
<<Subevents: parameters>>
<<Subevents: types>>
<<Subevents: interfaces>>
contains
<<Subevents: procedures>>
end module subevents
@ %def subevents
@
\subsection{Particles}
For the purpose of this module, a particle has a type which can
indicate a beam, incoming, outgoing, or composite particle, flavor and
helicity codes (integer, undefined for composite), four-momentum and
invariant mass squared. (Other particles types are used in extended
event types, but also defined here.) Furthermore, each particle has
an allocatable array of ancestors -- particle indices which indicate
the building blocks of a composite particle. For an incoming/outgoing
particle, the array contains only the index of the particle itself.
For incoming particles, the momentum is inverted before storing it in
the particle object.
<<Subevents: parameters>>=
integer, parameter, public :: PRT_UNDEFINED = 0
integer, parameter, public :: PRT_BEAM = -9
integer, parameter, public :: PRT_INCOMING = 1
integer, parameter, public :: PRT_OUTGOING = 2
integer, parameter, public :: PRT_COMPOSITE = 3
integer, parameter, public :: PRT_VIRTUAL = 4
integer, parameter, public :: PRT_RESONANT = 5
integer, parameter, public :: PRT_BEAM_REMNANT = 9
@ %def PRT_UNDEFINED PRT_BEAM
@ %def PRT_INCOMING PRT_OUTGOING PRT_COMPOSITE
@ %def PRT_COMPOSITE PRT_VIRTUAL PRT_RESONANT
@ %def PRT_BEAM_REMNANT
@
\subsubsection{The type}
We initialize only the type here and mark as unpolarized. The
initializers below do the rest. The logicals [[is_b_jet]] and
[[is_c_jet]] are true only if [[prt_t]] comes out of the
[[subevt_cluster]] routine and fulfils the correct flavor content.
<<Subevents: public>>=
public :: prt_t
<<Subevents: types>>=
type :: prt_t
private
integer :: type = PRT_UNDEFINED
integer :: pdg
logical :: polarized = .false.
logical :: colorized = .false.
logical :: clustered = .false.
logical :: is_b_jet = .false.
logical :: is_c_jet = .false.
integer :: h
type(vector4_t) :: p
real(default) :: p2
integer, dimension(:), allocatable :: src
integer, dimension(:), allocatable :: col
integer, dimension(:), allocatable :: acl
end type prt_t
@ %def prt_t
@ Initializers. Polarization is set separately. Finalizers are not
needed.
<<Subevents: procedures>>=
subroutine prt_init_beam (prt, pdg, p, p2, src)
type(prt_t), intent(out) :: prt
integer, intent(in) :: pdg
type(vector4_t), intent(in) :: p
real(default), intent(in) :: p2
integer, dimension(:), intent(in) :: src
prt%type = PRT_BEAM
call prt_set (prt, pdg, - p, p2, src)
end subroutine prt_init_beam
subroutine prt_init_incoming (prt, pdg, p, p2, src)
type(prt_t), intent(out) :: prt
integer, intent(in) :: pdg
type(vector4_t), intent(in) :: p
real(default), intent(in) :: p2
integer, dimension(:), intent(in) :: src
prt%type = PRT_INCOMING
call prt_set (prt, pdg, - p, p2, src)
end subroutine prt_init_incoming
subroutine prt_init_outgoing (prt, pdg, p, p2, src)
type(prt_t), intent(out) :: prt
integer, intent(in) :: pdg
type(vector4_t), intent(in) :: p
real(default), intent(in) :: p2
integer, dimension(:), intent(in) :: src
prt%type = PRT_OUTGOING
call prt_set (prt, pdg, p, p2, src)
end subroutine prt_init_outgoing
subroutine prt_init_composite (prt, p, src)
type(prt_t), intent(out) :: prt
type(vector4_t), intent(in) :: p
integer, dimension(:), intent(in) :: src
prt%type = PRT_COMPOSITE
call prt_set (prt, 0, p, p**2, src)
end subroutine prt_init_composite
@ %def prt_init_beam prt_init_incoming prt_init_outgoing prt_init_composite
@
This version is for temporary particle objects, so the [[src]] array
is not set.
<<Subevents: public>>=
public :: prt_init_combine
<<Subevents: procedures>>=
subroutine prt_init_combine (prt, prt1, prt2)
type(prt_t), intent(out) :: prt
type(prt_t), intent(in) :: prt1, prt2
type(vector4_t) :: p
integer, dimension(0) :: src
prt%type = PRT_COMPOSITE
p = prt1%p + prt2%p
call prt_set (prt, 0, p, p**2, src)
end subroutine prt_init_combine
@ %def prt_init_combine
@ Init from a pseudojet object.
<<Subevents: procedures>>=
subroutine prt_init_pseudojet (prt, jet, src, pdg, is_b_jet, is_c_jet)
type(prt_t), intent(out) :: prt
type(pseudojet_t), intent(in) :: jet
integer, dimension(:), intent(in) :: src
integer, intent(in) :: pdg
logical, intent(in) :: is_b_jet, is_c_jet
type(vector4_t) :: p
prt%type = PRT_COMPOSITE
p = vector4_moving (jet%e(), &
vector3_moving ([jet%px(), jet%py(), jet%pz()]))
call prt_set (prt, pdg, p, p**2, src)
prt%is_b_jet = is_b_jet
prt%is_c_jet = is_c_jet
prt%clustered = .true.
end subroutine prt_init_pseudojet
@ %def prt_init_pseudojet
@
\subsubsection{Accessing contents}
<<Subevents: public>>=
public :: prt_get_pdg
<<Subevents: procedures>>=
elemental function prt_get_pdg (prt) result (pdg)
integer :: pdg
type(prt_t), intent(in) :: prt
pdg = prt%pdg
end function prt_get_pdg
@ %def prt_get_pdg
<<Subevents: public>>=
public :: prt_get_momentum
<<Subevents: procedures>>=
elemental function prt_get_momentum (prt) result (p)
type(vector4_t) :: p
type(prt_t), intent(in) :: prt
p = prt%p
end function prt_get_momentum
@ %def prt_get_momentum
<<Subevents: public>>=
public :: prt_get_msq
<<Subevents: procedures>>=
elemental function prt_get_msq (prt) result (msq)
real(default) :: msq
type(prt_t), intent(in) :: prt
msq = prt%p2
end function prt_get_msq
@ %def prt_get_msq
<<Subevents: public>>=
public :: prt_is_polarized
<<Subevents: procedures>>=
elemental function prt_is_polarized (prt) result (flag)
logical :: flag
type(prt_t), intent(in) :: prt
flag = prt%polarized
end function prt_is_polarized
@ %def prt_is_polarized
<<Subevents: public>>=
public :: prt_get_helicity
<<Subevents: procedures>>=
elemental function prt_get_helicity (prt) result (h)
integer :: h
type(prt_t), intent(in) :: prt
h = prt%h
end function prt_get_helicity
@ %def prt_get_helicity
<<Subevents: public>>=
public :: prt_is_colorized
<<Subevents: procedures>>=
elemental function prt_is_colorized (prt) result (flag)
logical :: flag
type(prt_t), intent(in) :: prt
flag = prt%colorized
end function prt_is_colorized
@ %def prt_is_colorized
<<Subevents: public>>=
public :: prt_is_clustered
<<Subevents: procedures>>=
elemental function prt_is_clustered (prt) result (flag)
logical :: flag
type(prt_t), intent(in) :: prt
flag = prt%clustered
end function prt_is_clustered
@ %def prt_is_clustered
<<Subevents: public>>=
public :: prt_is_photon
<<Subevents: procedures>>=
elemental function prt_is_photon (prt) result (flag)
logical :: flag
type(prt_t), intent(in) :: prt
flag = prt%pdg == PHOTON
end function prt_is_photon
@ %def prt_is_photon
We do not take the top quark into account here.
<<Subevents: public>>=
public :: prt_is_parton
<<Subevents: procedures>>=
elemental function prt_is_parton (prt) result (flag)
logical :: flag
type(prt_t), intent(in) :: prt
flag = abs(prt%pdg) == DOWN_Q .or. &
abs(prt%pdg) == UP_Q .or. &
abs(prt%pdg) == STRANGE_Q .or. &
abs(prt%pdg) == CHARM_Q .or. &
abs(prt%pdg) == BOTTOM_Q .or. &
prt%pdg == GLUON
end function prt_is_parton
@ %def prt_is_photon
<<Subevents: public>>=
public :: prt_is_lepton
<<Subevents: procedures>>=
elemental function prt_is_lepton (prt) result (flag)
logical :: flag
type(prt_t), intent(in) :: prt
flag = abs(prt%pdg) == ELECTRON .or. &
abs(prt%pdg) == MUON .or. &
abs(prt%pdg) == TAU
end function prt_is_lepton
@ %def prt_is_lepton
<<Subevents: public>>=
public :: prt_is_b_jet
<<Subevents: procedures>>=
elemental function prt_is_b_jet (prt) result (flag)
logical :: flag
type(prt_t), intent(in) :: prt
flag = prt%is_b_jet
end function prt_is_b_jet
@ %def prt_is_b_jet
<<Subevents: public>>=
public :: prt_is_c_jet
<<Subevents: procedures>>=
elemental function prt_is_c_jet (prt) result (flag)
logical :: flag
type(prt_t), intent(in) :: prt
flag = prt%is_c_jet
end function prt_is_c_jet
@ %def prt_is_c_jet
@ The number of open color (anticolor) lines. We inspect the list of color
(anticolor) lines and count the entries that do not appear in the list
of anticolors (colors). (There is no check against duplicates; we assume that
color line indices are unique.)
<<Subevents: public>>=
public :: prt_get_n_col
public :: prt_get_n_acl
<<Subevents: procedures>>=
elemental function prt_get_n_col (prt) result (n)
integer :: n
type(prt_t), intent(in) :: prt
integer, dimension(:), allocatable :: col, acl
integer :: i
n = 0
if (prt%colorized) then
do i = 1, size (prt%col)
if (all (prt%col(i) /= prt%acl)) n = n + 1
end do
end if
end function prt_get_n_col
elemental function prt_get_n_acl (prt) result (n)
integer :: n
type(prt_t), intent(in) :: prt
integer, dimension(:), allocatable :: col, acl
integer :: i
n = 0
if (prt%colorized) then
do i = 1, size (prt%acl)
if (all (prt%acl(i) /= prt%col)) n = n + 1
end do
end if
end function prt_get_n_acl
@ %def prt_get_n_col
@ %def prt_get_n_acl
@ Return the color and anticolor-flow line indices explicitly.
<<Subevents: public>>=
public :: prt_get_color_indices
<<Subevents: procedures>>=
subroutine prt_get_color_indices (prt, col, acl)
type(prt_t), intent(in) :: prt
integer, dimension(:), allocatable, intent(out) :: col, acl
if (prt%colorized) then
col = prt%col
acl = prt%acl
else
col = [integer::]
acl = [integer::]
end if
end subroutine prt_get_color_indices
@ %def prt_get_color_indices
@
\subsubsection{Setting data}
Set the PDG, momentum and momentum squared, and ancestors. If
allocate-on-assignment is available, this can be simplified.
<<Subevents: procedures>>=
subroutine prt_set (prt, pdg, p, p2, src)
type(prt_t), intent(inout) :: prt
integer, intent(in) :: pdg
type(vector4_t), intent(in) :: p
real(default), intent(in) :: p2
integer, dimension(:), intent(in) :: src
prt%pdg = pdg
prt%p = p
prt%p2 = p2
if (allocated (prt%src)) then
if (size (src) /= size (prt%src)) then
deallocate (prt%src)
allocate (prt%src (size (src)))
end if
else
allocate (prt%src (size (src)))
end if
prt%src = src
end subroutine prt_set
@ %def prt_set
@ Set the particle PDG code separately.
<<Subevents: procedures>>=
elemental subroutine prt_set_pdg (prt, pdg)
type(prt_t), intent(inout) :: prt
integer, intent(in) :: pdg
prt%pdg = pdg
end subroutine prt_set_pdg
@ %def prt_set_pdg
@ Set the momentum separately.
<<Subevents: procedures>>=
elemental subroutine prt_set_p (prt, p)
type(prt_t), intent(inout) :: prt
type(vector4_t), intent(in) :: p
prt%p = p
end subroutine prt_set_p
@ %def prt_set_p
@ Set the squared invariant mass separately.
<<Subevents: procedures>>=
elemental subroutine prt_set_p2 (prt, p2)
type(prt_t), intent(inout) :: prt
real(default), intent(in) :: p2
prt%p2 = p2
end subroutine prt_set_p2
@ %def prt_set_p2
@ Set helicity (optional).
<<Subevents: procedures>>=
subroutine prt_polarize (prt, h)
type(prt_t), intent(inout) :: prt
integer, intent(in) :: h
prt%polarized = .true.
prt%h = h
end subroutine prt_polarize
@ %def prt_polarize
@ Set color-flow indices (optional).
<<Subevents: procedures>>=
subroutine prt_colorize (prt, col, acl)
type(prt_t), intent(inout) :: prt
integer, dimension(:), intent(in) :: col, acl
prt%colorized = .true.
prt%col = col
prt%acl = acl
end subroutine prt_colorize
@ %def prt_colorize
@
\subsubsection{Conversion}
Transform a [[prt_t]] object into a [[c_prt_t]] object.
<<Subevents: public>>=
public :: c_prt
<<Subevents: interfaces>>=
interface c_prt
module procedure c_prt_from_prt
end interface
@ %def c_prt
<<Subevents: procedures>>=
elemental function c_prt_from_prt (prt) result (c_prt)
type(c_prt_t) :: c_prt
type(prt_t), intent(in) :: prt
c_prt = prt%p
c_prt%type = prt%type
c_prt%pdg = prt%pdg
if (prt%polarized) then
c_prt%polarized = 1
else
c_prt%polarized = 0
end if
c_prt%h = prt%h
end function c_prt_from_prt
@ %def c_prt_from_prt
@
\subsubsection{Output}
<<Subevents: public>>=
public :: prt_write
<<Subevents: procedures>>=
subroutine prt_write (prt, unit, testflag)
type(prt_t), intent(in) :: prt
integer, intent(in), optional :: unit
logical, intent(in), optional :: testflag
logical :: pacified
type(prt_t) :: tmp
character(len=7) :: fmt
integer :: u, i
call pac_fmt (fmt, FMT_19, FMT_14, testflag)
u = given_output_unit (unit); if (u < 0) return
pacified = .false. ; if (present (testflag)) pacified = testflag
tmp = prt
if (pacified) call pacify (tmp)
write (u, "(1x,A)", advance="no") "prt("
select case (prt%type)
case (PRT_UNDEFINED); write (u, "('?')", advance="no")
case (PRT_BEAM); write (u, "('b:')", advance="no")
case (PRT_INCOMING); write (u, "('i:')", advance="no")
case (PRT_OUTGOING); write (u, "('o:')", advance="no")
case (PRT_COMPOSITE); write (u, "('c:')", advance="no")
end select
select case (prt%type)
case (PRT_BEAM, PRT_INCOMING, PRT_OUTGOING)
if (prt%polarized) then
write (u, "(I0,'/',I0,'|')", advance="no") prt%pdg, prt%h
else
write (u, "(I0,'|')", advance="no") prt%pdg
end if
end select
select case (prt%type)
case (PRT_BEAM, PRT_INCOMING, PRT_OUTGOING, PRT_COMPOSITE)
if (prt%colorized) then
write (u, "(*(I0,:,','))", advance="no") prt%col
write (u, "('/')", advance="no")
write (u, "(*(I0,:,','))", advance="no") prt%acl
write (u, "('|')", advance="no")
end if
end select
select case (prt%type)
case (PRT_BEAM, PRT_INCOMING, PRT_OUTGOING, PRT_COMPOSITE)
write (u, "(" // FMT_14 // ",';'," // FMT_14 // ",','," // &
FMT_14 // ",','," // FMT_14 // ")", advance="no") tmp%p
write (u, "('|'," // fmt // ")", advance="no") tmp%p2
end select
if (allocated (prt%src)) then
write (u, "('|')", advance="no")
do i = 1, size (prt%src)
write (u, "(1x,I0)", advance="no") prt%src(i)
end do
end if
if (prt%is_b_jet) then
write (u, "('|b jet')", advance="no")
end if
if (prt%is_c_jet) then
write (u, "('|c jet')", advance="no")
end if
write (u, "(A)") ")"
end subroutine prt_write
@ %def prt_write
@
\subsubsection{Tools}
Two particles match if their [[src]] arrays are the same.
<<Subevents: public>>=
public :: operator(.match.)
<<Subevents: interfaces>>=
interface operator(.match.)
module procedure prt_match
end interface
@ %def .match.
<<Subevents: procedures>>=
elemental function prt_match (prt1, prt2) result (match)
logical :: match
type(prt_t), intent(in) :: prt1, prt2
if (size (prt1%src) == size (prt2%src)) then
match = all (prt1%src == prt2%src)
else
match = .false.
end if
end function prt_match
@ %def prt_match
@ The combine operation makes a pseudoparticle whose momentum is the
result of adding (the momenta of) the pair of input particles. We
trace the particles from which a particle is built by storing a
[[src]] array. Each particle entry in the [[src]] list contains a
list of indices which indicates its building blocks. The indices
refer to an original list of particles. Index lists are sorted, and
they contain no element more than once.
We thus require that in a given pseudoparticle, each original particle
occurs at most once.
The result is intent(inout), so it will not be initialized when the
subroutine is entered.
If the particles carry color, we recall that the combined particle is a
composite which is understood as outgoing. If one of the arguments is an
incoming particle, is color entries must be reversed.
<<Subevents: procedures>>=
subroutine prt_combine (prt, prt_in1, prt_in2, ok)
type(prt_t), intent(inout) :: prt
type(prt_t), intent(in) :: prt_in1, prt_in2
logical :: ok
integer, dimension(:), allocatable :: src
integer, dimension(:), allocatable :: col1, acl1, col2, acl2
call combine_index_lists (src, prt_in1%src, prt_in2%src)
ok = allocated (src)
if (ok) then
call prt_init_composite (prt, prt_in1%p + prt_in2%p, src)
if (prt_in1%colorized .or. prt_in2%colorized) then
select case (prt_in1%type)
case default
call prt_get_color_indices (prt_in1, col1, acl1)
case (PRT_BEAM, PRT_INCOMING)
call prt_get_color_indices (prt_in1, acl1, col1)
end select
select case (prt_in2%type)
case default
call prt_get_color_indices (prt_in2, col2, acl2)
case (PRT_BEAM, PRT_INCOMING)
call prt_get_color_indices (prt_in2, acl2, col2)
end select
call prt_colorize (prt, [col1, col2], [acl1, acl2])
end if
end if
end subroutine prt_combine
@ %def prt_combine
@ This variant does not produce the combined particle, it just checks
whether the combination is valid (no common [[src]] entry).
<<Subevents: public>>=
public :: are_disjoint
<<Subevents: procedures>>=
function are_disjoint (prt_in1, prt_in2) result (flag)
logical :: flag
type(prt_t), intent(in) :: prt_in1, prt_in2
flag = index_lists_are_disjoint (prt_in1%src, prt_in2%src)
end function are_disjoint
@ %def are_disjoint
@ [[src]] Lists with length $>1$ are built by a [[combine]] operation
which merges the lists in a sorted manner. If the result would have a
duplicate entry, it is discarded, and the result is unallocated.
<<Subevents: procedures>>=
subroutine combine_index_lists (res, src1, src2)
integer, dimension(:), intent(in) :: src1, src2
integer, dimension(:), allocatable :: res
integer :: i1, i2, i
allocate (res (size (src1) + size (src2)))
if (size (src1) == 0) then
res = src2
return
else if (size (src2) == 0) then
res = src1
return
end if
i1 = 1
i2 = 1
LOOP: do i = 1, size (res)
if (src1(i1) < src2(i2)) then
res(i) = src1(i1); i1 = i1 + 1
if (i1 > size (src1)) then
res(i+1:) = src2(i2:)
exit LOOP
end if
else if (src1(i1) > src2(i2)) then
res(i) = src2(i2); i2 = i2 + 1
if (i2 > size (src2)) then
res(i+1:) = src1(i1:)
exit LOOP
end if
else
deallocate (res)
exit LOOP
end if
end do LOOP
end subroutine combine_index_lists
@ %def combine_index_lists
@ This function is similar, but it does not actually merge the list,
it just checks whether they are disjoint (no common [[src]] entry).
<<Subevents: procedures>>=
function index_lists_are_disjoint (src1, src2) result (flag)
logical :: flag
integer, dimension(:), intent(in) :: src1, src2
integer :: i1, i2, i
flag = .true.
i1 = 1
i2 = 1
LOOP: do i = 1, size (src1) + size (src2)
if (src1(i1) < src2(i2)) then
i1 = i1 + 1
if (i1 > size (src1)) then
exit LOOP
end if
else if (src1(i1) > src2(i2)) then
i2 = i2 + 1
if (i2 > size (src2)) then
exit LOOP
end if
else
flag = .false.
exit LOOP
end if
end do LOOP
end function index_lists_are_disjoint
@ %def index_lists_are_disjoint
@
\subsection{subevents}
Particles are collected in subevents. This type is implemented as a
dynamically allocated array, which need not be completely filled. The
value [[n_active]] determines the number of meaningful entries.
\subsubsection{Type definition}
<<Subevents: public>>=
public :: subevt_t
<<Subevents: types>>=
type :: subevt_t
private
integer :: n_active = 0
type(prt_t), dimension(:), allocatable :: prt
contains
<<Subevents: subevt: TBP>>
end type subevt_t
@ %def subevt_t
@ Initialize, allocating with size zero (default) or given size. The
number of contained particles is set equal to the size.
<<Subevents: public>>=
public :: subevt_init
<<Subevents: procedures>>=
subroutine subevt_init (subevt, n_active)
type(subevt_t), intent(out) :: subevt
integer, intent(in), optional :: n_active
if (present (n_active)) subevt%n_active = n_active
allocate (subevt%prt (subevt%n_active))
end subroutine subevt_init
@ %def subevt_init
@ (Re-)allocate the subevent with some given size. If the size
is greater than the previous one, do a real reallocation. Otherwise,
just reset the recorded size. Contents are untouched, but become
invalid.
<<Subevents: public>>=
public :: subevt_reset
<<Subevents: procedures>>=
subroutine subevt_reset (subevt, n_active)
type(subevt_t), intent(inout) :: subevt
integer, intent(in) :: n_active
subevt%n_active = n_active
if (subevt%n_active > size (subevt%prt)) then
deallocate (subevt%prt)
allocate (subevt%prt (subevt%n_active))
end if
end subroutine subevt_reset
@ %def subevt_reset
@ Output. No prefix for the headline 'subevt', because this will usually be
printed appending to a previous line.
<<Subevents: public>>=
public :: subevt_write
<<Subevents: subevt: TBP>>=
procedure :: write => subevt_write
<<Subevents: procedures>>=
subroutine subevt_write (object, unit, prefix, pacified)
class(subevt_t), intent(in) :: object
integer, intent(in), optional :: unit
character(*), intent(in), optional :: prefix
logical, intent(in), optional :: pacified
integer :: u, i
u = given_output_unit (unit); if (u < 0) return
write (u, "(1x,A)") "subevent:"
do i = 1, object%n_active
if (present (prefix)) write (u, "(A)", advance="no") prefix
write (u, "(1x,I0)", advance="no") i
call prt_write (object%prt(i), unit = unit, testflag = pacified)
end do
end subroutine subevt_write
@ %def subevt_write
@ Defined assignment: transfer only meaningful entries. This is a
deep copy (as would be default assignment).
<<Subevents: interfaces>>=
interface assignment(=)
module procedure subevt_assign
end interface
@ %def =
<<Subevents: procedures>>=
subroutine subevt_assign (subevt, subevt_in)
type(subevt_t), intent(inout) :: subevt
type(subevt_t), intent(in) :: subevt_in
if (.not. allocated (subevt%prt)) then
call subevt_init (subevt, subevt_in%n_active)
else
call subevt_reset (subevt, subevt_in%n_active)
end if
subevt%prt(:subevt%n_active) = subevt_in%prt(:subevt%n_active)
end subroutine subevt_assign
@ %def subevt_assign
@
\subsubsection{Fill contents}
Store incoming/outgoing particles which are completely defined.
<<Subevents: public>>=
public :: subevt_set_beam
public :: subevt_set_incoming
public :: subevt_set_outgoing
public :: subevt_set_composite
<<Subevents: procedures>>=
subroutine subevt_set_beam (subevt, i, pdg, p, p2, src)
type(subevt_t), intent(inout) :: subevt
integer, intent(in) :: i
integer, intent(in) :: pdg
type(vector4_t), intent(in) :: p
real(default), intent(in) :: p2
integer, dimension(:), intent(in), optional :: src
if (present (src)) then
call prt_init_beam (subevt%prt(i), pdg, p, p2, src)
else
call prt_init_beam (subevt%prt(i), pdg, p, p2, [i])
end if
end subroutine subevt_set_beam
subroutine subevt_set_incoming (subevt, i, pdg, p, p2, src)
type(subevt_t), intent(inout) :: subevt
integer, intent(in) :: i
integer, intent(in) :: pdg
type(vector4_t), intent(in) :: p
real(default), intent(in) :: p2
integer, dimension(:), intent(in), optional :: src
if (present (src)) then
call prt_init_incoming (subevt%prt(i), pdg, p, p2, src)
else
call prt_init_incoming (subevt%prt(i), pdg, p, p2, [i])
end if
end subroutine subevt_set_incoming
subroutine subevt_set_outgoing (subevt, i, pdg, p, p2, src)
type(subevt_t), intent(inout) :: subevt
integer, intent(in) :: i
integer, intent(in) :: pdg
type(vector4_t), intent(in) :: p
real(default), intent(in) :: p2
integer, dimension(:), intent(in), optional :: src
if (present (src)) then
call prt_init_outgoing (subevt%prt(i), pdg, p, p2, src)
else
call prt_init_outgoing (subevt%prt(i), pdg, p, p2, [i])
end if
end subroutine subevt_set_outgoing
subroutine subevt_set_composite (subevt, i, p, src)
type(subevt_t), intent(inout) :: subevt
integer, intent(in) :: i
type(vector4_t), intent(in) :: p
integer, dimension(:), intent(in) :: src
call prt_init_composite (subevt%prt(i), p, src)
end subroutine subevt_set_composite
@ %def subevt_set_incoming subevt_set_outgoing subevt_set_composite
@ Separately assign flavors, simultaneously for all incoming/outgoing
particles.
<<Subevents: public>>=
public :: subevt_set_pdg_beam
public :: subevt_set_pdg_incoming
public :: subevt_set_pdg_outgoing
<<Subevents: procedures>>=
subroutine subevt_set_pdg_beam (subevt, pdg)
type(subevt_t), intent(inout) :: subevt
integer, dimension(:), intent(in) :: pdg
integer :: i, j
j = 1
do i = 1, subevt%n_active
if (subevt%prt(i)%type == PRT_BEAM) then
call prt_set_pdg (subevt%prt(i), pdg(j))
j = j + 1
if (j > size (pdg)) exit
end if
end do
end subroutine subevt_set_pdg_beam
subroutine subevt_set_pdg_incoming (subevt, pdg)
type(subevt_t), intent(inout) :: subevt
integer, dimension(:), intent(in) :: pdg
integer :: i, j
j = 1
do i = 1, subevt%n_active
if (subevt%prt(i)%type == PRT_INCOMING) then
call prt_set_pdg (subevt%prt(i), pdg(j))
j = j + 1
if (j > size (pdg)) exit
end if
end do
end subroutine subevt_set_pdg_incoming
subroutine subevt_set_pdg_outgoing (subevt, pdg)
type(subevt_t), intent(inout) :: subevt
integer, dimension(:), intent(in) :: pdg
integer :: i, j
j = 1
do i = 1, subevt%n_active
if (subevt%prt(i)%type == PRT_OUTGOING) then
call prt_set_pdg (subevt%prt(i), pdg(j))
j = j + 1
if (j > size (pdg)) exit
end if
end do
end subroutine subevt_set_pdg_outgoing
@ %def subevt_set_pdg_beam
@ %def subevt_set_pdg_incoming
@ %def subevt_set_pdg_outgoing
@ Separately assign momenta, simultaneously for all incoming/outgoing
particles.
<<Subevents: public>>=
public :: subevt_set_p_beam
public :: subevt_set_p_incoming
public :: subevt_set_p_outgoing
<<Subevents: procedures>>=
subroutine subevt_set_p_beam (subevt, p)
type(subevt_t), intent(inout) :: subevt
type(vector4_t), dimension(:), intent(in) :: p
integer :: i, j
j = 1
do i = 1, subevt%n_active
if (subevt%prt(i)%type == PRT_BEAM) then
call prt_set_p (subevt%prt(i), p(j))
j = j + 1
if (j > size (p)) exit
end if
end do
end subroutine subevt_set_p_beam
subroutine subevt_set_p_incoming (subevt, p)
type(subevt_t), intent(inout) :: subevt
type(vector4_t), dimension(:), intent(in) :: p
integer :: i, j
j = 1
do i = 1, subevt%n_active
if (subevt%prt(i)%type == PRT_INCOMING) then
call prt_set_p (subevt%prt(i), p(j))
j = j + 1
if (j > size (p)) exit
end if
end do
end subroutine subevt_set_p_incoming
subroutine subevt_set_p_outgoing (subevt, p)
type(subevt_t), intent(inout) :: subevt
type(vector4_t), dimension(:), intent(in) :: p
integer :: i, j
j = 1
do i = 1, subevt%n_active
if (subevt%prt(i)%type == PRT_OUTGOING) then
call prt_set_p (subevt%prt(i), p(j))
j = j + 1
if (j > size (p)) exit
end if
end do
end subroutine subevt_set_p_outgoing
@ %def subevt_set_p_beam
@ %def subevt_set_p_incoming
@ %def subevt_set_p_outgoing
@ Separately assign the squared invariant mass, simultaneously for all
incoming/outgoing particles.
<<Subevents: public>>=
public :: subevt_set_p2_beam
public :: subevt_set_p2_incoming
public :: subevt_set_p2_outgoing
<<Subevents: procedures>>=
subroutine subevt_set_p2_beam (subevt, p2)
type(subevt_t), intent(inout) :: subevt
real(default), dimension(:), intent(in) :: p2
integer :: i, j
j = 1
do i = 1, subevt%n_active
if (subevt%prt(i)%type == PRT_BEAM) then
call prt_set_p2 (subevt%prt(i), p2(j))
j = j + 1
if (j > size (p2)) exit
end if
end do
end subroutine subevt_set_p2_beam
subroutine subevt_set_p2_incoming (subevt, p2)
type(subevt_t), intent(inout) :: subevt
real(default), dimension(:), intent(in) :: p2
integer :: i, j
j = 1
do i = 1, subevt%n_active
if (subevt%prt(i)%type == PRT_INCOMING) then
call prt_set_p2 (subevt%prt(i), p2(j))
j = j + 1
if (j > size (p2)) exit
end if
end do
end subroutine subevt_set_p2_incoming
subroutine subevt_set_p2_outgoing (subevt, p2)
type(subevt_t), intent(inout) :: subevt
real(default), dimension(:), intent(in) :: p2
integer :: i, j
j = 1
do i = 1, subevt%n_active
if (subevt%prt(i)%type == PRT_OUTGOING) then
call prt_set_p2 (subevt%prt(i), p2(j))
j = j + 1
if (j > size (p2)) exit
end if
end do
end subroutine subevt_set_p2_outgoing
@ %def subevt_set_p2_beam
@ %def subevt_set_p2_incoming
@ %def subevt_set_p2_outgoing
@ Set polarization for an entry
<<Subevents: public>>=
public :: subevt_polarize
<<Subevents: procedures>>=
subroutine subevt_polarize (subevt, i, h)
type(subevt_t), intent(inout) :: subevt
integer, intent(in) :: i, h
call prt_polarize (subevt%prt(i), h)
end subroutine subevt_polarize
@ %def subevt_polarize
@ Set color-flow indices for an entry
<<Subevents: public>>=
public :: subevt_colorize
<<Subevents: procedures>>=
subroutine subevt_colorize (subevt, i, col, acl)
type(subevt_t), intent(inout) :: subevt
integer, intent(in) :: i, col, acl
if (col > 0 .and. acl > 0) then
call prt_colorize (subevt%prt(i), [col], [acl])
else if (col > 0) then
call prt_colorize (subevt%prt(i), [col], [integer ::])
else if (acl > 0) then
call prt_colorize (subevt%prt(i), [integer ::], [acl])
else
call prt_colorize (subevt%prt(i), [integer ::], [integer ::])
end if
end subroutine subevt_colorize
@ %def subevt_colorize
@
\subsubsection{Accessing contents}
Return true if the subevent has entries.
<<Subevents: public>>=
public :: subevt_is_nonempty
<<Subevents: procedures>>=
function subevt_is_nonempty (subevt) result (flag)
logical :: flag
type(subevt_t), intent(in) :: subevt
flag = subevt%n_active /= 0
end function subevt_is_nonempty
@ %def subevt_is_nonempty
@ Return the number of entries
<<Subevents: public>>=
public :: subevt_get_length
<<Subevents: procedures>>=
function subevt_get_length (subevt) result (length)
integer :: length
type(subevt_t), intent(in) :: subevt
length = subevt%n_active
end function subevt_get_length
@ %def subevt_get_length
@ Return a specific particle. The index is not checked for validity.
<<Subevents: public>>=
public :: subevt_get_prt
<<Subevents: procedures>>=
function subevt_get_prt (subevt, i) result (prt)
type(prt_t) :: prt
type(subevt_t), intent(in) :: subevt
integer, intent(in) :: i
prt = subevt%prt(i)
end function subevt_get_prt
@ %def subevt_get_prt
@ Return the partonic energy squared. We take the particles with flag
[[PRT_INCOMING]] and compute their total invariant mass.
<<Subevents: public>>=
public :: subevt_get_sqrts_hat
<<Subevents: procedures>>=
function subevt_get_sqrts_hat (subevt) result (sqrts_hat)
type(subevt_t), intent(in) :: subevt
real(default) :: sqrts_hat
type(vector4_t) :: p
integer :: i
do i = 1, subevt%n_active
if (subevt%prt(i)%type == PRT_INCOMING) then
p = p + prt_get_momentum (subevt%prt(i))
end if
end do
sqrts_hat = p ** 1
end function subevt_get_sqrts_hat
@ %def subevt_get_sqrts_hat
@ Return the number of incoming (outgoing) particles, respectively.
Beam particles or composites are not counted.
<<Subevents: public>>=
public :: subevt_get_n_in
public :: subevt_get_n_out
<<Subevents: procedures>>=
function subevt_get_n_in (subevt) result (n_in)
type(subevt_t), intent(in) :: subevt
integer :: n_in
n_in = count (subevt%prt(:subevt%n_active)%type == PRT_INCOMING)
end function subevt_get_n_in
function subevt_get_n_out (subevt) result (n_out)
type(subevt_t), intent(in) :: subevt
integer :: n_out
n_out = count (subevt%prt(:subevt%n_active)%type == PRT_OUTGOING)
end function subevt_get_n_out
@ %def subevt_get_n_in
@ %def subevt_get_n_out
@
<<Subevents: interfaces>>=
interface c_prt
module procedure c_prt_from_subevt
module procedure c_prt_array_from_subevt
end interface
@ %def c_prt
<<Subevents: procedures>>=
function c_prt_from_subevt (subevt, i) result (c_prt)
type(c_prt_t) :: c_prt
type(subevt_t), intent(in) :: subevt
integer, intent(in) :: i
c_prt = c_prt_from_prt (subevt%prt(i))
end function c_prt_from_subevt
function c_prt_array_from_subevt (subevt) result (c_prt_array)
type(subevt_t), intent(in) :: subevt
type(c_prt_t), dimension(subevt%n_active) :: c_prt_array
c_prt_array = c_prt_from_prt (subevt%prt(1:subevt%n_active))
end function c_prt_array_from_subevt
@ %def c_prt_from_subevt
@ %def c_prt_array_from_subevt
@
\subsubsection{Operations with subevents}
The join operation joins two subevents. When appending the
elements of the second list, we check for each particle whether it is
already in the first list. If yes, it is discarded. The result list
should be initialized already.
If a mask is present, it refers to the second subevent.
Particles where the mask is not set are discarded.
<<Subevents: public>>=
public :: subevt_join
<<Subevents: procedures>>=
subroutine subevt_join (subevt, pl1, pl2, mask2)
type(subevt_t), intent(inout) :: subevt
type(subevt_t), intent(in) :: pl1, pl2
logical, dimension(:), intent(in), optional :: mask2
integer :: n1, n2, i, n
n1 = pl1%n_active
n2 = pl2%n_active
call subevt_reset (subevt, n1 + n2)
subevt%prt(:n1) = pl1%prt(:n1)
n = n1
if (present (mask2)) then
do i = 1, pl2%n_active
if (mask2(i)) then
if (disjoint (i)) then
n = n + 1
subevt%prt(n) = pl2%prt(i)
end if
end if
end do
else
do i = 1, pl2%n_active
if (disjoint (i)) then
n = n + 1
subevt%prt(n) = pl2%prt(i)
end if
end do
end if
subevt%n_active = n
contains
function disjoint (i) result (flag)
integer, intent(in) :: i
logical :: flag
integer :: j
do j = 1, pl1%n_active
if (.not. are_disjoint (pl1%prt(j), pl2%prt(i))) then
flag = .false.
return
end if
end do
flag = .true.
end function disjoint
end subroutine subevt_join
@ %def subevt_join
@ The combine operation makes a subevent whose entries are the
result of adding (the momenta of) each pair of particles in the input
lists. We trace the particles from which a particles is built by
storing a [[src]] array. Each particle entry in the [[src]] list
contains a list of indices which indicates its building blocks. The
indices refer to an original list of particles. Index lists are sorted,
and they contain no element more than once.
We thus require that in a given pseudoparticle, each original particle
occurs at most once.
<<Subevents: public>>=
public :: subevt_combine
<<Subevents: procedures>>=
subroutine subevt_combine (subevt, pl1, pl2, mask12)
type(subevt_t), intent(inout) :: subevt
type(subevt_t), intent(in) :: pl1, pl2
logical, dimension(:,:), intent(in), optional :: mask12
integer :: n1, n2, i1, i2, n, j
logical :: ok
n1 = pl1%n_active
n2 = pl2%n_active
call subevt_reset (subevt, n1 * n2)
n = 1
do i1 = 1, n1
do i2 = 1, n2
if (present (mask12)) then
ok = mask12(i1,i2)
else
ok = .true.
end if
if (ok) call prt_combine &
(subevt%prt(n), pl1%prt(i1), pl2%prt(i2), ok)
if (ok) then
CHECK_DOUBLES: do j = 1, n - 1
if (subevt%prt(n) .match. subevt%prt(j)) then
ok = .false.; exit CHECK_DOUBLES
end if
end do CHECK_DOUBLES
if (ok) n = n + 1
end if
end do
end do
subevt%n_active = n - 1
end subroutine subevt_combine
@ %def subevt_combine
@ The collect operation makes a single-entry subevent which
results from combining (the momenta of) all particles in the input
list. As above, the result does not contain an original particle more
than once; this is checked for each particle when it is collected.
Furthermore, each entry has a mask; where the mask is false, the entry
is dropped.
(Thus, if the input particles are already composite, there is some
chance that the result depends on the order of the input list and is
not as expected. This situation should be avoided.)
<<Subevents: public>>=
public :: subevt_collect
<<Subevents: procedures>>=
subroutine subevt_collect (subevt, pl1, mask1)
type(subevt_t), intent(inout) :: subevt
type(subevt_t), intent(in) :: pl1
logical, dimension(:), intent(in) :: mask1
type(prt_t) :: prt
integer :: i
logical :: ok
call subevt_reset (subevt, 1)
subevt%n_active = 0
do i = 1, pl1%n_active
if (mask1(i)) then
if (subevt%n_active == 0) then
subevt%n_active = 1
subevt%prt(1) = pl1%prt(i)
else
call prt_combine (prt, subevt%prt(1), pl1%prt(i), ok)
if (ok) subevt%prt(1) = prt
end if
end if
end do
end subroutine subevt_collect
@ %def subevt_collect
@ The cluster operation is similar to [[collect]], but applies a jet
algorithm. The result is a subevent consisting of jets and, possibly,
unclustered extra particles. As above, the result does not contain an
original particle more than once; this is checked for each particle when it is
collected. Furthermore, each entry has a mask; where the mask is false, the
entry is dropped.
The algorithm: first determine the (pseudo)particles that participate in the
clustering. They should not overlap, and the mask entry must be set. We then
cluster the particles, using the given jet definition. The result particles are
retrieved from the cluster sequence. We still have to determine the source
indices for each jet: for each input particle, we get the jet index.
Accumulating the source entries for all particles that are part of a given
jet, we derive the jet source entries. Finally, we delete the C structures
that have been constructed by FastJet and its interface.
<<Subevents: public>>=
public :: subevt_cluster
<<Subevents: procedures>>=
subroutine subevt_cluster (subevt, pl1, dcut, mask1, jet_def, &
keep_jets, exclusive)
type(subevt_t), intent(inout) :: subevt
type(subevt_t), intent(in) :: pl1
real(default), intent(in) :: dcut
logical, dimension(:), intent(in) :: mask1
type(jet_definition_t), intent(in) :: jet_def
logical, intent(in) :: keep_jets, exclusive
integer, dimension(:), allocatable :: map, jet_index
type(pseudojet_t), dimension(:), allocatable :: jet_in, jet_out
type(pseudojet_vector_t) :: jv_in, jv_out
type(cluster_sequence_t) :: cs
integer :: i, n_src, n_active
call map_prt_index (pl1, mask1, n_src, map)
n_active = count (map /= 0)
allocate (jet_in (n_active))
allocate (jet_index (n_active))
do i = 1, n_active
call jet_in(i)%init (prt_get_momentum (pl1%prt(map(i))))
end do
call jv_in%init (jet_in)
call cs%init (jv_in, jet_def)
if (exclusive) then
jv_out = cs%exclusive_jets (dcut)
else
jv_out = cs%inclusive_jets ()
end if
call cs%assign_jet_indices (jv_out, jet_index)
allocate (jet_out (jv_out%size ()))
jet_out = jv_out
call fill_pseudojet (subevt, pl1, jet_out, jet_index, n_src, map)
do i = 1, size (jet_out)
call jet_out(i)%final ()
end do
call jv_out%final ()
call cs%final ()
call jv_in%final ()
do i = 1, size (jet_in)
call jet_in(i)%final ()
end do
contains
! Uniquely combine sources and add map those new indices to the old ones
subroutine map_prt_index (pl1, mask1, n_src, map)
type(subevt_t), intent(in) :: pl1
logical, dimension(:), intent(in) :: mask1
integer, intent(out) :: n_src
integer, dimension(:), allocatable, intent(out) :: map
integer, dimension(:), allocatable :: src, src_tmp
integer :: i
allocate (src(0))
allocate (map (pl1%n_active), source = 0)
n_active = 0
do i = 1, pl1%n_active
if (.not. mask1(i)) cycle
call combine_index_lists (src_tmp, src, pl1%prt(i)%src)
if (.not. allocated (src_tmp)) cycle
call move_alloc (from=src_tmp, to=src)
n_active = n_active + 1
map(n_active) = i
end do
n_src = size (src)
end subroutine map_prt_index
! Retrieve source(s) of a jet and fill corresponding subevent
subroutine fill_pseudojet (subevt, pl1, jet_out, jet_index, n_src, map)
type(subevt_t), intent(inout) :: subevt
type(subevt_t), intent(in) :: pl1
type(pseudojet_t), dimension(:), intent(in) :: jet_out
integer, dimension(:), intent(in) :: jet_index
integer, dimension(:), intent(in) :: map
integer, intent(in) :: n_src
integer, dimension(n_src) :: src_fill
integer :: i, jet, k, combined_pdg, pdg, n_quarks, n_src_fill
logical :: is_b, is_c
call subevt_reset (subevt, size (jet_out))
do jet = 1, size (jet_out)
pdg = 0; src_fill = 0; n_src_fill = 0; combined_pdg = 0; n_quarks = 0
is_b = .false.; is_c = .false.
PARTICLE: do i = 1, size (jet_index)
if (jet_index(i) /= jet) cycle PARTICLE
associate (prt => pl1%prt(map(i)), n_src_prt => size(pl1%prt(map(i))%src))
do k = 1, n_src_prt
src_fill(n_src_fill + k) = prt%src(k)
end do
n_src_fill = n_src_fill + n_src_prt
if (is_quark (prt%pdg)) then
n_quarks = n_quarks + 1
if (.not. is_b) then
if (abs (prt%pdg) == 5) then
is_b = .true.
is_c = .false.
else if (abs (prt%pdg) == 4) then
is_c = .true.
end if
end if
if (combined_pdg == 0) combined_pdg = prt%pdg
end if
end associate
end do PARTICLE
if (keep_jets .and. n_quarks == 1) pdg = combined_pdg
call prt_init_pseudojet (subevt%prt(jet), jet_out(jet), &
src_fill(:n_src_fill), pdg, is_b, is_c)
end do
end subroutine fill_pseudojet
end subroutine subevt_cluster
@ %def subevt_cluster
@ Return a list of all particles for which the mask is true.
<<Subevents: public>>=
public :: subevt_select
<<Subevents: procedures>>=
subroutine subevt_select (subevt, pl, mask1)
type(subevt_t), intent(inout) :: subevt
type(subevt_t), intent(in) :: pl
logical, dimension(:), intent(in) :: mask1
integer :: i, n
call subevt_reset (subevt, pl%n_active)
n = 0
do i = 1, pl%n_active
if (mask1(i)) then
n = n + 1
subevt%prt(n) = pl%prt(i)
end if
end do
subevt%n_active = n
end subroutine subevt_select
@ %def subevt_select
@ Return a subevent which consists of the single particle with
specified [[index]]. If [[index]] is negative, count from the end.
If it is out of bounds, return an empty list.
<<Subevents: public>>=
public :: subevt_extract
<<Subevents: procedures>>=
subroutine subevt_extract (subevt, pl, index)
type(subevt_t), intent(inout) :: subevt
type(subevt_t), intent(in) :: pl
integer, intent(in) :: index
if (index > 0) then
if (index <= pl%n_active) then
call subevt_reset (subevt, 1)
subevt%prt(1) = pl%prt(index)
else
call subevt_reset (subevt, 0)
end if
else if (index < 0) then
if (abs (index) <= pl%n_active) then
call subevt_reset (subevt, 1)
subevt%prt(1) = pl%prt(pl%n_active + 1 + index)
else
call subevt_reset (subevt, 0)
end if
else
call subevt_reset (subevt, 0)
end if
end subroutine subevt_extract
@ %def subevt_extract
@ Return the list of particles sorted according to increasing values
of the provided integer or real array. If no array is given, sort by
PDG value.
<<Subevents: public>>=
public :: subevt_sort
<<Subevents: interfaces>>=
interface subevt_sort
module procedure subevt_sort_pdg
module procedure subevt_sort_int
module procedure subevt_sort_real
end interface
<<Subevents: procedures>>=
subroutine subevt_sort_pdg (subevt, pl)
type(subevt_t), intent(inout) :: subevt
type(subevt_t), intent(in) :: pl
integer :: n
n = subevt%n_active
call subevt_sort_int (subevt, pl, abs (3 * subevt%prt(:n)%pdg - 1))
end subroutine subevt_sort_pdg
subroutine subevt_sort_int (subevt, pl, ival)
type(subevt_t), intent(inout) :: subevt
type(subevt_t), intent(in) :: pl
integer, dimension(:), intent(in) :: ival
call subevt_reset (subevt, pl%n_active)
subevt%n_active = pl%n_active
subevt%prt = pl%prt( order (ival) )
end subroutine subevt_sort_int
subroutine subevt_sort_real (subevt, pl, rval)
type(subevt_t), intent(inout) :: subevt
type(subevt_t), intent(in) :: pl
real(default), dimension(:), intent(in) :: rval
integer :: i
integer, dimension(size(rval)) :: idx
call subevt_reset (subevt, pl%n_active)
subevt%n_active = pl%n_active
if (allocated (subevt%prt)) deallocate (subevt%prt)
allocate (subevt%prt (size(pl%prt)))
idx = order (rval)
do i = 1, size (idx)
subevt%prt(i) = pl%prt (idx(i))
end do
end subroutine subevt_sort_real
@ %def subevt_sort
@ Return the list of particles which have any of the specified PDG
codes (and optionally particle type: beam, incoming, outgoing).
<<Subevents: public>>=
public :: subevt_select_pdg_code
<<Subevents: procedures>>=
subroutine subevt_select_pdg_code (subevt, aval, subevt_in, prt_type)
type(subevt_t), intent(inout) :: subevt
type(pdg_array_t), intent(in) :: aval
type(subevt_t), intent(in) :: subevt_in
integer, intent(in), optional :: prt_type
integer :: n_active, n_match
logical, dimension(:), allocatable :: mask
integer :: i, j
n_active = subevt_in%n_active
allocate (mask (n_active))
forall (i = 1:n_active) &
mask(i) = aval .match. subevt_in%prt(i)%pdg
if (present (prt_type)) &
mask = mask .and. subevt_in%prt(:n_active)%type == prt_type
n_match = count (mask)
call subevt_reset (subevt, n_match)
j = 0
do i = 1, n_active
if (mask(i)) then
j = j + 1
subevt%prt(j) = subevt_in%prt(i)
end if
end do
end subroutine subevt_select_pdg_code
@ %def subevt_select_pdg_code
@
\subsection{Eliminate numerical noise}
This is useful for testing purposes: set entries to zero that are smaller in
absolute values than a given tolerance parameter.
Note: instead of setting the tolerance in terms of EPSILON
(kind-dependent), we fix it to $10^{-16}$, which is the typical value
for double precision. The reason is that there are situations where
intermediate representations (external libraries, files) are limited
to double precision, even if the main program uses higher precision.
<<Subevents: public>>=
public :: pacify
<<Subevents: interfaces>>=
interface pacify
module procedure pacify_prt
module procedure pacify_subevt
end interface pacify
@ %def pacify
<<Subevents: procedures>>=
subroutine pacify_prt (prt)
class(prt_t), intent(inout) :: prt
real(default) :: e
e = max (1E-10_default * energy (prt%p), 1E-13_default)
call pacify (prt%p, e)
call pacify (prt%p2, 1E3_default * e)
end subroutine pacify_prt
subroutine pacify_subevt (subevt)
class(subevt_t), intent(inout) :: subevt
integer :: i
do i = 1, subevt%n_active
call pacify (subevt%prt(i))
end do
end subroutine pacify_subevt
@ %def pacify_prt
@ %def pacify_subevt
@
\clearpage
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{Analysis tools}
This module defines structures useful for data analysis. These
include observables, histograms, and plots.
Observables are quantities that are calculated and summed up event by
event. At the end, one can compute the average and error.
Histograms have their bins in addition to the observable properties.
Histograms are usually written out in tables and displayed
graphically.
In plots, each record creates its own entry in a table. This can be
used for scatter plots if called event by event, or for plotting
dependencies on parameters if called once per integration run.
Graphs are container for histograms and plots, which carry their own graphics
options.
The type layout is still somewhat obfuscated. This would become much simpler
if type extension could be used.
<<[[analysis.f90]]>>=
<<File header>>
module analysis
<<Use kinds>>
<<Use strings>>
use io_units
use format_utils, only: quote_underscore, tex_format
use system_defs, only: TAB
use diagnostics
use os_interface
use ifiles
<<Standard module head>>
<<Analysis: public>>
<<Analysis: parameters>>
<<Analysis: types>>
<<Analysis: interfaces>>
<<Analysis: variables>>
contains
<<Analysis: procedures>>
end module analysis
@ %def analysis
@
\subsection{Output formats}
These formats share a common field width (alignment).
<<Analysis: parameters>>=
character(*), parameter, public :: HISTOGRAM_HEAD_FORMAT = "1x,A15,3x"
character(*), parameter, public :: HISTOGRAM_INTG_FORMAT = "3x,I9,3x"
character(*), parameter, public :: HISTOGRAM_DATA_FORMAT = "ES19.12"
@ %def HISTOGRAM_HEAD_FORMAT HISTOGRAM_INTG_FORMAT HISTOGRAM_DATA_FORMAT
@
\subsection{Graph options}
These parameters are used for displaying data. They apply to a whole graph,
which may contain more than one plot element.
The GAMELAN code chunks are part of both [[graph_options]] and
[[drawing_options]]. The [[drawing_options]] copy is used in histograms and
plots, also as graph elements. The [[graph_options]] copy is used for
[[graph]] objects as a whole. Both copies are usually identical.
<<Analysis: public>>=
public :: graph_options_t
<<Analysis: types>>=
type :: graph_options_t
private
type(string_t) :: id
type(string_t) :: title
type(string_t) :: description
type(string_t) :: x_label
type(string_t) :: y_label
integer :: width_mm = 130
integer :: height_mm = 90
logical :: x_log = .false.
logical :: y_log = .false.
real(default) :: x_min = 0
real(default) :: x_max = 1
real(default) :: y_min = 0
real(default) :: y_max = 1
logical :: x_min_set = .false.
logical :: x_max_set = .false.
logical :: y_min_set = .false.
logical :: y_max_set = .false.
type(string_t) :: gmlcode_bg
type(string_t) :: gmlcode_fg
end type graph_options_t
@ %def graph_options_t
@ Initialize the record, all strings are empty. The limits are undefined.
<<Analysis: public>>=
public :: graph_options_init
<<Analysis: procedures>>=
subroutine graph_options_init (graph_options)
type(graph_options_t), intent(out) :: graph_options
graph_options%id = ""
graph_options%title = ""
graph_options%description = ""
graph_options%x_label = ""
graph_options%y_label = ""
graph_options%gmlcode_bg = ""
graph_options%gmlcode_fg = ""
end subroutine graph_options_init
@ %def graph_options_init
@ Set individual options.
<<Analysis: public>>=
public :: graph_options_set
<<Analysis: procedures>>=
subroutine graph_options_set (graph_options, id, &
title, description, x_label, y_label, width_mm, height_mm, &
x_log, y_log, x_min, x_max, y_min, y_max, &
gmlcode_bg, gmlcode_fg)
type(graph_options_t), intent(inout) :: graph_options
type(string_t), intent(in), optional :: id
type(string_t), intent(in), optional :: title
type(string_t), intent(in), optional :: description
type(string_t), intent(in), optional :: x_label, y_label
integer, intent(in), optional :: width_mm, height_mm
logical, intent(in), optional :: x_log, y_log
real(default), intent(in), optional :: x_min, x_max, y_min, y_max
type(string_t), intent(in), optional :: gmlcode_bg, gmlcode_fg
if (present (id)) graph_options%id = id
if (present (title)) graph_options%title = title
if (present (description)) graph_options%description = description
if (present (x_label)) graph_options%x_label = x_label
if (present (y_label)) graph_options%y_label = y_label
if (present (width_mm)) graph_options%width_mm = width_mm
if (present (height_mm)) graph_options%height_mm = height_mm
if (present (x_log)) graph_options%x_log = x_log
if (present (y_log)) graph_options%y_log = y_log
if (present (x_min)) graph_options%x_min = x_min
if (present (x_max)) graph_options%x_max = x_max
if (present (y_min)) graph_options%y_min = y_min
if (present (y_max)) graph_options%y_max = y_max
if (present (x_min)) graph_options%x_min_set = .true.
if (present (x_max)) graph_options%x_max_set = .true.
if (present (y_min)) graph_options%y_min_set = .true.
if (present (y_max)) graph_options%y_max_set = .true.
if (present (gmlcode_bg)) graph_options%gmlcode_bg = gmlcode_bg
if (present (gmlcode_fg)) graph_options%gmlcode_fg = gmlcode_fg
end subroutine graph_options_set
@ %def graph_options_set
@ Write a simple account of all options.
<<Analysis: public>>=
public :: graph_options_write
<<Analysis: procedures>>=
subroutine graph_options_write (gro, unit)
type(graph_options_t), intent(in) :: gro
integer, intent(in), optional :: unit
integer :: u
u = given_output_unit (unit)
1 format (A,1x,'"',A,'"')
2 format (A,1x,L1)
3 format (A,1x,ES19.12)
4 format (A,1x,I0)
5 format (A,1x,'[undefined]')
write (u, 1) "title =", char (gro%title)
write (u, 1) "description =", char (gro%description)
write (u, 1) "x_label =", char (gro%x_label)
write (u, 1) "y_label =", char (gro%y_label)
write (u, 2) "x_log =", gro%x_log
write (u, 2) "y_log =", gro%y_log
if (gro%x_min_set) then
write (u, 3) "x_min =", gro%x_min
else
write (u, 5) "x_min ="
end if
if (gro%x_max_set) then
write (u, 3) "x_max =", gro%x_max
else
write (u, 5) "x_max ="
end if
if (gro%y_min_set) then
write (u, 3) "y_min =", gro%y_min
else
write (u, 5) "y_min ="
end if
if (gro%y_max_set) then
write (u, 3) "y_max =", gro%y_max
else
write (u, 5) "y_max ="
end if
write (u, 4) "width_mm =", gro%width_mm
write (u, 4) "height_mm =", gro%height_mm
write (u, 1) "gmlcode_bg =", char (gro%gmlcode_bg)
write (u, 1) "gmlcode_fg =", char (gro%gmlcode_fg)
end subroutine graph_options_write
@ %def graph_options_write
@ Write a \LaTeX\ header/footer for the analysis file.
<<Analysis: procedures>>=
subroutine graph_options_write_tex_header (gro, unit)
type(graph_options_t), intent(in) :: gro
integer, intent(in), optional :: unit
integer :: u
u = given_output_unit (unit)
if (gro%title /= "") then
write (u, "(A)")
write (u, "(A)") "\section{" // char (gro%title) // "}"
else
write (u, "(A)") "\section{" // char (quote_underscore (gro%id)) // "}"
end if
if (gro%description /= "") then
write (u, "(A)") char (gro%description)
write (u, *)
write (u, "(A)") "\vspace*{\baselineskip}"
end if
write (u, "(A)") "\vspace*{\baselineskip}"
write (u, "(A)") "\unitlength 1mm"
write (u, "(A,I0,',',I0,A)") &
"\begin{gmlgraph*}(", &
gro%width_mm, gro%height_mm, &
")[dat]"
end subroutine graph_options_write_tex_header
subroutine graph_options_write_tex_footer (gro, unit)
type(graph_options_t), intent(in) :: gro
integer, intent(in), optional :: unit
integer :: u, width, height
width = gro%width_mm - 10
height = gro%height_mm - 10
u = given_output_unit (unit)
write (u, "(A)") " begingmleps ""Whizard-Logo.eps"";"
write (u, "(A,I0,A,I0,A)") &
" base := (", width, "*unitlength,", height, "*unitlength);"
write (u, "(A)") " height := 9.6*unitlength;"
write (u, "(A)") " width := 11.2*unitlength;"
write (u, "(A)") " endgmleps;"
write (u, "(A)") "\end{gmlgraph*}"
end subroutine graph_options_write_tex_footer
@ %def graph_options_write_tex_header
@ %def graph_options_write_tex_footer
@ Return the analysis object ID.
<<Analysis: procedures>>=
function graph_options_get_id (gro) result (id)
type(string_t) :: id
type(graph_options_t), intent(in) :: gro
id = gro%id
end function graph_options_get_id
@ %def graph_options_get_id
@ Create an appropriate [[setup]] command (linear/log).
<<Analysis: procedures>>=
function graph_options_get_gml_setup (gro) result (cmd)
type(string_t) :: cmd
type(graph_options_t), intent(in) :: gro
type(string_t) :: x_str, y_str
if (gro%x_log) then
x_str = "log"
else
x_str = "linear"
end if
if (gro%y_log) then
y_str = "log"
else
y_str = "linear"
end if
cmd = "setup (" // x_str // ", " // y_str // ");"
end function graph_options_get_gml_setup
@ %def graph_options_get_gml_setup
@ Return the labels in GAMELAN form.
<<Analysis: procedures>>=
function graph_options_get_gml_x_label (gro) result (cmd)
type(string_t) :: cmd
type(graph_options_t), intent(in) :: gro
cmd = 'label.bot (<' // '<' // gro%x_label // '>' // '>, out);'
end function graph_options_get_gml_x_label
function graph_options_get_gml_y_label (gro) result (cmd)
type(string_t) :: cmd
type(graph_options_t), intent(in) :: gro
cmd = 'label.ulft (<' // '<' // gro%y_label // '>' // '>, out);'
end function graph_options_get_gml_y_label
@ %def graph_options_get_gml_x_label
@ %def graph_options_get_gml_y_label
@ Create an appropriate [[graphrange]] statement for the given graph options.
Where the graph options are not set, use the supplied arguments, if any,
otherwise set the undefined value.
<<Analysis: procedures>>=
function graph_options_get_gml_graphrange &
(gro, x_min, x_max, y_min, y_max) result (cmd)
type(string_t) :: cmd
type(graph_options_t), intent(in) :: gro
real(default), intent(in), optional :: x_min, x_max, y_min, y_max
type(string_t) :: x_min_str, x_max_str, y_min_str, y_max_str
character(*), parameter :: fmt = "(ES15.8)"
if (gro%x_min_set) then
x_min_str = "#" // trim (adjustl (real2string (gro%x_min, fmt)))
else if (present (x_min)) then
x_min_str = "#" // trim (adjustl (real2string (x_min, fmt)))
else
x_min_str = "??"
end if
if (gro%x_max_set) then
x_max_str = "#" // trim (adjustl (real2string (gro%x_max, fmt)))
else if (present (x_max)) then
x_max_str = "#" // trim (adjustl (real2string (x_max, fmt)))
else
x_max_str = "??"
end if
if (gro%y_min_set) then
y_min_str = "#" // trim (adjustl (real2string (gro%y_min, fmt)))
else if (present (y_min)) then
y_min_str = "#" // trim (adjustl (real2string (y_min, fmt)))
else
y_min_str = "??"
end if
if (gro%y_max_set) then
y_max_str = "#" // trim (adjustl (real2string (gro%y_max, fmt)))
else if (present (y_max)) then
y_max_str = "#" // trim (adjustl (real2string (y_max, fmt)))
else
y_max_str = "??"
end if
cmd = "graphrange (" // x_min_str // ", " // y_min_str // "), " &
// "(" // x_max_str // ", " // y_max_str // ");"
end function graph_options_get_gml_graphrange
@ %def graph_options_get_gml_graphrange
@ Get extra GAMELAN code to be executed before and after the usual drawing
commands.
<<Analysis: procedures>>=
function graph_options_get_gml_bg_command (gro) result (cmd)
type(string_t) :: cmd
type(graph_options_t), intent(in) :: gro
cmd = gro%gmlcode_bg
end function graph_options_get_gml_bg_command
function graph_options_get_gml_fg_command (gro) result (cmd)
type(string_t) :: cmd
type(graph_options_t), intent(in) :: gro
cmd = gro%gmlcode_fg
end function graph_options_get_gml_fg_command
@ %def graph_options_get_gml_bg_command
@ %def graph_options_get_gml_fg_command
@ Append the header for generic data output in ifile format. We print only
labels, not graphics parameters.
<<Analysis: procedures>>=
subroutine graph_options_get_header (pl, header, comment)
type(graph_options_t), intent(in) :: pl
type(ifile_t), intent(inout) :: header
type(string_t), intent(in), optional :: comment
type(string_t) :: c
if (present (comment)) then
c = comment
else
c = ""
end if
call ifile_append (header, &
c // "ID: " // pl%id)
call ifile_append (header, &
c // "title: " // pl%title)
call ifile_append (header, &
c // "description: " // pl%description)
call ifile_append (header, &
c // "x axis label: " // pl%x_label)
call ifile_append (header, &
c // "y axis label: " // pl%y_label)
end subroutine graph_options_get_header
@ %def graph_options_get_header
@
\subsection{Drawing options}
These options apply to an individual graph element (histogram or plot).
<<Analysis: public>>=
public :: drawing_options_t
<<Analysis: types>>=
type :: drawing_options_t
type(string_t) :: dataset
logical :: with_hbars = .false.
logical :: with_base = .false.
logical :: piecewise = .false.
logical :: fill = .false.
logical :: draw = .false.
logical :: err = .false.
logical :: symbols = .false.
type(string_t) :: fill_options
type(string_t) :: draw_options
type(string_t) :: err_options
type(string_t) :: symbol
type(string_t) :: gmlcode_bg
type(string_t) :: gmlcode_fg
end type drawing_options_t
@ %def drawing_options_t
@ Write a simple account of all options.
<<Analysis: public>>=
public :: drawing_options_write
<<Analysis: procedures>>=
subroutine drawing_options_write (dro, unit)
type(drawing_options_t), intent(in) :: dro
integer, intent(in), optional :: unit
integer :: u
u = given_output_unit (unit)
1 format (A,1x,'"',A,'"')
2 format (A,1x,L1)
write (u, 2) "with_hbars =", dro%with_hbars
write (u, 2) "with_base =", dro%with_base
write (u, 2) "piecewise =", dro%piecewise
write (u, 2) "fill =", dro%fill
write (u, 2) "draw =", dro%draw
write (u, 2) "err =", dro%err
write (u, 2) "symbols =", dro%symbols
write (u, 1) "fill_options=", char (dro%fill_options)
write (u, 1) "draw_options=", char (dro%draw_options)
write (u, 1) "err_options =", char (dro%err_options)
write (u, 1) "symbol =", char (dro%symbol)
write (u, 1) "gmlcode_bg =", char (dro%gmlcode_bg)
write (u, 1) "gmlcode_fg =", char (dro%gmlcode_fg)
end subroutine drawing_options_write
@ %def drawing_options_write
@ Init with empty strings and default options, appropriate for either
histogram or plot.
<<Analysis: public>>=
public :: drawing_options_init_histogram
public :: drawing_options_init_plot
<<Analysis: procedures>>=
subroutine drawing_options_init_histogram (dro)
type(drawing_options_t), intent(out) :: dro
dro%dataset = "dat"
dro%with_hbars = .true.
dro%with_base = .true.
dro%piecewise = .true.
dro%fill = .true.
dro%draw = .true.
dro%fill_options = "withcolor col.default"
dro%draw_options = ""
dro%err_options = ""
dro%symbol = "fshape(circle scaled 1mm)()"
dro%gmlcode_bg = ""
dro%gmlcode_fg = ""
end subroutine drawing_options_init_histogram
subroutine drawing_options_init_plot (dro)
type(drawing_options_t), intent(out) :: dro
dro%dataset = "dat"
dro%draw = .true.
dro%fill_options = "withcolor col.default"
dro%draw_options = ""
dro%err_options = ""
dro%symbol = "fshape(circle scaled 1mm)()"
dro%gmlcode_bg = ""
dro%gmlcode_fg = ""
end subroutine drawing_options_init_plot
@ %def drawing_options_init_histogram
@ %def drawing_options_init_plot
@ Set individual options.
<<Analysis: public>>=
public :: drawing_options_set
<<Analysis: procedures>>=
subroutine drawing_options_set (dro, dataset, &
with_hbars, with_base, piecewise, fill, draw, err, symbols, &
fill_options, draw_options, err_options, symbol, &
gmlcode_bg, gmlcode_fg)
type(drawing_options_t), intent(inout) :: dro
type(string_t), intent(in), optional :: dataset
logical, intent(in), optional :: with_hbars, with_base, piecewise
logical, intent(in), optional :: fill, draw, err, symbols
type(string_t), intent(in), optional :: fill_options, draw_options
type(string_t), intent(in), optional :: err_options, symbol
type(string_t), intent(in), optional :: gmlcode_bg, gmlcode_fg
if (present (dataset)) dro%dataset = dataset
if (present (with_hbars)) dro%with_hbars = with_hbars
if (present (with_base)) dro%with_base = with_base
if (present (piecewise)) dro%piecewise = piecewise
if (present (fill)) dro%fill = fill
if (present (draw)) dro%draw = draw
if (present (err)) dro%err = err
if (present (symbols)) dro%symbols = symbols
if (present (fill_options)) dro%fill_options = fill_options
if (present (draw_options)) dro%draw_options = draw_options
if (present (err_options)) dro%err_options = err_options
if (present (symbol)) dro%symbol = symbol
if (present (gmlcode_bg)) dro%gmlcode_bg = gmlcode_bg
if (present (gmlcode_fg)) dro%gmlcode_fg = gmlcode_fg
end subroutine drawing_options_set
@ %def drawing_options_set
@ There are sepate commands for drawing the
curve and for drawing errors. The symbols are applied to the latter. First
of all, we may have to compute a baseline:
<<Analysis: procedures>>=
function drawing_options_get_calc_command (dro) result (cmd)
type(string_t) :: cmd
type(drawing_options_t), intent(in) :: dro
if (dro%with_base) then
cmd = "calculate " // dro%dataset // ".base (" // dro%dataset // ") " &
// "(x, #0);"
else
cmd = ""
end if
end function drawing_options_get_calc_command
@ %def drawing_options_get_calc_command
@ Return the drawing command.
<<Analysis: procedures>>=
function drawing_options_get_draw_command (dro) result (cmd)
type(string_t) :: cmd
type(drawing_options_t), intent(in) :: dro
if (dro%fill) then
cmd = "fill"
else if (dro%draw) then
cmd = "draw"
else
cmd = ""
end if
if (dro%fill .or. dro%draw) then
if (dro%piecewise) cmd = cmd // " piecewise"
if (dro%draw .and. dro%with_base) cmd = cmd // " cyclic"
cmd = cmd // " from (" // dro%dataset
if (dro%with_base) then
if (dro%piecewise) then
cmd = cmd // ", " // dro%dataset // ".base/\" ! "
else
cmd = cmd // " ~ " // dro%dataset // ".base\" ! "
end if
end if
cmd = cmd // ")"
if (dro%fill) then
cmd = cmd // " " // dro%fill_options
if (dro%draw) cmd = cmd // " outlined"
end if
if (dro%draw) cmd = cmd // " " // dro%draw_options
cmd = cmd // ";"
end if
end function drawing_options_get_draw_command
@ %def drawing_options_get_draw_command
@ The error command draws error bars, if any.
<<Analysis: procedures>>=
function drawing_options_get_err_command (dro) result (cmd)
type(string_t) :: cmd
type(drawing_options_t), intent(in) :: dro
if (dro%err) then
cmd = "draw piecewise " &
// "from (" // dro%dataset // ".err)" &
// " " // dro%err_options // ";"
else
cmd = ""
end if
end function drawing_options_get_err_command
@ %def drawing_options_get_err_command
@ The symbol command draws symbols, if any.
<<Analysis: procedures>>=
function drawing_options_get_symb_command (dro) result (cmd)
type(string_t) :: cmd
type(drawing_options_t), intent(in) :: dro
if (dro%symbols) then
cmd = "phantom" &
// " from (" // dro%dataset // ")" &
// " withsymbol (" // dro%symbol // ");"
else
cmd = ""
end if
end function drawing_options_get_symb_command
@ %def drawing_options_get_symb_command
@ Get extra GAMELAN code to be executed before and after the usual drawing
commands.
<<Analysis: procedures>>=
function drawing_options_get_gml_bg_command (dro) result (cmd)
type(string_t) :: cmd
type(drawing_options_t), intent(in) :: dro
cmd = dro%gmlcode_bg
end function drawing_options_get_gml_bg_command
function drawing_options_get_gml_fg_command (dro) result (cmd)
type(string_t) :: cmd
type(drawing_options_t), intent(in) :: dro
cmd = dro%gmlcode_fg
end function drawing_options_get_gml_fg_command
@ %def drawing_options_get_gml_bg_command
@ %def drawing_options_get_gml_fg_command
@
\subsection{Observables}
The observable type holds the accumulated observable values and weight
sums which are necessary for proper averaging.
<<Analysis: types>>=
type :: observable_t
private
real(default) :: sum_values = 0
real(default) :: sum_squared_values = 0
real(default) :: sum_weights = 0
real(default) :: sum_squared_weights = 0
integer :: count = 0
type(string_t) :: obs_label
type(string_t) :: obs_unit
type(graph_options_t) :: graph_options
end type observable_t
@ %def observable_t
@ Initialize with defined properties
<<Analysis: procedures>>=
subroutine observable_init (obs, obs_label, obs_unit, graph_options)
type(observable_t), intent(out) :: obs
type(string_t), intent(in), optional :: obs_label, obs_unit
type(graph_options_t), intent(in), optional :: graph_options
if (present (obs_label)) then
obs%obs_label = obs_label
else
obs%obs_label = ""
end if
if (present (obs_unit)) then
obs%obs_unit = obs_unit
else
obs%obs_unit = ""
end if
if (present (graph_options)) then
obs%graph_options = graph_options
else
call graph_options_init (obs%graph_options)
end if
end subroutine observable_init
@ %def observable_init
@ Reset all numeric entries.
<<Analysis: procedures>>=
subroutine observable_clear (obs)
type(observable_t), intent(inout) :: obs
obs%sum_values = 0
obs%sum_squared_values = 0
obs%sum_weights = 0
obs%sum_squared_weights = 0
obs%count = 0
end subroutine observable_clear
@ %def observable_clear
-@ Record a a value. Always successful for observables.
+@ Record a value. Always successful for observables.
<<Analysis: interfaces>>=
interface observable_record_value
module procedure observable_record_value_unweighted
module procedure observable_record_value_weighted
end interface
<<Analysis: procedures>>=
subroutine observable_record_value_unweighted (obs, value, success)
type(observable_t), intent(inout) :: obs
real(default), intent(in) :: value
logical, intent(out), optional :: success
obs%sum_values = obs%sum_values + value
obs%sum_squared_values = obs%sum_squared_values + value**2
obs%sum_weights = obs%sum_weights + 1
obs%sum_squared_weights = obs%sum_squared_weights + 1
obs%count = obs%count + 1
if (present (success)) success = .true.
end subroutine observable_record_value_unweighted
subroutine observable_record_value_weighted (obs, value, weight, success)
type(observable_t), intent(inout) :: obs
real(default), intent(in) :: value, weight
logical, intent(out), optional :: success
obs%sum_values = obs%sum_values + value * weight
obs%sum_squared_values = obs%sum_squared_values + value**2 * weight
- obs%sum_weights = obs%sum_weights + abs (weight)
+ obs%sum_weights = obs%sum_weights + weight
obs%sum_squared_weights = obs%sum_squared_weights + weight**2
obs%count = obs%count + 1
if (present (success)) success = .true.
end subroutine observable_record_value_weighted
@ %def observable_record_value
@ Here are the statistics formulas:
\begin{enumerate}
\item Unweighted case:
Given a sample of $n$ values $x_i$, the average is
\begin{equation}
\langle x \rangle = \frac{\sum x_i}{n}
\end{equation}
and the error estimate
\begin{align}
\Delta x &= \sqrt{\frac{1}{n-1}\langle{\sum(x_i - \langle x\rangle)^2}}
\\
&= \sqrt{\frac{1}{n-1}
\left(\frac{\sum x_i^2}{n} - \frac{(\sum x_i)^2}{n^2}\right)}
\end{align}
\item Weighted case:
Instead of weight 1, each event comes with weight $w_i$.
\begin{equation}
\langle x \rangle = \frac{\sum x_i w_i}{\sum w_i}
\end{equation}
and
\begin{equation}
\Delta x
= \sqrt{\frac{1}{n-1}
\left(\frac{\sum x_i^2 w_i}{\sum w_i}
- \frac{(\sum x_i w_i)^2}{(\sum w_i)^2}\right)}
\end{equation}
For $w_i=1$, this specializes to the previous formula.
\end{enumerate}
<<Analysis: procedures>>=
function observable_get_n_entries (obs) result (n)
integer :: n
type(observable_t), intent(in) :: obs
n = obs%count
end function observable_get_n_entries
function observable_get_average (obs) result (avg)
real(default) :: avg
type(observable_t), intent(in) :: obs
if (obs%sum_weights /= 0) then
avg = obs%sum_values / obs%sum_weights
else
avg = 0
end if
end function observable_get_average
function observable_get_error (obs) result (err)
real(default) :: err
type(observable_t), intent(in) :: obs
real(default) :: var, n
if (obs%sum_weights /= 0) then
select case (obs%count)
case (0:1)
err = 0
case default
n = obs%count
var = obs%sum_squared_values / obs%sum_weights &
- (obs%sum_values / obs%sum_weights) ** 2
err = sqrt (max (var, 0._default) / (n - 1))
end select
else
err = 0
end if
end function observable_get_error
@ %def observable_get_n_entries
@ %def observable_get_sum
@ %def observable_get_average
@ %def observable_get_error
@ Write label and/or physical unit to a string.
<<Analysis: procedures>>=
function observable_get_label (obs, wl, wu) result (string)
type(string_t) :: string
type(observable_t), intent(in) :: obs
logical, intent(in) :: wl, wu
type(string_t) :: obs_label, obs_unit
if (wl) then
if (obs%obs_label /= "") then
obs_label = obs%obs_label
else
obs_label = "\textrm{Observable}"
end if
else
obs_label = ""
end if
if (wu) then
if (obs%obs_unit /= "") then
if (wl) then
obs_unit = "\;[" // obs%obs_unit // "]"
else
obs_unit = obs%obs_unit
end if
else
obs_unit = ""
end if
else
obs_unit = ""
end if
string = obs_label // obs_unit
end function observable_get_label
@ %def observable_get_label
@
\subsection{Output}
<<Analysis: procedures>>=
subroutine observable_write (obs, unit)
type(observable_t), intent(in) :: obs
integer, intent(in), optional :: unit
real(default) :: avg, err, relerr
integer :: n
integer :: u
u = given_output_unit (unit); if (u < 0) return
avg = observable_get_average (obs)
err = observable_get_error (obs)
if (avg /= 0) then
relerr = err / abs (avg)
else
relerr = 0
end if
n = observable_get_n_entries (obs)
if (obs%graph_options%title /= "") then
write (u, "(A,1x,3A)") &
"title =", '"', char (obs%graph_options%title), '"'
end if
if (obs%graph_options%title /= "") then
write (u, "(A,1x,3A)") &
"description =", '"', char (obs%graph_options%description), '"'
end if
write (u, "(A,1x," // HISTOGRAM_DATA_FORMAT // ")", advance = "no") &
"average =", avg
call write_unit ()
write (u, "(A,1x," // HISTOGRAM_DATA_FORMAT // ")", advance = "no") &
"error[abs] =", err
call write_unit ()
write (u, "(A,1x," // HISTOGRAM_DATA_FORMAT // ")") &
"error[rel] =", relerr
write (u, "(A,1x,I0)") &
"n_entries =", n
contains
subroutine write_unit ()
if (obs%obs_unit /= "") then
write (u, "(1x,A)") char (obs%obs_unit)
else
write (u, *)
end if
end subroutine write_unit
end subroutine observable_write
@ %def observable_write
@ \LaTeX\ output.
<<Analysis: procedures>>=
subroutine observable_write_driver (obs, unit, write_heading)
type(observable_t), intent(in) :: obs
integer, intent(in), optional :: unit
logical, intent(in), optional :: write_heading
real(default) :: avg, err
integer :: n_digits
logical :: heading
integer :: u
u = given_output_unit (unit); if (u < 0) return
heading = .true.; if (present (write_heading)) heading = write_heading
avg = observable_get_average (obs)
err = observable_get_error (obs)
if (avg /= 0 .and. err /= 0) then
n_digits = max (2, 2 - int (log10 (abs (err / real (avg, default)))))
else if (avg /= 0) then
n_digits = 100
else
n_digits = 1
end if
if (heading) then
write (u, "(A)")
if (obs%graph_options%title /= "") then
write (u, "(A)") "\section{" // char (obs%graph_options%title) &
// "}"
else
write (u, "(A)") "\section{Observable}"
end if
if (obs%graph_options%description /= "") then
write (u, "(A)") char (obs%graph_options%description)
write (u, *)
end if
write (u, "(A)") "\begin{flushleft}"
end if
write (u, "(A)", advance="no") " $\langle{" ! $ sign
write (u, "(A)", advance="no") char (observable_get_label (obs, wl=.true., wu=.false.))
write (u, "(A)", advance="no") "}\rangle = "
write (u, "(A)", advance="no") char (tex_format (avg, n_digits))
write (u, "(A)", advance="no") "\pm"
write (u, "(A)", advance="no") char (tex_format (err, 2))
write (u, "(A)", advance="no") "\;{"
write (u, "(A)", advance="no") char (observable_get_label (obs, wl=.false., wu=.true.))
write (u, "(A)") "}"
write (u, "(A)", advance="no") " \quad[n_{\text{entries}} = "
write (u, "(I0)",advance="no") observable_get_n_entries (obs)
write (u, "(A)") "]$" ! $ fool Emacs' noweb mode
if (heading) then
write (u, "(A)") "\end{flushleft}"
end if
end subroutine observable_write_driver
@ %def observable_write_driver
@
\subsection{Histograms}
\subsubsection{Bins}
<<Analysis: types>>=
type :: bin_t
private
real(default) :: midpoint = 0
real(default) :: width = 0
real(default) :: sum_weights = 0
real(default) :: sum_squared_weights = 0
real(default) :: sum_excess_weights = 0
integer :: count = 0
end type bin_t
@ %def bin_t
<<Analysis: procedures>>=
subroutine bin_init (bin, midpoint, width)
type(bin_t), intent(out) :: bin
real(default), intent(in) :: midpoint, width
bin%midpoint = midpoint
bin%width = width
end subroutine bin_init
@ %def bin_init
<<Analysis: procedures>>=
elemental subroutine bin_clear (bin)
type(bin_t), intent(inout) :: bin
bin%sum_weights = 0
bin%sum_squared_weights = 0
bin%sum_excess_weights = 0
bin%count = 0
end subroutine bin_clear
@ %def bin_clear
<<Analysis: procedures>>=
subroutine bin_record_value (bin, normalize, weight, excess)
type(bin_t), intent(inout) :: bin
logical, intent(in) :: normalize
real(default), intent(in) :: weight
real(default), intent(in), optional :: excess
real(default) :: w, e
if (normalize) then
if (bin%width /= 0) then
w = weight / bin%width
if (present (excess)) e = excess / bin%width
else
w = 0
if (present (excess)) e = 0
end if
else
w = weight
if (present (excess)) e = excess
end if
- bin%sum_weights = bin%sum_weights + abs (w)
+ bin%sum_weights = bin%sum_weights + w
bin%sum_squared_weights = bin%sum_squared_weights + w ** 2
if (present (excess)) &
bin%sum_excess_weights = bin%sum_excess_weights + abs (e)
bin%count = bin%count + 1
end subroutine bin_record_value
@ %def bin_record_value
<<Analysis: procedures>>=
function bin_get_midpoint (bin) result (x)
real(default) :: x
type(bin_t), intent(in) :: bin
x = bin%midpoint
end function bin_get_midpoint
function bin_get_width (bin) result (w)
real(default) :: w
type(bin_t), intent(in) :: bin
w = bin%width
end function bin_get_width
function bin_get_n_entries (bin) result (n)
integer :: n
type(bin_t), intent(in) :: bin
n = bin%count
end function bin_get_n_entries
function bin_get_sum (bin) result (s)
real(default) :: s
type(bin_t), intent(in) :: bin
s = bin%sum_weights
end function bin_get_sum
function bin_get_error (bin) result (err)
real(default) :: err
type(bin_t), intent(in) :: bin
err = sqrt (bin%sum_squared_weights)
end function bin_get_error
function bin_get_excess (bin) result (excess)
real(default) :: excess
type(bin_t), intent(in) :: bin
excess = bin%sum_excess_weights
end function bin_get_excess
@ %def bin_get_midpoint
@ %def bin_get_width
@ %def bin_get_n_entries
@ %def bin_get_sum
@ %def bin_get_error
@ %def bin_get_excess
<<Analysis: procedures>>=
subroutine bin_write_header (unit)
integer, intent(in), optional :: unit
character(120) :: buffer
integer :: u
u = given_output_unit (unit); if (u < 0) return
write (buffer, "(A,4(1x," //HISTOGRAM_HEAD_FORMAT // "),2x,A)") &
"#", "bin midpoint", "value ", "error ", &
"excess ", "n"
write (u, "(A)") trim (buffer)
end subroutine bin_write_header
subroutine bin_write (bin, unit)
type(bin_t), intent(in) :: bin
integer, intent(in), optional :: unit
integer :: u
u = given_output_unit (unit); if (u < 0) return
write (u, "(1x,4(1x," // HISTOGRAM_DATA_FORMAT // "),2x,I0)") &
bin_get_midpoint (bin), &
bin_get_sum (bin), &
bin_get_error (bin), &
bin_get_excess (bin), &
bin_get_n_entries (bin)
end subroutine bin_write
@ %def bin_write_header
@ %def bin_write
@
\subsubsection{Histograms}
<<Analysis: types>>=
type :: histogram_t
private
real(default) :: lower_bound = 0
real(default) :: upper_bound = 0
real(default) :: width = 0
integer :: n_bins = 0
logical :: normalize_bins = .false.
type(observable_t) :: obs
type(observable_t) :: obs_within_bounds
type(bin_t) :: underflow
type(bin_t), dimension(:), allocatable :: bin
type(bin_t) :: overflow
type(graph_options_t) :: graph_options
type(drawing_options_t) :: drawing_options
end type histogram_t
@ %def histogram_t
@
\subsubsection{Initializer/finalizer}
Initialize a histogram. We may provide either the bin width or the
number of bins. A finalizer is not needed, since the histogram contains no
pointer (sub)components.
<<Analysis: interfaces>>=
interface histogram_init
module procedure histogram_init_n_bins
module procedure histogram_init_bin_width
end interface
<<Analysis: procedures>>=
subroutine histogram_init_n_bins (h, id, &
lower_bound, upper_bound, n_bins, normalize_bins, &
obs_label, obs_unit, graph_options, drawing_options)
type(histogram_t), intent(out) :: h
type(string_t), intent(in) :: id
real(default), intent(in) :: lower_bound, upper_bound
integer, intent(in) :: n_bins
logical, intent(in) :: normalize_bins
type(string_t), intent(in), optional :: obs_label, obs_unit
type(graph_options_t), intent(in), optional :: graph_options
type(drawing_options_t), intent(in), optional :: drawing_options
real(default) :: bin_width
integer :: i
call observable_init (h%obs_within_bounds, obs_label, obs_unit)
call observable_init (h%obs, obs_label, obs_unit)
h%lower_bound = lower_bound
h%upper_bound = upper_bound
h%n_bins = max (n_bins, 1)
h%width = h%upper_bound - h%lower_bound
h%normalize_bins = normalize_bins
bin_width = h%width / h%n_bins
allocate (h%bin (h%n_bins))
call bin_init (h%underflow, h%lower_bound, 0._default)
do i = 1, h%n_bins
call bin_init (h%bin(i), &
h%lower_bound - bin_width/2 + i * bin_width, bin_width)
end do
call bin_init (h%overflow, h%upper_bound, 0._default)
if (present (graph_options)) then
h%graph_options = graph_options
else
call graph_options_init (h%graph_options)
end if
call graph_options_set (h%graph_options, id = id)
if (present (drawing_options)) then
h%drawing_options = drawing_options
else
call drawing_options_init_histogram (h%drawing_options)
end if
end subroutine histogram_init_n_bins
subroutine histogram_init_bin_width (h, id, &
lower_bound, upper_bound, bin_width, normalize_bins, &
obs_label, obs_unit, graph_options, drawing_options)
type(histogram_t), intent(out) :: h
type(string_t), intent(in) :: id
real(default), intent(in) :: lower_bound, upper_bound, bin_width
logical, intent(in) :: normalize_bins
type(string_t), intent(in), optional :: obs_label, obs_unit
type(graph_options_t), intent(in), optional :: graph_options
type(drawing_options_t), intent(in), optional :: drawing_options
integer :: n_bins
if (bin_width /= 0) then
n_bins = nint ((upper_bound - lower_bound) / bin_width)
else
n_bins = 1
end if
call histogram_init_n_bins (h, id, &
lower_bound, upper_bound, n_bins, normalize_bins, &
obs_label, obs_unit, graph_options, drawing_options)
end subroutine histogram_init_bin_width
@ %def histogram_init
@ Initialize a histogram by copying another one.
Since [[h]] has no pointer (sub)components, intrinsic assignment is
sufficient. Optionally, we replace the drawing options.
<<Analysis: procedures>>=
subroutine histogram_init_histogram (h, h_in, drawing_options)
type(histogram_t), intent(out) :: h
type(histogram_t), intent(in) :: h_in
type(drawing_options_t), intent(in), optional :: drawing_options
h = h_in
if (present (drawing_options)) then
h%drawing_options = drawing_options
end if
end subroutine histogram_init_histogram
@ %def histogram_init_histogram
@
\subsubsection{Fill histograms}
Clear the histogram contents, but do not modify the structure.
<<Analysis: procedures>>=
subroutine histogram_clear (h)
type(histogram_t), intent(inout) :: h
call observable_clear (h%obs)
call observable_clear (h%obs_within_bounds)
call bin_clear (h%underflow)
if (allocated (h%bin)) call bin_clear (h%bin)
call bin_clear (h%overflow)
end subroutine histogram_clear
@ %def histogram_clear
@ Record a value. Successful if the value is within bounds, otherwise
it is recorded as under-/overflow. Optionally, we may provide an
excess weight that could be returned by the unweighting procedure.
<<Analysis: procedures>>=
subroutine histogram_record_value_unweighted (h, value, excess, success)
type(histogram_t), intent(inout) :: h
real(default), intent(in) :: value
real(default), intent(in), optional :: excess
logical, intent(out), optional :: success
integer :: i_bin
call observable_record_value (h%obs, value)
if (h%width /= 0) then
i_bin = floor (((value - h%lower_bound) / h%width) * h%n_bins) + 1
else
i_bin = 0
end if
if (i_bin <= 0) then
call bin_record_value (h%underflow, .false., 1._default, excess)
if (present (success)) success = .false.
else if (i_bin <= h%n_bins) then
call observable_record_value (h%obs_within_bounds, value)
call bin_record_value &
(h%bin(i_bin), h%normalize_bins, 1._default, excess)
if (present (success)) success = .true.
else
call bin_record_value (h%overflow, .false., 1._default, excess)
if (present (success)) success = .false.
end if
end subroutine histogram_record_value_unweighted
@ %def histogram_record_value_unweighted
@ Weighted events: analogous, but no excess weight.
<<Analysis: procedures>>=
subroutine histogram_record_value_weighted (h, value, weight, success)
type(histogram_t), intent(inout) :: h
real(default), intent(in) :: value, weight
logical, intent(out), optional :: success
integer :: i_bin
call observable_record_value (h%obs, value, weight)
if (h%width /= 0) then
i_bin = floor (((value - h%lower_bound) / h%width) * h%n_bins) + 1
else
i_bin = 0
end if
if (i_bin <= 0) then
call bin_record_value (h%underflow, .false., weight)
if (present (success)) success = .false.
else if (i_bin <= h%n_bins) then
call observable_record_value (h%obs_within_bounds, value, weight)
call bin_record_value (h%bin(i_bin), h%normalize_bins, weight)
if (present (success)) success = .true.
else
call bin_record_value (h%overflow, .false., weight)
if (present (success)) success = .false.
end if
end subroutine histogram_record_value_weighted
@ %def histogram_record_value_weighted
@
\subsubsection{Access contents}
Inherited from the observable component (all-over average etc.)
<<Analysis: procedures>>=
function histogram_get_n_entries (h) result (n)
integer :: n
type(histogram_t), intent(in) :: h
n = observable_get_n_entries (h%obs)
end function histogram_get_n_entries
function histogram_get_average (h) result (avg)
real(default) :: avg
type(histogram_t), intent(in) :: h
avg = observable_get_average (h%obs)
end function histogram_get_average
function histogram_get_error (h) result (err)
real(default) :: err
type(histogram_t), intent(in) :: h
err = observable_get_error (h%obs)
end function histogram_get_error
@ %def histogram_get_n_entries
@ %def histogram_get_average
@ %def histogram_get_error
@ Analogous, but applied only to events within bounds.
<<Analysis: procedures>>=
function histogram_get_n_entries_within_bounds (h) result (n)
integer :: n
type(histogram_t), intent(in) :: h
n = observable_get_n_entries (h%obs_within_bounds)
end function histogram_get_n_entries_within_bounds
function histogram_get_average_within_bounds (h) result (avg)
real(default) :: avg
type(histogram_t), intent(in) :: h
avg = observable_get_average (h%obs_within_bounds)
end function histogram_get_average_within_bounds
function histogram_get_error_within_bounds (h) result (err)
real(default) :: err
type(histogram_t), intent(in) :: h
err = observable_get_error (h%obs_within_bounds)
end function histogram_get_error_within_bounds
@ %def histogram_get_n_entries_within_bounds
@ %def histogram_get_average_within_bounds
@ %def histogram_get_error_within_bounds
Get the number of bins
<<Analysis: procedures>>=
function histogram_get_n_bins (h) result (n)
type(histogram_t), intent(in) :: h
integer :: n
n = h%n_bins
end function histogram_get_n_bins
@ %def histogram_get_n_bins
@ Check bins. If the index is zero or above the limit, return the
results for underflow or overflow, respectively.
<<Analysis: procedures>>=
function histogram_get_n_entries_for_bin (h, i) result (n)
integer :: n
type(histogram_t), intent(in) :: h
integer, intent(in) :: i
if (i <= 0) then
n = bin_get_n_entries (h%underflow)
else if (i <= h%n_bins) then
n = bin_get_n_entries (h%bin(i))
else
n = bin_get_n_entries (h%overflow)
end if
end function histogram_get_n_entries_for_bin
function histogram_get_sum_for_bin (h, i) result (avg)
real(default) :: avg
type(histogram_t), intent(in) :: h
integer, intent(in) :: i
if (i <= 0) then
avg = bin_get_sum (h%underflow)
else if (i <= h%n_bins) then
avg = bin_get_sum (h%bin(i))
else
avg = bin_get_sum (h%overflow)
end if
end function histogram_get_sum_for_bin
function histogram_get_error_for_bin (h, i) result (err)
real(default) :: err
type(histogram_t), intent(in) :: h
integer, intent(in) :: i
if (i <= 0) then
err = bin_get_error (h%underflow)
else if (i <= h%n_bins) then
err = bin_get_error (h%bin(i))
else
err = bin_get_error (h%overflow)
end if
end function histogram_get_error_for_bin
function histogram_get_excess_for_bin (h, i) result (err)
real(default) :: err
type(histogram_t), intent(in) :: h
integer, intent(in) :: i
if (i <= 0) then
err = bin_get_excess (h%underflow)
else if (i <= h%n_bins) then
err = bin_get_excess (h%bin(i))
else
err = bin_get_excess (h%overflow)
end if
end function histogram_get_excess_for_bin
@ %def histogram_get_n_entries_for_bin
@ %def histogram_get_sum_for_bin
@ %def histogram_get_error_for_bin
@ %def histogram_get_excess_for_bin
@ Return a pointer to the graph options.
<<Analysis: procedures>>=
function histogram_get_graph_options_ptr (h) result (ptr)
type(graph_options_t), pointer :: ptr
type(histogram_t), intent(in), target :: h
ptr => h%graph_options
end function histogram_get_graph_options_ptr
@ %def histogram_get_graph_options_ptr
@ Return a pointer to the drawing options.
<<Analysis: procedures>>=
function histogram_get_drawing_options_ptr (h) result (ptr)
type(drawing_options_t), pointer :: ptr
type(histogram_t), intent(in), target :: h
ptr => h%drawing_options
end function histogram_get_drawing_options_ptr
@ %def histogram_get_drawing_options_ptr
@
\subsubsection{Output}
<<Analysis: procedures>>=
subroutine histogram_write (h, unit)
type(histogram_t), intent(in) :: h
integer, intent(in), optional :: unit
integer :: u, i
u = given_output_unit (unit); if (u < 0) return
call bin_write_header (u)
if (allocated (h%bin)) then
do i = 1, h%n_bins
call bin_write (h%bin(i), u)
end do
end if
write (u, "(A)")
write (u, "(A,1x,A)") "#", "Underflow:"
call bin_write (h%underflow, u)
write (u, "(A)")
write (u, "(A,1x,A)") "#", "Overflow:"
call bin_write (h%overflow, u)
write (u, "(A)")
write (u, "(A,1x,A)") "#", "Summary: data within bounds"
call observable_write (h%obs_within_bounds, u)
write (u, "(A)")
write (u, "(A,1x,A)") "#", "Summary: all data"
call observable_write (h%obs, u)
write (u, "(A)")
end subroutine histogram_write
@ %def histogram_write
@ Write the GAMELAN reader for histogram contents.
<<Analysis: procedures>>=
subroutine histogram_write_gml_reader (h, filename, unit)
type(histogram_t), intent(in) :: h
type(string_t), intent(in) :: filename
integer, intent(in), optional :: unit
character(*), parameter :: fmt = "(ES15.8)"
integer :: u
u = given_output_unit (unit); if (u < 0) return
write (u, "(2x,A)") 'fromfile "' // char (filename) // '":'
write (u, "(4x,A)") 'key "# Histogram:";'
write (u, "(4x,A)") 'dx := #' &
// real2char (h%width / h%n_bins / 2, fmt) // ';'
write (u, "(4x,A)") 'for i withinblock:'
write (u, "(6x,A)") 'get x, y, y.d, y.n, y.e;'
if (h%drawing_options%with_hbars) then
write (u, "(6x,A)") 'plot (' // char (h%drawing_options%dataset) &
// ') (x,y) hbar dx;'
else
write (u, "(6x,A)") 'plot (' // char (h%drawing_options%dataset) &
// ') (x,y);'
end if
if (h%drawing_options%err) then
write (u, "(6x,A)") 'plot (' // char (h%drawing_options%dataset) &
// '.err) ' &
// '(x,y) vbar y.d;'
end if
!!! Future excess options for plots
! write (u, "(6x,A)") 'if show_excess: ' // &
! & 'plot(dat.e)(x, y plus y.e) hbar dx; fi'
write (u, "(4x,A)") 'endfor'
write (u, "(2x,A)") 'endfrom'
end subroutine histogram_write_gml_reader
@ %def histogram_write_gml_reader
@ \LaTeX\ and GAMELAN output.
<<Analysis: procedures>>=
subroutine histogram_write_gml_driver (h, filename, unit)
type(histogram_t), intent(in) :: h
type(string_t), intent(in) :: filename
integer, intent(in), optional :: unit
type(string_t) :: calc_cmd, bg_cmd, draw_cmd, err_cmd, symb_cmd, fg_cmd
integer :: u
u = given_output_unit (unit); if (u < 0) return
call graph_options_write_tex_header (h%graph_options, unit)
write (u, "(2x,A)") char (graph_options_get_gml_setup (h%graph_options))
write (u, "(2x,A)") char (graph_options_get_gml_graphrange &
(h%graph_options, x_min=h%lower_bound, x_max=h%upper_bound))
call histogram_write_gml_reader (h, filename, unit)
calc_cmd = drawing_options_get_calc_command (h%drawing_options)
if (calc_cmd /= "") write (u, "(2x,A)") char (calc_cmd)
bg_cmd = drawing_options_get_gml_bg_command (h%drawing_options)
if (bg_cmd /= "") write (u, "(2x,A)") char (bg_cmd)
draw_cmd = drawing_options_get_draw_command (h%drawing_options)
if (draw_cmd /= "") write (u, "(2x,A)") char (draw_cmd)
err_cmd = drawing_options_get_err_command (h%drawing_options)
if (err_cmd /= "") write (u, "(2x,A)") char (err_cmd)
symb_cmd = drawing_options_get_symb_command (h%drawing_options)
if (symb_cmd /= "") write (u, "(2x,A)") char (symb_cmd)
fg_cmd = drawing_options_get_gml_fg_command (h%drawing_options)
if (fg_cmd /= "") write (u, "(2x,A)") char (fg_cmd)
write (u, "(2x,A)") char (graph_options_get_gml_x_label (h%graph_options))
write (u, "(2x,A)") char (graph_options_get_gml_y_label (h%graph_options))
call graph_options_write_tex_footer (h%graph_options, unit)
write (u, "(A)") "\vspace*{2\baselineskip}"
write (u, "(A)") "\begin{flushleft}"
write (u, "(A)") "\textbf{Data within bounds:} \\"
call observable_write_driver (h%obs_within_bounds, unit, &
write_heading=.false.)
write (u, "(A)") "\\[0.5\baselineskip]"
write (u, "(A)") "\textbf{All data:} \\"
call observable_write_driver (h%obs, unit, write_heading=.false.)
write (u, "(A)") "\end{flushleft}"
end subroutine histogram_write_gml_driver
@ %def histogram_write_gml_driver
@ Return the header for generic data output as an ifile.
<<Analysis: procedures>>=
subroutine histogram_get_header (h, header, comment)
type(histogram_t), intent(in) :: h
type(ifile_t), intent(inout) :: header
type(string_t), intent(in), optional :: comment
type(string_t) :: c
if (present (comment)) then
c = comment
else
c = ""
end if
call ifile_append (header, c // "WHIZARD histogram data")
call graph_options_get_header (h%graph_options, header, comment)
call ifile_append (header, &
c // "range: " // real2string (h%lower_bound) &
// " - " // real2string (h%upper_bound))
call ifile_append (header, &
c // "counts total: " &
// int2char (histogram_get_n_entries_within_bounds (h)))
call ifile_append (header, &
c // "total average: " &
// real2string (histogram_get_average_within_bounds (h)) // " +- " &
// real2string (histogram_get_error_within_bounds (h)))
end subroutine histogram_get_header
@ %def histogram_get_header
@
\subsection{Plots}
\subsubsection{Points}
<<Analysis: types>>=
type :: point_t
private
real(default) :: x = 0
real(default) :: y = 0
real(default) :: yerr = 0
real(default) :: xerr = 0
type(point_t), pointer :: next => null ()
end type point_t
@ %def point_t
<<Analysis: interfaces>>=
interface point_init
module procedure point_init_contents
module procedure point_init_point
end interface
<<Analysis: procedures>>=
subroutine point_init_contents (point, x, y, yerr, xerr)
type(point_t), intent(out) :: point
real(default), intent(in) :: x, y
real(default), intent(in), optional :: yerr, xerr
point%x = x
point%y = y
if (present (yerr)) point%yerr = yerr
if (present (xerr)) point%xerr = xerr
end subroutine point_init_contents
subroutine point_init_point (point, point_in)
type(point_t), intent(out) :: point
type(point_t), intent(in) :: point_in
point%x = point_in%x
point%y = point_in%y
point%yerr = point_in%yerr
point%xerr = point_in%xerr
end subroutine point_init_point
@ %def point_init
<<Analysis: procedures>>=
function point_get_x (point) result (x)
real(default) :: x
type(point_t), intent(in) :: point
x = point%x
end function point_get_x
function point_get_y (point) result (y)
real(default) :: y
type(point_t), intent(in) :: point
y = point%y
end function point_get_y
function point_get_xerr (point) result (xerr)
real(default) :: xerr
type(point_t), intent(in) :: point
xerr = point%xerr
end function point_get_xerr
function point_get_yerr (point) result (yerr)
real(default) :: yerr
type(point_t), intent(in) :: point
yerr = point%yerr
end function point_get_yerr
@ %def point_get_x
@ %def point_get_y
@ %def point_get_xerr
@ %def point_get_yerr
<<Analysis: procedures>>=
subroutine point_write_header (unit)
integer, intent(in) :: unit
character(120) :: buffer
integer :: u
u = given_output_unit (unit); if (u < 0) return
write (buffer, "(A,4(1x," // HISTOGRAM_HEAD_FORMAT // "))") &
"#", "x ", "y ", "yerr ", "xerr "
write (u, "(A)") trim (buffer)
end subroutine point_write_header
subroutine point_write (point, unit)
type(point_t), intent(in) :: point
integer, intent(in), optional :: unit
integer :: u
u = given_output_unit (unit); if (u < 0) return
write (u, "(1x,4(1x," // HISTOGRAM_DATA_FORMAT // "))") &
point_get_x (point), &
point_get_y (point), &
point_get_yerr (point), &
point_get_xerr (point)
end subroutine point_write
@ %def point_write
@
\subsubsection{Plots}
<<Analysis: types>>=
type :: plot_t
private
type(point_t), pointer :: first => null ()
type(point_t), pointer :: last => null ()
integer :: count = 0
type(graph_options_t) :: graph_options
type(drawing_options_t) :: drawing_options
end type plot_t
@ %def plot_t
@
\subsubsection{Initializer/finalizer}
Initialize a plot. We provide the lower and upper bound in the $x$
direction.
<<Analysis: interfaces>>=
interface plot_init
module procedure plot_init_empty
module procedure plot_init_plot
end interface
<<Analysis: procedures>>=
subroutine plot_init_empty (p, id, graph_options, drawing_options)
type(plot_t), intent(out) :: p
type(string_t), intent(in) :: id
type(graph_options_t), intent(in), optional :: graph_options
type(drawing_options_t), intent(in), optional :: drawing_options
if (present (graph_options)) then
p%graph_options = graph_options
else
call graph_options_init (p%graph_options)
end if
call graph_options_set (p%graph_options, id = id)
if (present (drawing_options)) then
p%drawing_options = drawing_options
else
call drawing_options_init_plot (p%drawing_options)
end if
end subroutine plot_init_empty
@ %def plot_init
@ Initialize a plot by copying another one, optionally merging in a new
set of drawing options.
Since [[p]] has pointer (sub)components, we have to explicitly deep-copy the
original.
<<Analysis: procedures>>=
subroutine plot_init_plot (p, p_in, drawing_options)
type(plot_t), intent(out) :: p
type(plot_t), intent(in) :: p_in
type(drawing_options_t), intent(in), optional :: drawing_options
type(point_t), pointer :: current, new
current => p_in%first
do while (associated (current))
allocate (new)
call point_init (new, current)
if (associated (p%last)) then
p%last%next => new
else
p%first => new
end if
p%last => new
current => current%next
end do
p%count = p_in%count
p%graph_options = p_in%graph_options
if (present (drawing_options)) then
p%drawing_options = drawing_options
else
p%drawing_options = p_in%drawing_options
end if
end subroutine plot_init_plot
@ %def plot_init_plot
@ Finalize the plot by deallocating the list of points.
<<Analysis: procedures>>=
subroutine plot_final (plot)
type(plot_t), intent(inout) :: plot
type(point_t), pointer :: current
do while (associated (plot%first))
current => plot%first
plot%first => current%next
deallocate (current)
end do
plot%last => null ()
end subroutine plot_final
@ %def plot_final
@
\subsubsection{Fill plots}
Clear the plot contents, but do not modify the structure.
<<Analysis: procedures>>=
subroutine plot_clear (plot)
type(plot_t), intent(inout) :: plot
plot%count = 0
call plot_final (plot)
end subroutine plot_clear
@ %def plot_clear
@ Record a value. Successful if the value is within bounds, otherwise
it is recorded as under-/overflow.
<<Analysis: procedures>>=
subroutine plot_record_value (plot, x, y, yerr, xerr, success)
type(plot_t), intent(inout) :: plot
real(default), intent(in) :: x, y
real(default), intent(in), optional :: yerr, xerr
logical, intent(out), optional :: success
type(point_t), pointer :: point
plot%count = plot%count + 1
allocate (point)
call point_init (point, x, y, yerr, xerr)
if (associated (plot%first)) then
plot%last%next => point
else
plot%first => point
end if
plot%last => point
if (present (success)) success = .true.
end subroutine plot_record_value
@ %def plot_record_value
@
\subsubsection{Access contents}
The number of points.
<<Analysis: procedures>>=
function plot_get_n_entries (plot) result (n)
integer :: n
type(plot_t), intent(in) :: plot
n = plot%count
end function plot_get_n_entries
@ %def plot_get_n_entries
@ Return a pointer to the graph options.
<<Analysis: procedures>>=
function plot_get_graph_options_ptr (p) result (ptr)
type(graph_options_t), pointer :: ptr
type(plot_t), intent(in), target :: p
ptr => p%graph_options
end function plot_get_graph_options_ptr
@ %def plot_get_graph_options_ptr
@ Return a pointer to the drawing options.
<<Analysis: procedures>>=
function plot_get_drawing_options_ptr (p) result (ptr)
type(drawing_options_t), pointer :: ptr
type(plot_t), intent(in), target :: p
ptr => p%drawing_options
end function plot_get_drawing_options_ptr
@ %def plot_get_drawing_options_ptr
@
\subsubsection{Output}
This output format is used by the GAMELAN driver below.
<<Analysis: procedures>>=
subroutine plot_write (plot, unit)
type(plot_t), intent(in) :: plot
integer, intent(in), optional :: unit
type(point_t), pointer :: point
integer :: u
u = given_output_unit (unit); if (u < 0) return
call point_write_header (u)
point => plot%first
do while (associated (point))
call point_write (point, unit)
point => point%next
end do
write (u, *)
write (u, "(A,1x,A)") "#", "Summary:"
write (u, "(A,1x,I0)") &
"n_entries =", plot_get_n_entries (plot)
write (u, *)
end subroutine plot_write
@ %def plot_write
@ Write the GAMELAN reader for plot contents.
<<Analysis: procedures>>=
subroutine plot_write_gml_reader (p, filename, unit)
type(plot_t), intent(in) :: p
type(string_t), intent(in) :: filename
integer, intent(in), optional :: unit
integer :: u
u = given_output_unit (unit); if (u < 0) return
write (u, "(2x,A)") 'fromfile "' // char (filename) // '":'
write (u, "(4x,A)") 'key "# Plot:";'
write (u, "(4x,A)") 'for i withinblock:'
write (u, "(6x,A)") 'get x, y, y.err, x.err;'
write (u, "(6x,A)") 'plot (' // char (p%drawing_options%dataset) &
// ') (x,y);'
if (p%drawing_options%err) then
write (u, "(6x,A)") 'plot (' // char (p%drawing_options%dataset) &
// '.err) (x,y) vbar y.err hbar x.err;'
end if
write (u, "(4x,A)") 'endfor'
write (u, "(2x,A)") 'endfrom'
end subroutine plot_write_gml_reader
@ %def plot_write_gml_header
@ \LaTeX\ and GAMELAN output. Analogous to histogram output.
<<Analysis: procedures>>=
subroutine plot_write_gml_driver (p, filename, unit)
type(plot_t), intent(in) :: p
type(string_t), intent(in) :: filename
integer, intent(in), optional :: unit
type(string_t) :: calc_cmd, bg_cmd, draw_cmd, err_cmd, symb_cmd, fg_cmd
integer :: u
u = given_output_unit (unit); if (u < 0) return
call graph_options_write_tex_header (p%graph_options, unit)
write (u, "(2x,A)") &
char (graph_options_get_gml_setup (p%graph_options))
write (u, "(2x,A)") &
char (graph_options_get_gml_graphrange (p%graph_options))
call plot_write_gml_reader (p, filename, unit)
calc_cmd = drawing_options_get_calc_command (p%drawing_options)
if (calc_cmd /= "") write (u, "(2x,A)") char (calc_cmd)
bg_cmd = drawing_options_get_gml_bg_command (p%drawing_options)
if (bg_cmd /= "") write (u, "(2x,A)") char (bg_cmd)
draw_cmd = drawing_options_get_draw_command (p%drawing_options)
if (draw_cmd /= "") write (u, "(2x,A)") char (draw_cmd)
err_cmd = drawing_options_get_err_command (p%drawing_options)
if (err_cmd /= "") write (u, "(2x,A)") char (err_cmd)
symb_cmd = drawing_options_get_symb_command (p%drawing_options)
if (symb_cmd /= "") write (u, "(2x,A)") char (symb_cmd)
fg_cmd = drawing_options_get_gml_fg_command (p%drawing_options)
if (fg_cmd /= "") write (u, "(2x,A)") char (fg_cmd)
write (u, "(2x,A)") char (graph_options_get_gml_x_label (p%graph_options))
write (u, "(2x,A)") char (graph_options_get_gml_y_label (p%graph_options))
call graph_options_write_tex_footer (p%graph_options, unit)
end subroutine plot_write_gml_driver
@ %def plot_write_driver
@ Append header for generic data output in ifile format.
<<Analysis: procedures>>=
subroutine plot_get_header (plot, header, comment)
type(plot_t), intent(in) :: plot
type(ifile_t), intent(inout) :: header
type(string_t), intent(in), optional :: comment
type(string_t) :: c
if (present (comment)) then
c = comment
else
c = ""
end if
call ifile_append (header, c // "WHIZARD plot data")
call graph_options_get_header (plot%graph_options, header, comment)
call ifile_append (header, &
c // "number of points: " &
// int2char (plot_get_n_entries (plot)))
end subroutine plot_get_header
@ %def plot_get_header
@
\subsection{Graphs}
A graph is a container for several graph elements. Each graph element is
either a plot or a histogram. There is an appropriate base type below
(the [[analysis_object_t]]), but to avoid recursion, we define a separate base
type here. Note that there is no actual recursion: a graph is an analysis
object, but a graph cannot contain graphs.
(If we could use type extension, the implementation would be much more
transparent.)
\subsubsection{Graph elements}
Graph elements cannot be filled by the [[record]] command directly. The
contents are always copied from elementary histograms or plots.
<<Analysis: types>>=
type :: graph_element_t
private
integer :: type = AN_UNDEFINED
type(histogram_t), pointer :: h => null ()
type(plot_t), pointer :: p => null ()
end type graph_element_t
@ %def graph_element_t
<<Analysis: procedures>>=
subroutine graph_element_final (el)
type(graph_element_t), intent(inout) :: el
select case (el%type)
case (AN_HISTOGRAM)
deallocate (el%h)
case (AN_PLOT)
call plot_final (el%p)
deallocate (el%p)
end select
el%type = AN_UNDEFINED
end subroutine graph_element_final
@ %def graph_element_final
@ Return the number of entries in the graph element:
<<Analysis: procedures>>=
function graph_element_get_n_entries (el) result (n)
integer :: n
type(graph_element_t), intent(in) :: el
select case (el%type)
case (AN_HISTOGRAM); n = histogram_get_n_entries (el%h)
case (AN_PLOT); n = plot_get_n_entries (el%p)
case default; n = 0
end select
end function graph_element_get_n_entries
@ %def graph_element_get_n_entries
@ Return a pointer to the graph / drawing options.
<<Analysis: procedures>>=
function graph_element_get_graph_options_ptr (el) result (ptr)
type(graph_options_t), pointer :: ptr
type(graph_element_t), intent(in) :: el
select case (el%type)
case (AN_HISTOGRAM); ptr => histogram_get_graph_options_ptr (el%h)
case (AN_PLOT); ptr => plot_get_graph_options_ptr (el%p)
case default; ptr => null ()
end select
end function graph_element_get_graph_options_ptr
function graph_element_get_drawing_options_ptr (el) result (ptr)
type(drawing_options_t), pointer :: ptr
type(graph_element_t), intent(in) :: el
select case (el%type)
case (AN_HISTOGRAM); ptr => histogram_get_drawing_options_ptr (el%h)
case (AN_PLOT); ptr => plot_get_drawing_options_ptr (el%p)
case default; ptr => null ()
end select
end function graph_element_get_drawing_options_ptr
@ %def graph_element_get_graph_options_ptr
@ %def graph_element_get_drawing_options_ptr
@ Output, simple wrapper for the plot/histogram writer.
<<Analysis: procedures>>=
subroutine graph_element_write (el, unit)
type(graph_element_t), intent(in) :: el
integer, intent(in), optional :: unit
type(graph_options_t), pointer :: gro
type(string_t) :: id
integer :: u
u = given_output_unit (unit); if (u < 0) return
gro => graph_element_get_graph_options_ptr (el)
id = graph_options_get_id (gro)
write (u, "(A,A)") '#', repeat ("-", 78)
select case (el%type)
case (AN_HISTOGRAM)
write (u, "(A)", advance="no") "# Histogram: "
write (u, "(1x,A)") char (id)
call histogram_write (el%h, unit)
case (AN_PLOT)
write (u, "(A)", advance="no") "# Plot: "
write (u, "(1x,A)") char (id)
call plot_write (el%p, unit)
end select
end subroutine graph_element_write
@ %def graph_element_write
<<Analysis: procedures>>=
subroutine graph_element_write_gml_reader (el, filename, unit)
type(graph_element_t), intent(in) :: el
type(string_t), intent(in) :: filename
integer, intent(in), optional :: unit
select case (el%type)
case (AN_HISTOGRAM); call histogram_write_gml_reader (el%h, filename, unit)
case (AN_PLOT); call plot_write_gml_reader (el%p, filename, unit)
end select
end subroutine graph_element_write_gml_reader
@ %def graph_element_write_gml_reader
@
\subsubsection{The graph type}
The actual graph type contains its own [[graph_options]], which override the
individual settings. The [[drawing_options]] are set in the graph elements.
This distinction motivates the separation of the two types.
<<Analysis: types>>=
type :: graph_t
private
type(graph_element_t), dimension(:), allocatable :: el
type(graph_options_t) :: graph_options
end type graph_t
@ %def graph_t
@
\subsubsection{Initializer/finalizer}
The graph is created with a definite number of elements. The elements are
filled one by one, optionally with modified drawing options.
<<Analysis: procedures>>=
subroutine graph_init (g, id, n_elements, graph_options)
type(graph_t), intent(out) :: g
type(string_t), intent(in) :: id
integer, intent(in) :: n_elements
type(graph_options_t), intent(in), optional :: graph_options
allocate (g%el (n_elements))
if (present (graph_options)) then
g%graph_options = graph_options
else
call graph_options_init (g%graph_options)
end if
call graph_options_set (g%graph_options, id = id)
end subroutine graph_init
@ %def graph_init
<<Analysis: procedures>>=
subroutine graph_insert_histogram (g, i, h, drawing_options)
type(graph_t), intent(inout), target :: g
integer, intent(in) :: i
type(histogram_t), intent(in) :: h
type(drawing_options_t), intent(in), optional :: drawing_options
type(graph_options_t), pointer :: gro
type(drawing_options_t), pointer :: dro
type(string_t) :: id
g%el(i)%type = AN_HISTOGRAM
allocate (g%el(i)%h)
call histogram_init_histogram (g%el(i)%h, h, drawing_options)
gro => histogram_get_graph_options_ptr (g%el(i)%h)
dro => histogram_get_drawing_options_ptr (g%el(i)%h)
id = graph_options_get_id (gro)
call drawing_options_set (dro, dataset = "dat." // id)
end subroutine graph_insert_histogram
@ %def graph_insert_histogram
<<Analysis: procedures>>=
subroutine graph_insert_plot (g, i, p, drawing_options)
type(graph_t), intent(inout) :: g
integer, intent(in) :: i
type(plot_t), intent(in) :: p
type(drawing_options_t), intent(in), optional :: drawing_options
type(graph_options_t), pointer :: gro
type(drawing_options_t), pointer :: dro
type(string_t) :: id
g%el(i)%type = AN_PLOT
allocate (g%el(i)%p)
call plot_init_plot (g%el(i)%p, p, drawing_options)
gro => plot_get_graph_options_ptr (g%el(i)%p)
dro => plot_get_drawing_options_ptr (g%el(i)%p)
id = graph_options_get_id (gro)
call drawing_options_set (dro, dataset = "dat." // id)
end subroutine graph_insert_plot
@ %def graph_insert_plot
@ Finalizer.
<<Analysis: procedures>>=
subroutine graph_final (g)
type(graph_t), intent(inout) :: g
integer :: i
do i = 1, size (g%el)
call graph_element_final (g%el(i))
end do
deallocate (g%el)
end subroutine graph_final
@ %def graph_final
@
\subsubsection{Access contents}
The number of elements.
<<Analysis: procedures>>=
function graph_get_n_elements (graph) result (n)
integer :: n
type(graph_t), intent(in) :: graph
n = size (graph%el)
end function graph_get_n_elements
@ %def graph_get_n_elements
@ Retrieve a pointer to the drawing options of an element, so they can be
modified. (The [[target]] attribute is not actually needed because the
components are pointers.)
<<Analysis: procedures>>=
function graph_get_drawing_options_ptr (g, i) result (ptr)
type(drawing_options_t), pointer :: ptr
type(graph_t), intent(in), target :: g
integer, intent(in) :: i
ptr => graph_element_get_drawing_options_ptr (g%el(i))
end function graph_get_drawing_options_ptr
@ %def graph_get_drawing_options_ptr
@
\subsubsection{Output}
The default output format just writes histogram and plot data.
<<Analysis: procedures>>=
subroutine graph_write (graph, unit)
type(graph_t), intent(in) :: graph
integer, intent(in), optional :: unit
integer :: i
do i = 1, size (graph%el)
call graph_element_write (graph%el(i), unit)
end do
end subroutine graph_write
@ %def graph_write
@ The GAMELAN driver is not a simple wrapper, but it writes the plot/histogram
contents embedded the complete graph. First, data are read in, global
background commands next, then individual elements, then global foreground
commands.
<<Analysis: procedures>>=
subroutine graph_write_gml_driver (g, filename, unit)
type(graph_t), intent(in) :: g
type(string_t), intent(in) :: filename
type(string_t) :: calc_cmd, bg_cmd, draw_cmd, err_cmd, symb_cmd, fg_cmd
integer, intent(in), optional :: unit
type(drawing_options_t), pointer :: dro
integer :: u, i
u = given_output_unit (unit); if (u < 0) return
call graph_options_write_tex_header (g%graph_options, unit)
write (u, "(2x,A)") &
char (graph_options_get_gml_setup (g%graph_options))
write (u, "(2x,A)") &
char (graph_options_get_gml_graphrange (g%graph_options))
do i = 1, size (g%el)
call graph_element_write_gml_reader (g%el(i), filename, unit)
calc_cmd = drawing_options_get_calc_command &
(graph_element_get_drawing_options_ptr (g%el(i)))
if (calc_cmd /= "") write (u, "(2x,A)") char (calc_cmd)
end do
bg_cmd = graph_options_get_gml_bg_command (g%graph_options)
if (bg_cmd /= "") write (u, "(2x,A)") char (bg_cmd)
do i = 1, size (g%el)
dro => graph_element_get_drawing_options_ptr (g%el(i))
bg_cmd = drawing_options_get_gml_bg_command (dro)
if (bg_cmd /= "") write (u, "(2x,A)") char (bg_cmd)
draw_cmd = drawing_options_get_draw_command (dro)
if (draw_cmd /= "") write (u, "(2x,A)") char (draw_cmd)
err_cmd = drawing_options_get_err_command (dro)
if (err_cmd /= "") write (u, "(2x,A)") char (err_cmd)
symb_cmd = drawing_options_get_symb_command (dro)
if (symb_cmd /= "") write (u, "(2x,A)") char (symb_cmd)
fg_cmd = drawing_options_get_gml_fg_command (dro)
if (fg_cmd /= "") write (u, "(2x,A)") char (fg_cmd)
end do
fg_cmd = graph_options_get_gml_fg_command (g%graph_options)
if (fg_cmd /= "") write (u, "(2x,A)") char (fg_cmd)
write (u, "(2x,A)") char (graph_options_get_gml_x_label (g%graph_options))
write (u, "(2x,A)") char (graph_options_get_gml_y_label (g%graph_options))
call graph_options_write_tex_footer (g%graph_options, unit)
end subroutine graph_write_gml_driver
@ %def graph_write_gml_driver
@ Append header for generic data output in ifile format.
<<Analysis: procedures>>=
subroutine graph_get_header (graph, header, comment)
type(graph_t), intent(in) :: graph
type(ifile_t), intent(inout) :: header
type(string_t), intent(in), optional :: comment
type(string_t) :: c
if (present (comment)) then
c = comment
else
c = ""
end if
call ifile_append (header, c // "WHIZARD graph data")
call graph_options_get_header (graph%graph_options, header, comment)
call ifile_append (header, &
c // "number of graph elements: " &
// int2char (graph_get_n_elements (graph)))
end subroutine graph_get_header
@ %def graph_get_header
@
\subsection{Analysis objects}
This data structure holds all observables, histograms and such that
are currently active. We have one global store; individual items are
identified by their ID strings.
(This should rather be coded by type extension.)
<<Analysis: parameters>>=
integer, parameter :: AN_UNDEFINED = 0
integer, parameter :: AN_OBSERVABLE = 1
integer, parameter :: AN_HISTOGRAM = 2
integer, parameter :: AN_PLOT = 3
integer, parameter :: AN_GRAPH = 4
<<Analysis: public>>=
public :: AN_UNDEFINED, AN_HISTOGRAM, AN_OBSERVABLE, AN_PLOT, AN_GRAPH
@ %def AN_UNDEFINED
@ %def AN_OBSERVABLE AN_HISTOGRAM AN_PLOT AN_GRAPH
<<Analysis: types>>=
type :: analysis_object_t
private
type(string_t) :: id
integer :: type = AN_UNDEFINED
type(observable_t), pointer :: obs => null ()
type(histogram_t), pointer :: h => null ()
type(plot_t), pointer :: p => null ()
type(graph_t), pointer :: g => null ()
type(analysis_object_t), pointer :: next => null ()
end type analysis_object_t
@ %def analysis_object_t
@
\subsubsection{Initializer/finalizer}
Allocate with the correct type but do not fill initial values.
<<Analysis: procedures>>=
subroutine analysis_object_init (obj, id, type)
type(analysis_object_t), intent(out) :: obj
type(string_t), intent(in) :: id
integer, intent(in) :: type
obj%id = id
obj%type = type
select case (obj%type)
case (AN_OBSERVABLE); allocate (obj%obs)
case (AN_HISTOGRAM); allocate (obj%h)
case (AN_PLOT); allocate (obj%p)
case (AN_GRAPH); allocate (obj%g)
end select
end subroutine analysis_object_init
@ %def analysis_object_init
<<Analysis: procedures>>=
subroutine analysis_object_final (obj)
type(analysis_object_t), intent(inout) :: obj
select case (obj%type)
case (AN_OBSERVABLE)
deallocate (obj%obs)
case (AN_HISTOGRAM)
deallocate (obj%h)
case (AN_PLOT)
call plot_final (obj%p)
deallocate (obj%p)
case (AN_GRAPH)
call graph_final (obj%g)
deallocate (obj%g)
end select
obj%type = AN_UNDEFINED
end subroutine analysis_object_final
@ %def analysis_object_final
@ Clear the analysis object, i.e., reset it to its initial state. Not
applicable to graphs, which are always combinations of other existing
objects.
<<Analysis: procedures>>=
subroutine analysis_object_clear (obj)
type(analysis_object_t), intent(inout) :: obj
select case (obj%type)
case (AN_OBSERVABLE)
call observable_clear (obj%obs)
case (AN_HISTOGRAM)
call histogram_clear (obj%h)
case (AN_PLOT)
call plot_clear (obj%p)
end select
end subroutine analysis_object_clear
@ %def analysis_object_clear
@
\subsubsection{Fill with data}
Record data. The effect depends on the type of analysis object.
<<Analysis: procedures>>=
subroutine analysis_object_record_data (obj, &
x, y, yerr, xerr, weight, excess, success)
type(analysis_object_t), intent(inout) :: obj
real(default), intent(in) :: x
real(default), intent(in), optional :: y, yerr, xerr, weight, excess
logical, intent(out), optional :: success
select case (obj%type)
case (AN_OBSERVABLE)
if (present (weight)) then
call observable_record_value_weighted (obj%obs, x, weight, success)
else
call observable_record_value_unweighted (obj%obs, x, success)
end if
case (AN_HISTOGRAM)
if (present (weight)) then
call histogram_record_value_weighted (obj%h, x, weight, success)
else
call histogram_record_value_unweighted (obj%h, x, excess, success)
end if
case (AN_PLOT)
if (present (y)) then
call plot_record_value (obj%p, x, y, yerr, xerr, success)
else
if (present (success)) success = .false.
end if
case default
if (present (success)) success = .false.
end select
end subroutine analysis_object_record_data
@ %def analysis_object_record_data
@ Explicitly set the pointer to the next object in the list.
<<Analysis: procedures>>=
subroutine analysis_object_set_next_ptr (obj, next)
type(analysis_object_t), intent(inout) :: obj
type(analysis_object_t), pointer :: next
obj%next => next
end subroutine analysis_object_set_next_ptr
@ %def analysis_object_set_next_ptr
@
\subsubsection{Access contents}
Return a pointer to the next object in the list.
<<Analysis: procedures>>=
function analysis_object_get_next_ptr (obj) result (next)
type(analysis_object_t), pointer :: next
type(analysis_object_t), intent(in) :: obj
next => obj%next
end function analysis_object_get_next_ptr
@ %def analysis_object_get_next_ptr
@ Return data as appropriate for the object type.
<<Analysis: procedures>>=
function analysis_object_get_n_elements (obj) result (n)
integer :: n
type(analysis_object_t), intent(in) :: obj
select case (obj%type)
case (AN_HISTOGRAM)
n = 1
case (AN_PLOT)
n = 1
case (AN_GRAPH)
n = graph_get_n_elements (obj%g)
case default
n = 0
end select
end function analysis_object_get_n_elements
function analysis_object_get_n_entries (obj, within_bounds) result (n)
integer :: n
type(analysis_object_t), intent(in) :: obj
logical, intent(in), optional :: within_bounds
logical :: wb
select case (obj%type)
case (AN_OBSERVABLE)
n = observable_get_n_entries (obj%obs)
case (AN_HISTOGRAM)
wb = .false.; if (present (within_bounds)) wb = within_bounds
if (wb) then
n = histogram_get_n_entries_within_bounds (obj%h)
else
n = histogram_get_n_entries (obj%h)
end if
case (AN_PLOT)
n = plot_get_n_entries (obj%p)
case default
n = 0
end select
end function analysis_object_get_n_entries
function analysis_object_get_average (obj, within_bounds) result (avg)
real(default) :: avg
type(analysis_object_t), intent(in) :: obj
logical, intent(in), optional :: within_bounds
logical :: wb
select case (obj%type)
case (AN_OBSERVABLE)
avg = observable_get_average (obj%obs)
case (AN_HISTOGRAM)
wb = .false.; if (present (within_bounds)) wb = within_bounds
if (wb) then
avg = histogram_get_average_within_bounds (obj%h)
else
avg = histogram_get_average (obj%h)
end if
case default
avg = 0
end select
end function analysis_object_get_average
function analysis_object_get_error (obj, within_bounds) result (err)
real(default) :: err
type(analysis_object_t), intent(in) :: obj
logical, intent(in), optional :: within_bounds
logical :: wb
select case (obj%type)
case (AN_OBSERVABLE)
err = observable_get_error (obj%obs)
case (AN_HISTOGRAM)
wb = .false.; if (present (within_bounds)) wb = within_bounds
if (wb) then
err = histogram_get_error_within_bounds (obj%h)
else
err = histogram_get_error (obj%h)
end if
case default
err = 0
end select
end function analysis_object_get_error
@ %def analysis_object_get_n_elements
@ %def analysis_object_get_n_entries
@ %def analysis_object_get_average
@ %def analysis_object_get_error
@ Return pointers to the actual contents:
<<Analysis: procedures>>=
function analysis_object_get_observable_ptr (obj) result (obs)
type(observable_t), pointer :: obs
type(analysis_object_t), intent(in) :: obj
select case (obj%type)
case (AN_OBSERVABLE); obs => obj%obs
case default; obs => null ()
end select
end function analysis_object_get_observable_ptr
function analysis_object_get_histogram_ptr (obj) result (h)
type(histogram_t), pointer :: h
type(analysis_object_t), intent(in) :: obj
select case (obj%type)
case (AN_HISTOGRAM); h => obj%h
case default; h => null ()
end select
end function analysis_object_get_histogram_ptr
function analysis_object_get_plot_ptr (obj) result (plot)
type(plot_t), pointer :: plot
type(analysis_object_t), intent(in) :: obj
select case (obj%type)
case (AN_PLOT); plot => obj%p
case default; plot => null ()
end select
end function analysis_object_get_plot_ptr
function analysis_object_get_graph_ptr (obj) result (g)
type(graph_t), pointer :: g
type(analysis_object_t), intent(in) :: obj
select case (obj%type)
case (AN_GRAPH); g => obj%g
case default; g => null ()
end select
end function analysis_object_get_graph_ptr
@ %def analysis_object_get_observable_ptr
@ %def analysis_object_get_histogram_ptr
@ %def analysis_object_get_plot_ptr
@ %def analysis_object_get_graph_ptr
@ Return true if the object has a graphical representation:
<<Analysis: procedures>>=
function analysis_object_has_plot (obj) result (flag)
logical :: flag
type(analysis_object_t), intent(in) :: obj
select case (obj%type)
case (AN_HISTOGRAM); flag = .true.
case (AN_PLOT); flag = .true.
case (AN_GRAPH); flag = .true.
case default; flag = .false.
end select
end function analysis_object_has_plot
@ %def analysis_object_has_plot
@
\subsubsection{Output}
<<Analysis: procedures>>=
subroutine analysis_object_write (obj, unit, verbose)
type(analysis_object_t), intent(in) :: obj
integer, intent(in), optional :: unit
logical, intent(in), optional :: verbose
logical :: verb
integer :: u
u = given_output_unit (unit); if (u < 0) return
verb = .false.; if (present (verbose)) verb = verbose
write (u, "(A)") repeat ("#", 79)
select case (obj%type)
case (AN_OBSERVABLE)
write (u, "(A)", advance="no") "# Observable:"
case (AN_HISTOGRAM)
write (u, "(A)", advance="no") "# Histogram: "
case (AN_PLOT)
write (u, "(A)", advance="no") "# Plot: "
case (AN_GRAPH)
write (u, "(A)", advance="no") "# Graph: "
case default
write (u, "(A)") "# [undefined analysis object]"
return
end select
write (u, "(1x,A)") char (obj%id)
select case (obj%type)
case (AN_OBSERVABLE)
call observable_write (obj%obs, unit)
case (AN_HISTOGRAM)
if (verb) then
call graph_options_write (obj%h%graph_options, unit)
write (u, *)
call drawing_options_write (obj%h%drawing_options, unit)
write (u, *)
end if
call histogram_write (obj%h, unit)
case (AN_PLOT)
if (verb) then
call graph_options_write (obj%p%graph_options, unit)
write (u, *)
call drawing_options_write (obj%p%drawing_options, unit)
write (u, *)
end if
call plot_write (obj%p, unit)
case (AN_GRAPH)
call graph_write (obj%g, unit)
end select
end subroutine analysis_object_write
@ %def analysis_object_write
@ Write the object part of the \LaTeX\ driver file.
<<Analysis: procedures>>=
subroutine analysis_object_write_driver (obj, filename, unit)
type(analysis_object_t), intent(in) :: obj
type(string_t), intent(in) :: filename
integer, intent(in), optional :: unit
select case (obj%type)
case (AN_OBSERVABLE)
call observable_write_driver (obj%obs, unit)
case (AN_HISTOGRAM)
call histogram_write_gml_driver (obj%h, filename, unit)
case (AN_PLOT)
call plot_write_gml_driver (obj%p, filename, unit)
case (AN_GRAPH)
call graph_write_gml_driver (obj%g, filename, unit)
end select
end subroutine analysis_object_write_driver
@ %def analysis_object_write_driver
@ Return a data header for external formats, in ifile form.
<<Analysis: procedures>>=
subroutine analysis_object_get_header (obj, header, comment)
type(analysis_object_t), intent(in) :: obj
type(ifile_t), intent(inout) :: header
type(string_t), intent(in), optional :: comment
select case (obj%type)
case (AN_HISTOGRAM)
call histogram_get_header (obj%h, header, comment)
case (AN_PLOT)
call plot_get_header (obj%p, header, comment)
end select
end subroutine analysis_object_get_header
@ %def analysis_object_get_header
@
\subsection{Analysis object iterator}
Analysis objects are containers which have iterable data structures:
histograms/bins and plots/points. If they are to be treated on a common
basis, it is useful to have an iterator which hides the implementation
details.
The iterator is used only for elementary analysis objects that contain plot
data: histograms or plots. It is invalid for meta-objects (graphs) and
non-graphical objects (observables).
<<Analysis: public>>=
public :: analysis_iterator_t
<<Analysis: types>>=
type :: analysis_iterator_t
private
integer :: type = AN_UNDEFINED
type(analysis_object_t), pointer :: object => null ()
integer :: index = 1
type(point_t), pointer :: point => null ()
end type
@ %def analysis_iterator_t
@ The initializer places the iterator at the beginning of the analysis object.
<<Analysis: procedures>>=
subroutine analysis_iterator_init (iterator, object)
type(analysis_iterator_t), intent(out) :: iterator
type(analysis_object_t), intent(in), target :: object
iterator%object => object
if (associated (iterator%object)) then
iterator%type = iterator%object%type
select case (iterator%type)
case (AN_PLOT)
iterator%point => iterator%object%p%first
end select
end if
end subroutine analysis_iterator_init
@ %def analysis_iterator_init
@ The iterator is valid as long as it points to an existing entry. An
iterator for a data object without array data (observable) is always invalid.
<<Analysis: public>>=
public :: analysis_iterator_is_valid
<<Analysis: procedures>>=
function analysis_iterator_is_valid (iterator) result (valid)
logical :: valid
type(analysis_iterator_t), intent(in) :: iterator
if (associated (iterator%object)) then
select case (iterator%type)
case (AN_HISTOGRAM)
valid = iterator%index <= histogram_get_n_bins (iterator%object%h)
case (AN_PLOT)
valid = associated (iterator%point)
case default
valid = .false.
end select
else
valid = .false.
end if
end function analysis_iterator_is_valid
@ %def analysis_iterator_is_valid
@ Advance the iterator.
<<Analysis: public>>=
public :: analysis_iterator_advance
<<Analysis: procedures>>=
subroutine analysis_iterator_advance (iterator)
type(analysis_iterator_t), intent(inout) :: iterator
if (associated (iterator%object)) then
select case (iterator%type)
case (AN_PLOT)
iterator%point => iterator%point%next
end select
iterator%index = iterator%index + 1
end if
end subroutine analysis_iterator_advance
@ %def analysis_iterator_advance
@ Retrieve the object type:
<<Analysis: public>>=
public :: analysis_iterator_get_type
<<Analysis: procedures>>=
function analysis_iterator_get_type (iterator) result (type)
integer :: type
type(analysis_iterator_t), intent(in) :: iterator
type = iterator%type
end function analysis_iterator_get_type
@ %def analysis_iterator_get_type
@ Use the iterator to retrieve data. We implement a common routine which
takes the data descriptors as optional arguments. Data which do not occur in
the selected type trigger to an error condition.
The iterator must point to a valid entry.
<<Analysis: public>>=
public :: analysis_iterator_get_data
<<Analysis: procedures>>=
subroutine analysis_iterator_get_data (iterator, &
x, y, yerr, xerr, width, excess, index, n_total)
type(analysis_iterator_t), intent(in) :: iterator
real(default), intent(out), optional :: x, y, yerr, xerr, width, excess
integer, intent(out), optional :: index, n_total
select case (iterator%type)
case (AN_HISTOGRAM)
if (present (x)) &
x = bin_get_midpoint (iterator%object%h%bin(iterator%index))
if (present (y)) &
y = bin_get_sum (iterator%object%h%bin(iterator%index))
if (present (yerr)) &
yerr = bin_get_error (iterator%object%h%bin(iterator%index))
if (present (xerr)) &
call invalid ("histogram", "xerr")
if (present (width)) &
width = bin_get_width (iterator%object%h%bin(iterator%index))
if (present (excess)) &
excess = bin_get_excess (iterator%object%h%bin(iterator%index))
if (present (index)) &
index = iterator%index
if (present (n_total)) &
n_total = histogram_get_n_bins (iterator%object%h)
case (AN_PLOT)
if (present (x)) &
x = point_get_x (iterator%point)
if (present (y)) &
y = point_get_y (iterator%point)
if (present (yerr)) &
yerr = point_get_yerr (iterator%point)
if (present (xerr)) &
xerr = point_get_xerr (iterator%point)
if (present (width)) &
call invalid ("plot", "width")
if (present (excess)) &
call invalid ("plot", "excess")
if (present (index)) &
index = iterator%index
if (present (n_total)) &
n_total = plot_get_n_entries (iterator%object%p)
case default
call msg_bug ("analysis_iterator_get_data: called " &
// "for unsupported analysis object type")
end select
contains
subroutine invalid (typestr, objstr)
character(*), intent(in) :: typestr, objstr
call msg_bug ("analysis_iterator_get_data: attempt to get '" &
// objstr // "' for type '" // typestr // "'")
end subroutine invalid
end subroutine analysis_iterator_get_data
@ %def analysis_iterator_get_data
@
\subsection{Analysis store}
This data structure holds all observables, histograms and such that
are currently active. We have one global store; individual items are
identified by their ID strings and types.
<<Analysis: variables>>=
type(analysis_store_t), save :: analysis_store
@ %def analysis_store
<<Analysis: types>>=
type :: analysis_store_t
private
type(analysis_object_t), pointer :: first => null ()
type(analysis_object_t), pointer :: last => null ()
end type analysis_store_t
@ %def analysis_store_t
@ Delete the analysis store
<<Analysis: public>>=
public :: analysis_final
<<Analysis: procedures>>=
subroutine analysis_final ()
type(analysis_object_t), pointer :: current
do while (associated (analysis_store%first))
current => analysis_store%first
analysis_store%first => current%next
call analysis_object_final (current)
end do
analysis_store%last => null ()
end subroutine analysis_final
@ %def analysis_final
@ Append a new analysis object
<<Analysis: procedures>>=
subroutine analysis_store_append_object (id, type)
type(string_t), intent(in) :: id
integer, intent(in) :: type
type(analysis_object_t), pointer :: obj
allocate (obj)
call analysis_object_init (obj, id, type)
if (associated (analysis_store%last)) then
analysis_store%last%next => obj
else
analysis_store%first => obj
end if
analysis_store%last => obj
end subroutine analysis_store_append_object
@ %def analysis_store_append_object
@ Return a pointer to the analysis object with given ID.
<<Analysis: procedures>>=
function analysis_store_get_object_ptr (id) result (obj)
type(string_t), intent(in) :: id
type(analysis_object_t), pointer :: obj
obj => analysis_store%first
do while (associated (obj))
if (obj%id == id) return
obj => obj%next
end do
end function analysis_store_get_object_ptr
@ %def analysis_store_get_object_ptr
@ Initialize an analysis object: either reset it if present, or append
a new entry.
<<Analysis: procedures>>=
subroutine analysis_store_init_object (id, type, obj)
type(string_t), intent(in) :: id
integer, intent(in) :: type
type(analysis_object_t), pointer :: obj, next
obj => analysis_store_get_object_ptr (id)
if (associated (obj)) then
next => analysis_object_get_next_ptr (obj)
call analysis_object_final (obj)
call analysis_object_init (obj, id, type)
call analysis_object_set_next_ptr (obj, next)
else
call analysis_store_append_object (id, type)
obj => analysis_store%last
end if
end subroutine analysis_store_init_object
@ %def analysis_store_init_object
@ Get the type of a analysis object
<<Analysis: public>>=
public :: analysis_store_get_object_type
<<Analysis: procedures>>=
function analysis_store_get_object_type (id) result (type)
type(string_t), intent(in) :: id
integer :: type
type(analysis_object_t), pointer :: object
object => analysis_store_get_object_ptr (id)
if (associated (object)) then
type = object%type
else
type = AN_UNDEFINED
end if
end function analysis_store_get_object_type
@ %def analysis_store_get_object_type
@ Return the number of objects in the store.
<<Analysis: procedures>>=
function analysis_store_get_n_objects () result (n)
integer :: n
type(analysis_object_t), pointer :: current
n = 0
current => analysis_store%first
do while (associated (current))
n = n + 1
current => current%next
end do
end function analysis_store_get_n_objects
@ %def analysis_store_get_n_objects
@ Allocate an array and fill it with all existing IDs.
<<Analysis: public>>=
public :: analysis_store_get_ids
<<Analysis: procedures>>=
subroutine analysis_store_get_ids (id)
type(string_t), dimension(:), allocatable, intent(out) :: id
type(analysis_object_t), pointer :: current
integer :: i
allocate (id (analysis_store_get_n_objects()))
i = 0
current => analysis_store%first
do while (associated (current))
i = i + 1
id(i) = current%id
current => current%next
end do
end subroutine analysis_store_get_ids
@ %def analysis_store_get_ids
@
\subsection{\LaTeX\ driver file}
Write a driver file for all objects in the store.
<<Analysis: procedures>>=
subroutine analysis_store_write_driver_all (filename_data, unit)
type(string_t), intent(in) :: filename_data
integer, intent(in), optional :: unit
type(analysis_object_t), pointer :: obj
call analysis_store_write_driver_header (unit)
obj => analysis_store%first
do while (associated (obj))
call analysis_object_write_driver (obj, filename_data, unit)
obj => obj%next
end do
call analysis_store_write_driver_footer (unit)
end subroutine analysis_store_write_driver_all
@ %def analysis_store_write_driver_all
@
Write a driver file for an array of objects.
<<Analysis: procedures>>=
subroutine analysis_store_write_driver_obj (filename_data, id, unit)
type(string_t), intent(in) :: filename_data
type(string_t), dimension(:), intent(in) :: id
integer, intent(in), optional :: unit
type(analysis_object_t), pointer :: obj
integer :: i
call analysis_store_write_driver_header (unit)
do i = 1, size (id)
obj => analysis_store_get_object_ptr (id(i))
if (associated (obj)) &
call analysis_object_write_driver (obj, filename_data, unit)
end do
call analysis_store_write_driver_footer (unit)
end subroutine analysis_store_write_driver_obj
@ %def analysis_store_write_driver_obj
@ The beginning of the driver file.
<<Analysis: procedures>>=
subroutine analysis_store_write_driver_header (unit)
integer, intent(in), optional :: unit
integer :: u
u = given_output_unit (unit); if (u < 0) return
write (u, '(A)') "\documentclass[12pt]{article}"
write (u, *)
write (u, '(A)') "\usepackage{gamelan}"
write (u, '(A)') "\usepackage{amsmath}"
write (u, '(A)') "\usepackage{ifpdf}"
write (u, '(A)') "\ifpdf"
write (u, '(A)') " \DeclareGraphicsRule{*}{mps}{*}{}"
write (u, '(A)') "\else"
write (u, '(A)') " \DeclareGraphicsRule{*}{eps}{*}{}"
write (u, '(A)') "\fi"
write (u, *)
write (u, '(A)') "\begin{document}"
write (u, '(A)') "\begin{gmlfile}"
write (u, *)
write (u, '(A)') "\begin{gmlcode}"
write (u, '(A)') " color col.default, col.excess;"
write (u, '(A)') " col.default = 0.9white;"
write (u, '(A)') " col.excess = red;"
write (u, '(A)') " boolean show_excess;"
!!! Future excess options for plots
! if (mcs(1)%plot_excess .and. mcs(1)%unweighted) then
! write (u, '(A)') " show_excess = true;"
! else
write (u, '(A)') " show_excess = false;"
! end if
write (u, '(A)') "\end{gmlcode}"
write (u, *)
end subroutine analysis_store_write_driver_header
@ %def analysis_store_write_driver_header
@ The end of the driver file.
<<Analysis: procedures>>=
subroutine analysis_store_write_driver_footer (unit)
integer, intent(in), optional :: unit
integer :: u
u = given_output_unit (unit); if (u < 0) return
write(u, *)
write(u, '(A)') "\end{gmlfile}"
write(u, '(A)') "\end{document}"
end subroutine analysis_store_write_driver_footer
@ %def analysis_store_write_driver_footer
@
\subsection{API}
\subsubsection{Creating new objects}
The specific versions below:
<<Analysis: public>>=
public :: analysis_init_observable
<<Analysis: procedures>>=
subroutine analysis_init_observable (id, obs_label, obs_unit, graph_options)
type(string_t), intent(in) :: id
type(string_t), intent(in), optional :: obs_label, obs_unit
type(graph_options_t), intent(in), optional :: graph_options
type(analysis_object_t), pointer :: obj
type(observable_t), pointer :: obs
call analysis_store_init_object (id, AN_OBSERVABLE, obj)
obs => analysis_object_get_observable_ptr (obj)
call observable_init (obs, obs_label, obs_unit, graph_options)
end subroutine analysis_init_observable
@ %def analysis_init_observable
<<Analysis: public>>=
public :: analysis_init_histogram
<<Analysis: interfaces>>=
interface analysis_init_histogram
module procedure analysis_init_histogram_n_bins
module procedure analysis_init_histogram_bin_width
end interface
<<Analysis: procedures>>=
subroutine analysis_init_histogram_n_bins &
(id, lower_bound, upper_bound, n_bins, normalize_bins, &
obs_label, obs_unit, graph_options, drawing_options)
type(string_t), intent(in) :: id
real(default), intent(in) :: lower_bound, upper_bound
integer, intent(in) :: n_bins
logical, intent(in) :: normalize_bins
type(string_t), intent(in), optional :: obs_label, obs_unit
type(graph_options_t), intent(in), optional :: graph_options
type(drawing_options_t), intent(in), optional :: drawing_options
type(analysis_object_t), pointer :: obj
type(histogram_t), pointer :: h
call analysis_store_init_object (id, AN_HISTOGRAM, obj)
h => analysis_object_get_histogram_ptr (obj)
call histogram_init (h, id, &
lower_bound, upper_bound, n_bins, normalize_bins, &
obs_label, obs_unit, graph_options, drawing_options)
end subroutine analysis_init_histogram_n_bins
subroutine analysis_init_histogram_bin_width &
(id, lower_bound, upper_bound, bin_width, normalize_bins, &
obs_label, obs_unit, graph_options, drawing_options)
type(string_t), intent(in) :: id
real(default), intent(in) :: lower_bound, upper_bound, bin_width
logical, intent(in) :: normalize_bins
type(string_t), intent(in), optional :: obs_label, obs_unit
type(graph_options_t), intent(in), optional :: graph_options
type(drawing_options_t), intent(in), optional :: drawing_options
type(analysis_object_t), pointer :: obj
type(histogram_t), pointer :: h
call analysis_store_init_object (id, AN_HISTOGRAM, obj)
h => analysis_object_get_histogram_ptr (obj)
call histogram_init (h, id, &
lower_bound, upper_bound, bin_width, normalize_bins, &
obs_label, obs_unit, graph_options, drawing_options)
end subroutine analysis_init_histogram_bin_width
@ %def analysis_init_histogram_n_bins
@ %def analysis_init_histogram_bin_width
<<Analysis: public>>=
public :: analysis_init_plot
<<Analysis: procedures>>=
subroutine analysis_init_plot (id, graph_options, drawing_options)
type(string_t), intent(in) :: id
type(graph_options_t), intent(in), optional :: graph_options
type(drawing_options_t), intent(in), optional :: drawing_options
type(analysis_object_t), pointer :: obj
type(plot_t), pointer :: plot
call analysis_store_init_object (id, AN_PLOT, obj)
plot => analysis_object_get_plot_ptr (obj)
call plot_init (plot, id, graph_options, drawing_options)
end subroutine analysis_init_plot
@ %def analysis_init_plot
<<Analysis: public>>=
public :: analysis_init_graph
<<Analysis: procedures>>=
subroutine analysis_init_graph (id, n_elements, graph_options)
type(string_t), intent(in) :: id
integer, intent(in) :: n_elements
type(graph_options_t), intent(in), optional :: graph_options
type(analysis_object_t), pointer :: obj
type(graph_t), pointer :: graph
call analysis_store_init_object (id, AN_GRAPH, obj)
graph => analysis_object_get_graph_ptr (obj)
call graph_init (graph, id, n_elements, graph_options)
end subroutine analysis_init_graph
@ %def analysis_init_graph
@
\subsubsection{Recording data}
This procedure resets an object or the whole store to its initial
state.
<<Analysis: public>>=
public :: analysis_clear
<<Analysis: interfaces>>=
interface analysis_clear
module procedure analysis_store_clear_obj
module procedure analysis_store_clear_all
end interface
<<Analysis: procedures>>=
subroutine analysis_store_clear_obj (id)
type(string_t), intent(in) :: id
type(analysis_object_t), pointer :: obj
obj => analysis_store_get_object_ptr (id)
if (associated (obj)) then
call analysis_object_clear (obj)
end if
end subroutine analysis_store_clear_obj
subroutine analysis_store_clear_all ()
type(analysis_object_t), pointer :: obj
obj => analysis_store%first
do while (associated (obj))
call analysis_object_clear (obj)
obj => obj%next
end do
end subroutine analysis_store_clear_all
@ %def analysis_clear
@
There is one generic recording function whose behavior depends on the
type of analysis object.
<<Analysis: public>>=
public :: analysis_record_data
<<Analysis: procedures>>=
subroutine analysis_record_data (id, x, y, yerr, xerr, &
weight, excess, success, exist)
type(string_t), intent(in) :: id
real(default), intent(in) :: x
real(default), intent(in), optional :: y, yerr, xerr, weight, excess
logical, intent(out), optional :: success, exist
type(analysis_object_t), pointer :: obj
obj => analysis_store_get_object_ptr (id)
if (associated (obj)) then
call analysis_object_record_data (obj, x, y, yerr, xerr, &
weight, excess, success)
if (present (exist)) exist = .true.
else
if (present (success)) success = .false.
if (present (exist)) exist = .false.
end if
end subroutine analysis_record_data
@ %def analysis_record_data
@
\subsubsection{Build a graph}
This routine sets up the array of graph elements by copying the graph elements
given as input. The object must exist and already be initialized as a graph.
<<Analysis: public>>=
public :: analysis_fill_graph
<<Analysis: procedures>>=
subroutine analysis_fill_graph (id, i, id_in, drawing_options)
type(string_t), intent(in) :: id
integer, intent(in) :: i
type(string_t), intent(in) :: id_in
type(drawing_options_t), intent(in), optional :: drawing_options
type(analysis_object_t), pointer :: obj
type(graph_t), pointer :: g
type(histogram_t), pointer :: h
type(plot_t), pointer :: p
obj => analysis_store_get_object_ptr (id)
g => analysis_object_get_graph_ptr (obj)
obj => analysis_store_get_object_ptr (id_in)
if (associated (obj)) then
select case (obj%type)
case (AN_HISTOGRAM)
h => analysis_object_get_histogram_ptr (obj)
call graph_insert_histogram (g, i, h, drawing_options)
case (AN_PLOT)
p => analysis_object_get_plot_ptr (obj)
call graph_insert_plot (g, i, p, drawing_options)
case default
call msg_error ("Graph '" // char (id) // "': Element '" &
// char (id_in) // "' is neither histogram nor plot.")
end select
else
call msg_error ("Graph '" // char (id) // "': Element '" &
// char (id_in) // "' is undefined.")
end if
end subroutine analysis_fill_graph
@ %def analysis_fill_graph
@
\subsubsection{Retrieve generic results}
Check if a named object exists.
<<Analysis: public>>=
public :: analysis_exists
<<Analysis: procedures>>=
function analysis_exists (id) result (flag)
type(string_t), intent(in) :: id
logical :: flag
type(analysis_object_t), pointer :: obj
flag = .true.
obj => analysis_store%first
do while (associated (obj))
if (obj%id == id) return
obj => obj%next
end do
flag = .false.
end function analysis_exists
@ %def analysis_exists
@ The following functions should work for all kinds of analysis object:
<<Analysis: public>>=
public :: analysis_get_n_elements
public :: analysis_get_n_entries
public :: analysis_get_average
public :: analysis_get_error
<<Analysis: procedures>>=
function analysis_get_n_elements (id) result (n)
integer :: n
type(string_t), intent(in) :: id
type(analysis_object_t), pointer :: obj
obj => analysis_store_get_object_ptr (id)
if (associated (obj)) then
n = analysis_object_get_n_elements (obj)
else
n = 0
end if
end function analysis_get_n_elements
function analysis_get_n_entries (id, within_bounds) result (n)
integer :: n
type(string_t), intent(in) :: id
logical, intent(in), optional :: within_bounds
type(analysis_object_t), pointer :: obj
obj => analysis_store_get_object_ptr (id)
if (associated (obj)) then
n = analysis_object_get_n_entries (obj, within_bounds)
else
n = 0
end if
end function analysis_get_n_entries
function analysis_get_average (id, within_bounds) result (avg)
real(default) :: avg
type(string_t), intent(in) :: id
type(analysis_object_t), pointer :: obj
logical, intent(in), optional :: within_bounds
obj => analysis_store_get_object_ptr (id)
if (associated (obj)) then
avg = analysis_object_get_average (obj, within_bounds)
else
avg = 0
end if
end function analysis_get_average
function analysis_get_error (id, within_bounds) result (err)
real(default) :: err
type(string_t), intent(in) :: id
type(analysis_object_t), pointer :: obj
logical, intent(in), optional :: within_bounds
obj => analysis_store_get_object_ptr (id)
if (associated (obj)) then
err = analysis_object_get_error (obj, within_bounds)
else
err = 0
end if
end function analysis_get_error
@ %def analysis_get_n_elements
@ %def analysis_get_n_entries
@ %def analysis_get_average
@ %def analysis_get_error
@ Return true if any analysis object is graphical
<<Analysis: public>>=
public :: analysis_has_plots
<<Analysis: interfaces>>=
interface analysis_has_plots
module procedure analysis_has_plots_any
module procedure analysis_has_plots_obj
end interface
<<Analysis: procedures>>=
function analysis_has_plots_any () result (flag)
logical :: flag
type(analysis_object_t), pointer :: obj
flag = .false.
obj => analysis_store%first
do while (associated (obj))
flag = analysis_object_has_plot (obj)
if (flag) return
end do
end function analysis_has_plots_any
function analysis_has_plots_obj (id) result (flag)
logical :: flag
type(string_t), dimension(:), intent(in) :: id
type(analysis_object_t), pointer :: obj
integer :: i
flag = .false.
do i = 1, size (id)
obj => analysis_store_get_object_ptr (id(i))
if (associated (obj)) then
flag = analysis_object_has_plot (obj)
if (flag) return
end if
end do
end function analysis_has_plots_obj
@ %def analysis_has_plots
@
\subsubsection{Iterators}
Initialize an iterator for the given object. If the object does not exist or
has wrong type, the iterator will be invalid.
<<Analysis: public>>=
public :: analysis_init_iterator
<<Analysis: procedures>>=
subroutine analysis_init_iterator (id, iterator)
type(string_t), intent(in) :: id
type(analysis_iterator_t), intent(out) :: iterator
type(analysis_object_t), pointer :: obj
obj => analysis_store_get_object_ptr (id)
if (associated (obj)) call analysis_iterator_init (iterator, obj)
end subroutine analysis_init_iterator
@ %def analysis_init_iterator
@
\subsubsection{Output}
<<Analysis: public>>=
public :: analysis_write
<<Analysis: interfaces>>=
interface analysis_write
module procedure analysis_write_object
module procedure analysis_write_all
end interface
@ %def interface
<<Analysis: procedures>>=
subroutine analysis_write_object (id, unit, verbose)
type(string_t), intent(in) :: id
integer, intent(in), optional :: unit
logical, intent(in), optional :: verbose
type(analysis_object_t), pointer :: obj
obj => analysis_store_get_object_ptr (id)
if (associated (obj)) then
call analysis_object_write (obj, unit, verbose)
else
call msg_error ("Analysis object '" // char (id) // "' not found")
end if
end subroutine analysis_write_object
subroutine analysis_write_all (unit, verbose)
integer, intent(in), optional :: unit
logical, intent(in), optional :: verbose
type(analysis_object_t), pointer :: obj
integer :: u
u = given_output_unit (unit); if (u < 0) return
obj => analysis_store%first
do while (associated (obj))
call analysis_object_write (obj, unit, verbose)
obj => obj%next
end do
end subroutine analysis_write_all
@ %def analysis_write_object
@ %def analysis_write_all
<<Analysis: public>>=
public :: analysis_write_driver
<<Analysis: procedures>>=
subroutine analysis_write_driver (filename_data, id, unit)
type(string_t), intent(in) :: filename_data
type(string_t), dimension(:), intent(in), optional :: id
integer, intent(in), optional :: unit
if (present (id)) then
call analysis_store_write_driver_obj (filename_data, id, unit)
else
call analysis_store_write_driver_all (filename_data, unit)
end if
end subroutine analysis_write_driver
@ %def analysis_write_driver
<<Analysis: public>>=
public :: analysis_compile_tex
<<Analysis: procedures>>=
subroutine analysis_compile_tex (file, has_gmlcode, os_data)
type(string_t), intent(in) :: file
logical, intent(in) :: has_gmlcode
type(os_data_t), intent(in) :: os_data
integer :: status
if (os_data%event_analysis_ps) then
call os_system_call ("make compile " // os_data%makeflags // " -f " // &
char (file) // "_ana.makefile", status)
if (status /= 0) then
call msg_error ("Unable to compile analysis output file")
end if
else
call msg_warning ("Skipping results display because " &
// "latex/mpost/dvips is not available")
end if
end subroutine analysis_compile_tex
@ %def analysis_compile_tex
@ Write header for generic data output to an ifile.
<<Analysis: public>>=
public :: analysis_get_header
<<Analysis: procedures>>=
subroutine analysis_get_header (id, header, comment)
type(string_t), intent(in) :: id
type(ifile_t), intent(inout) :: header
type(string_t), intent(in), optional :: comment
type(analysis_object_t), pointer :: object
object => analysis_store_get_object_ptr (id)
if (associated (object)) then
call analysis_object_get_header (object, header, comment)
end if
end subroutine analysis_get_header
@ %def analysis_get_header
@ Write a makefile in order to do the compile steps.
<<Analysis: public>>=
public :: analysis_write_makefile
<<Analysis: procedures>>=
subroutine analysis_write_makefile (filename, unit, has_gmlcode, os_data)
type(string_t), intent(in) :: filename
integer, intent(in) :: unit
logical, intent(in) :: has_gmlcode
type(os_data_t), intent(in) :: os_data
write (unit, "(3A)") "# WHIZARD: Makefile for analysis '", &
char (filename), "'"
write (unit, "(A)") "# Automatically generated file, do not edit"
write (unit, "(A)") ""
write (unit, "(A)") "# LaTeX setup"
write (unit, "(A)") "LATEX = " // char (os_data%latex)
write (unit, "(A)") "MPOST = " // char (os_data%mpost)
write (unit, "(A)") "GML = " // char (os_data%gml)
write (unit, "(A)") "DVIPS = " // char (os_data%dvips)
write (unit, "(A)") "PS2PDF = " // char (os_data%ps2pdf)
write (unit, "(A)") 'TEX_FLAGS = "$$TEXINPUTS:' // &
char(os_data%whizard_texpath) // '"'
write (unit, "(A)") 'MP_FLAGS = "$$MPINPUTS:' // &
char(os_data%whizard_texpath) // '"'
write (unit, "(A)") ""
write (unit, "(5A)") "TEX_SOURCES = ", char (filename), ".tex"
if (os_data%event_analysis_pdf) then
write (unit, "(5A)") "TEX_OBJECTS = ", char (filename), ".pdf"
else
write (unit, "(5A)") "TEX_OBJECTS = ", char (filename), ".ps"
end if
if (os_data%event_analysis_ps) then
if (os_data%event_analysis_pdf) then
write (unit, "(5A)") char (filename), ".pdf: ", &
char (filename), ".tex"
else
write (unit, "(5A)") char (filename), ".ps: ", &
char (filename), ".tex"
end if
write (unit, "(5A)") TAB, "-TEXINPUTS=$(TEX_FLAGS) $(LATEX) " // &
char (filename) // ".tex"
if (has_gmlcode) then
write (unit, "(5A)") TAB, "$(GML) " // char (filename)
write (unit, "(5A)") TAB, "TEXINPUTS=$(TEX_FLAGS) $(LATEX) " // &
char (filename) // ".tex"
end if
write (unit, "(5A)") TAB, "$(DVIPS) -o " // char (filename) // ".ps " // &
char (filename) // ".dvi"
if (os_data%event_analysis_pdf) then
write (unit, "(5A)") TAB, "$(PS2PDF) " // char (filename) // ".ps"
end if
end if
write (unit, "(A)")
write (unit, "(A)") "compile: $(TEX_OBJECTS)"
write (unit, "(A)") ".PHONY: compile"
write (unit, "(A)")
write (unit, "(5A)") "CLEAN_OBJECTS = ", char (filename), ".aux"
write (unit, "(5A)") "CLEAN_OBJECTS += ", char (filename), ".log"
write (unit, "(5A)") "CLEAN_OBJECTS += ", char (filename), ".dvi"
write (unit, "(5A)") "CLEAN_OBJECTS += ", char (filename), ".out"
write (unit, "(5A)") "CLEAN_OBJECTS += ", char (filename), ".[1-9]"
write (unit, "(5A)") "CLEAN_OBJECTS += ", char (filename), ".[1-9][0-9]"
write (unit, "(5A)") "CLEAN_OBJECTS += ", char (filename), ".[1-9][0-9][0-9]"
write (unit, "(5A)") "CLEAN_OBJECTS += ", char (filename), ".t[1-9]"
write (unit, "(5A)") "CLEAN_OBJECTS += ", char (filename), ".t[1-9][0-9]"
write (unit, "(5A)") "CLEAN_OBJECTS += ", char (filename), ".t[1-9][0-9][0-9]"
write (unit, "(5A)") "CLEAN_OBJECTS += ", char (filename), ".ltp"
write (unit, "(5A)") "CLEAN_OBJECTS += ", char (filename), ".mp"
write (unit, "(5A)") "CLEAN_OBJECTS += ", char (filename), ".mpx"
write (unit, "(5A)") "CLEAN_OBJECTS += ", char (filename), ".dvi"
write (unit, "(5A)") "CLEAN_OBJECTS += ", char (filename), ".ps"
write (unit, "(5A)") "CLEAN_OBJECTS += ", char (filename), ".pdf"
write (unit, "(A)")
write (unit, "(A)") "# Generic cleanup targets"
write (unit, "(A)") "clean-objects:"
write (unit, "(A)") TAB // "rm -f $(CLEAN_OBJECTS)"
write (unit, "(A)") ""
write (unit, "(A)") "clean: clean-objects"
write (unit, "(A)") ".PHONY: clean"
end subroutine analysis_write_makefile
@ %def analysis_write_makefile
@
\subsection{Unit tests}
Test module, followed by the corresponding implementation module.
<<[[analysis_ut.f90]]>>=
<<File header>>
module analysis_ut
use unit_tests
use analysis_uti
<<Standard module head>>
<<Analysis: public test>>
contains
<<Analysis: test driver>>
end module analysis_ut
@ %def analysis_ut
@
<<[[analysis_uti.f90]]>>=
<<File header>>
module analysis_uti
<<Use kinds>>
<<Use strings>>
use format_defs, only: FMT_19
use analysis
<<Standard module head>>
<<Analysis: test declarations>>
contains
<<Analysis: tests>>
end module analysis_uti
@ %def analysis_ut
@ API: driver for the unit tests below.
<<Analysis: public test>>=
public :: analysis_test
<<Analysis: test driver>>=
subroutine analysis_test (u, results)
integer, intent(in) :: u
type(test_results_t), intent(inout) :: results
<<Analysis: execute tests>>
end subroutine analysis_test
@ %def analysis_test
<<Analysis: execute tests>>=
call test (analysis_1, "analysis_1", &
"check elementary analysis building blocks", &
u, results)
<<Analysis: test declarations>>=
public :: analysis_1
<<Analysis: tests>>=
subroutine analysis_1 (u)
integer, intent(in) :: u
type(string_t) :: id1, id2, id3, id4
integer :: i
id1 = "foo"
id2 = "bar"
id3 = "hist"
id4 = "plot"
write (u, "(A)") "* Test output: Analysis"
write (u, "(A)") "* Purpose: test the analysis routines"
write (u, "(A)")
call analysis_init_observable (id1)
call analysis_init_observable (id2)
call analysis_init_histogram &
(id3, 0.5_default, 5.5_default, 1._default, normalize_bins=.false.)
call analysis_init_plot (id4)
do i = 1, 3
write (u, "(A,1x," // FMT_19 // ")") "data = ", real(i,default)
call analysis_record_data (id1, real(i,default))
call analysis_record_data (id2, real(i,default), &
weight=real(i,default))
call analysis_record_data (id3, real(i,default))
call analysis_record_data (id4, real(i,default), real(i,default)**2)
end do
write (u, "(A,10(1x,I5))") "n_entries = ", &
analysis_get_n_entries (id1), &
analysis_get_n_entries (id2), &
analysis_get_n_entries (id3), &
analysis_get_n_entries (id3, within_bounds = .true.), &
analysis_get_n_entries (id4), &
analysis_get_n_entries (id4, within_bounds = .true.)
write (u, "(A,10(1x," // FMT_19 // "))") "average = ", &
analysis_get_average (id1), &
analysis_get_average (id2), &
analysis_get_average (id3), &
analysis_get_average (id3, within_bounds = .true.)
write (u, "(A,10(1x," // FMT_19 // "))") "error = ", &
analysis_get_error (id1), &
analysis_get_error (id2), &
analysis_get_error (id3), &
analysis_get_error (id3, within_bounds = .true.)
write (u, "(A)")
write (u, "(A)") "* Clear analysis #2"
write (u, "(A)")
call analysis_clear (id2)
do i = 4, 6
print *, "data = ", real(i,default)
call analysis_record_data (id1, real(i,default))
call analysis_record_data (id2, real(i,default), &
weight=real(i,default))
call analysis_record_data (id3, real(i,default))
call analysis_record_data (id4, real(i,default), real(i,default)**2)
end do
write (u, "(A,10(1x,I5))") "n_entries = ", &
analysis_get_n_entries (id1), &
analysis_get_n_entries (id2), &
analysis_get_n_entries (id3), &
analysis_get_n_entries (id3, within_bounds = .true.), &
analysis_get_n_entries (id4), &
analysis_get_n_entries (id4, within_bounds = .true.)
write (u, "(A,10(1x," // FMT_19 // "))") "average = ", &
analysis_get_average (id1), &
analysis_get_average (id2), &
analysis_get_average (id3), &
analysis_get_average (id3, within_bounds = .true.)
write (u, "(A,10(1x," // FMT_19 // "))") "error = ", &
analysis_get_error (id1), &
analysis_get_error (id2), &
analysis_get_error (id3), &
analysis_get_error (id3, within_bounds = .true.)
write (u, "(A)")
call analysis_write (u)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call analysis_clear ()
call analysis_final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: analysis_1"
end subroutine analysis_1
@ %def analysis_1
Index: trunk/src/models/parameters.SM_dim6.f90
===================================================================
--- trunk/src/models/parameters.SM_dim6.f90 (revision 8482)
+++ trunk/src/models/parameters.SM_dim6.f90 (revision 8483)
@@ -1,356 +1,362 @@
! parameters.SM_dim6.f90
!
! Copyright (C) 1999-2020 by
! Wolfgang Kilian <kilian@physik.uni-siegen.de>
! Thorsten Ohl <ohl@physik.uni-wuerzburg.de>
! Juergen Reuter <juergen.reuter@desy.de>
! with contributions from
! cf. main AUTHORS file
!
! WHIZARD is free software; you can redistribute it and/or modify it
! under the terms of the GNU General Public License as published by
! the Free Software Foundation; either version 2, or (at your option)
! any later version.
!
! WHIZARD is distributed in the hope that it will be useful, but
! WITHOUT ANY WARRANTY; without even the implied warranty of
! MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
! GNU General Public License for more details.
!
! You should have received a copy of the GNU General Public License
! along with this program; if not, write to the Free Software
! Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
!
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
module parameters_sm_dim6
use kinds
use constants
use sm_physics !NODEP!
implicit none
private
real(default), dimension(27), public :: mass, width
real(default), public :: as
complex(default), public :: gs, igs
real(default), public :: e, g, e_em
real(default), public :: sinthw, costhw, sin2thw, tanthw
real(default), public :: qelep, qeup, qedwn
real(default), public :: ttop, tbot, tch, ttau, tw
real(default), public :: ltop, lbot, lc, ltau, lw
complex(default), public :: qlep, qup, qdwn, gcc, qw, &
gzww, gwww, ghww, ghhww, ghzz, ghhzz, &
ghbb, ghtt, ghcc, ghtautau, gh3, gh4, ghmm, &
iqw, igzww, igwww, gw4, gzzww, gazww, gaaww
real(default), public :: vev
complex(default), dimension(2), public :: &
gncneu, gnclep, gncup, gncdwn
real(default), public :: tau4, tau5
complex(default), private :: ghgaga_sm, ghgaz_sm
complex(default), public :: ghgaga_ac, ghgaz_ac, ghzz_ac, ghww_ac
complex(default), public :: ghgaz_u, ghzz_u, ghww_u
complex(default), public :: c66, c6p, c6t, c6dw, c6db, c6dpw, c6dpb, &
c6pb, c6pg, c6g, c6w
complex(default), public :: lambdac6
complex(default), public :: ghzz6v3, ghzz6d, ghzz6dp, ghzz6pb
complex(default), public :: ghaz6d, ghaz6dp, ghaz6pb, dim6awwdp, &
dim6awwdw, dim6awwgauge
complex(default), public :: dim6awwggg, dim6cphi, dim6vev3, ghgaga6, &
ghww6d, ghww6dp
complex(default), public :: dim6gggg ,dim6gggcg, dim6wwzw, &
dim6wwzdpwdw, dim6wwzdw, dim6wwzd
complex(default), public :: adim6h4v2, adim6h4p2, adim6ahwwdpb, &
adim6ahwwdpw, adim6ahwwdw
complex(default), public :: adim6aawwdw, adim6aawww, &
adim6hhwwdw, adim6hhwwdpw
complex(default), public :: adim6hwwzdw, adim6hwwzddpw, &
adim6hwwzdpw, adim6hwwzdpb
complex(default), public :: adim6ahhzd, adim6ahhzdp, adim6ahhzpb, &
adim6azwww, adim6azwwdwdpw
complex(default), public :: adim6wwwww, adim6wwwwdwdpw, &
adim6wwzzw, adim6wwzzdwdpw, adim6hhaa
complex(default), public :: adim6hhzzd, adim6hhzzdp, adim6hhzzpb, adim6hhzzt
public :: import_from_whizard, model_update_alpha_s
contains
subroutine import_from_whizard (par_array, scheme)
real(default), dimension(37), intent(in) :: par_array
integer, intent(in) :: scheme
type :: parameter_set
real(default) :: gf
real(default) :: mZ
real(default) :: mW
real(default) :: mH
real(default) :: alphas
real(default) :: me
real(default) :: mmu
real(default) :: mtau
real(default) :: ms
real(default) :: mc
real(default) :: mb
real(default) :: mtop
real(default) :: wtop
real(default) :: wZ
real(default) :: wW
real(default) :: wH
real(default) :: xi0
real(default) :: xipm
real(default) :: fac_gh3
real(default) :: fghgaga
real(default) :: fghgaz
real(default) :: c66
real(default) :: c6p
real(default) :: c6t
real(default) :: c6dw
real(default) :: c6db
real(default) :: c6dpw
real(default) :: c6dpb
real(default) :: c6pb
real(default) :: c6pg
real(default) :: c6g
real(default) :: c6w
real(default) :: lambdac6
real(default) :: v
real(default) :: cw
real(default) :: sw
real(default) :: ee
end type parameter_set
type(parameter_set) :: par
!!! This corresponds to 1/alpha = 137.03598949333
real(default), parameter :: &
alpha = 1.0_default/137.03598949333_default
e_em = sqrt(4.0_default * PI * alpha)
par%gf = par_array(1)
par%mZ = par_array(2)
par%mW = par_array(3)
par%mH = par_array(4)
par%alphas = par_array(5)
par%me = par_array(6)
par%mmu = par_array(7)
par%mtau = par_array(8)
par%ms = par_array(9)
par%mc = par_array(10)
par%mb = par_array(11)
par%mtop = par_array(12)
par%wtop = par_array(13)
par%wZ = par_array(14)
par%wW = par_array(15)
par%wH = par_array(16)
par%xi0 = par_array(17)
par%xipm = par_array(18)
par%fac_gh3 = par_array(19)
par%fghgaga = par_array(20)
par%fghgaz = par_array(21)
par%c66 = par_array(22)
par%c6p = par_array(23)
par%c6t = par_array(24)
par%c6dw = par_array(25)
par%c6db = par_array(26)
par%c6dpw = par_array(27)
par%c6dpb = par_array(28)
par%c6pb = par_array(29)
par%c6pg = par_array(30)
par%c6g = par_array(31)
par%c6w = par_array(32)
par%lambdac6= par_array(33)
par%v = par_array(34)
par%cw = par_array(35)
par%sw = par_array(36)
par%ee = par_array(37)
mass(1:27) = 0
width(1:27) = 0
mass(3) = par%ms
mass(4) = par%mc
mass(5) = par%mb
mass(6) = par%mtop
width(6) = par%wtop
mass(11) = par%me
mass(13) = par%mmu
mass(15) = par%mtau
mass(23) = par%mZ
width(23) = par%wZ
mass(24) = par%mW
width(24) = par%wW
mass(25) = par%mH
width(25) = par%wH
mass(26) = par%xi0 * mass(23)
width(26) = 0
mass(27) = par%xipm * mass(24)
width(27) = 0
ttop = 4.0_default * mass(6)**2 / mass(25)**2
tbot = 4.0_default * mass(5)**2 / mass(25)**2
tch = 4.0_default * mass(4)**2 / mass(25)**2
ttau = 4.0_default * mass(15)**2 / mass(25)**2
tw = 4.0_default * mass(24)**2 / mass(25)**2
ltop = 4.0_default * mass(6)**2 / mass(23)**2
lbot = 4.0_default * mass(5)**2 / mass(23)**2
lc = 4.0_default * mass(4)**2 / mass(23)**2
ltau = 4.0_default * mass(15)**2 / mass(23)**2
lw = 4.0_default * mass(24)**2 / mass(23)**2
vev = par%v
e = par%ee
sinthw = par%sw
sin2thw = par%sw**2
costhw = par%cw
tanthw = sinthw/costhw
qelep = - 1
qeup = 2.0_default / 3.0_default
qedwn = - 1.0_default / 3.0_default
g = e / sinthw
gcc = - g / 2 / sqrt (2.0_default)
gncneu(1) = - g / 2 / costhw * ( + 0.5_default)
gnclep(1) = - g / 2 / costhw * ( - 0.5_default - 2 * qelep * sin2thw)
gncup(1) = - g / 2 / costhw * ( + 0.5_default - 2 * qeup * sin2thw)
gncdwn(1) = - g / 2 / costhw * ( - 0.5_default - 2 * qedwn * sin2thw)
gncneu(2) = - g / 2 / costhw * ( + 0.5_default)
gnclep(2) = - g / 2 / costhw * ( - 0.5_default)
gncup(2) = - g / 2 / costhw * ( + 0.5_default)
gncdwn(2) = - g / 2 / costhw * ( - 0.5_default)
qlep = - e * qelep
qup = - e * qeup
qdwn = - e * qedwn
qw = e
iqw = (0,1)*qw
gzww = g * costhw
igzww = (0,1)*gzww
gwww = g
igwww = (0,1)*gwww
gw4 = gwww**2
gzzww = gzww**2
gazww = gzww * qw
gaaww = qw**2
ghww = mass(24) * g
ghhww = g**2 / 2.0_default
ghzz = mass(23) * g / costhw
ghhzz = g**2 / 2.0_default / costhw**2
ghtt = - mass(6) / vev
ghbb = - mass(5) / vev
ghcc = - mass(4) / vev
ghtautau = - mass(15) / vev
ghmm = - mass(13) / vev
gh3 = - par%fac_gh3 * 3 * mass(25)**2 / vev
gh4 = - 3 * mass(25)**2 / vev**2
!!! Color flow basis, divide by sqrt(2)
gs = sqrt(2.0_default*PI*par%alphas)
igs = cmplx(0.0_default, 1.0_default, kind=default) * gs
c66 = par%c66
c6p = par%c6p
c6t = par%c6t
c6dw = par%c6dw
c6db = par%c6db
c6dpw = par%c6dpw
c6dpb = par%c6dpb
c6pb = par%c6pb
c6pg = par%c6pg
c6g = par%c6g
c6w = par%c6w
lambdac6 = par%lambdac6
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
!!! Higgs anomaly couplings
!!! SM LO loop factor (top,bottom,W)
ghgaga_sm = (-1._default) * alpha / vev / 2.0_default / PI * &
(( 4.0_default * (fonehalf(ttop) + fonehalf(tch)) &
+ fonehalf(tbot)) / 3.0_default + fonehalf(ttau) + fone(tw))
!!! asymptotic limit:
!!! ghgaga_sm = (par%ee)**2 / vev / &
!!! 9.0_default / pi**2
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
!!! SM LO loop factor (only top and W)
ghgaz_sm = e * e_em / 8.0_default / PI**2 / vev * ( &
( - 2.0_default + &
16.0_default/3.0_default * sin2thw) * &
(tri_i1(ttop,ltop) - tri_i2(ttop,ltop)) / costhw &
+ ( - 1.0_default + &
4.0_default/3.0_default * sin2thw) &
* (tri_i1(tbot,lbot) - tri_i2(tbot,lbot)) / costhw &
+ (-1.0_default + 4.0_default * sin2thw) &
* (tri_i1(ttau,ltau) - tri_i2(ttau,ltau)) / costhw &
- costhw * ( 4.0_default * (3.0_default - tanthw**2) * &
tri_i2(tw,lw) + ((1 + 2.0_default/tw) * tanthw**2 - ( &
5.0_default + 2.0_default/tw)) * tri_i1(tw,lw)) &
)/sinthw
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
ghgaga_ac = par%fghgaga * ghgaga_sm !!! Not yet implemented
ghgaz_ac = par%fghgaz * ghgaz_sm !!! Not yet implemented
ghzz_ac = 0.0_default !!! Not yet implemented
ghww_ac = 0.0_default !!! Not yet implemented
ghgaz_u = 0.0_default !!! Not yet implemented
ghzz_u = 0.0_default !!! Not yet implemented
ghww_u = 0.0_default !!! Not yet implemented
ghaz6d = - e / costhw * vev * c6dw/(lambdac6**2) + &
g * vev * c6db/(lambdac6**2)
ghaz6dp = 0.5_default * e / costhw * vev * c6dpw/(lambdac6**2) - &
0.5_default * g * vev * c6dpb/(lambdac6**2)
ghaz6pb = 4.0_default * costhw * sinthw * vev * c6pb/(lambdac6**2)
ghgaga6 = 4.0_default * costhw * costhw * vev * c6pb/(lambdac6**2)
dim6awwggg = 6.0_default * sinthw * c6w/(lambdac6**2)
dim6awwdp = 0.25_default * g * costhw * vev**2 * &
(g * c6dpb/(lambdac6**2) + e / costhw * c6dpw/(lambdac6**2))
dim6awwdw = 0.5_default * e**2 / sinthw * vev**2 * c6dw/(lambdac6**2)
dim6vev3 = 15 * vev**3 * c66/(lambdac6**2)
dim6cphi = 4.0_default * vev * c6p/(lambdac6**2)
ghww6d = g * vev * c6dw/(lambdac6**2)
ghww6dp = 0.5_default * g * vev * c6dpw/(lambdac6**2)
dim6wwzw = 6 * costhw * c6w/(lambdac6**2)
dim6wwzdpwdw = 0.25_default * g**2 / costhw * vev**2 * c6dpw/(lambdac6**2) &
+ 0.5_default * g * vev**2 * (sinthw*e/costhw + 3*costhw*g) &
* c6dw/(lambdac6**2)
dim6wwzdw = 0.5_default * e**2 / costhw * vev**2 * c6dw/(lambdac6**2)
dim6wwzd = 0.25_default * g**2 * costhw * vev**2 * c6dpw/(lambdac6**2) &
+ 1.5 * costhw * g**2 * vev**2 * c6dw/(lambdac6**2) &
- 0.25_default * g**2 * sinthw * vev**2 * c6dpb/(lambdac6**2)
ghzz6v3 = - 2 * g**2 / costhw**2 * vev**3 * c6t/(lambdac6**2)
ghzz6d = g * vev * c6dw/(lambdac6**2) + e / costhw * vev &
* c6db/(lambdac6**2)
ghzz6dp = 0.5_default * vev * (g * c6dpw/(lambdac6**2) + &
(e / costhw) * c6dpb/(lambdac6**2))
ghzz6pb = - 4.0_default * sinthw**2 * vev * c6pb/(lambdac6**2)
! dim6gggg = 6.0_default * c6g
! dim6gggcg = 2.0_default * gs * vev**2 * c6pg
adim6h4v2 = 45.0_default * vev**2 * c66/(lambdac6**2)
adim6h4p2 = 4.0_default * c6p/(lambdac6**2)
adim6ahwwdpb = 0.5_default * g**2 * costhw * vev * c6dpb/(lambdac6**2)
adim6ahwwdpw = 0.5_default * (e**2 / sinthw) * vev * c6dpw/(lambdac6**2)
adim6ahwwdw = (e**2 / sinthw) * vev * c6dw/(lambdac6**2)
adim6aawwdw = (e**3 / sinthw) * vev**2 * c6dw/(lambdac6**2)
adim6aawww = 6.0_default * e * sinthw * c6w/(lambdac6**2)
adim6hhwwdpw = 0.5_default * g * c6dpw/(lambdac6**2)
adim6hhwwdw = g * c6dw/(lambdac6**2)
adim6hwwzdw = (e**2 / costhw) * vev *c6dw/(lambdac6**2)
adim6hwwzddpw = g**2 * costhw * vev * ( 3*c6dw/(lambdac6**2) + &
0.5_default*c6dpw/(lambdac6**2) )
adim6hwwzdpw = 0.5_default * (e**2 / costhw) * vev * c6dpw/(lambdac6**2)
adim6hwwzdpb = 0.5_default * (e**2 / sinthw) * vev * c6dpb/(lambdac6**2)
adim6ahhzd = g * c6db/(lambdac6**2) - e/costhw * c6dw/(lambdac6**2)
adim6ahhzdp = 0.5_default * (e/costhw * c6dpw/(lambdac6**2) - &
g * c6dpb/(lambdac6**2))
adim6ahhzpb = 4.0_default * costhw * sinthw * c6pb/(lambdac6**2)
adim6azwww = 6.0_default * e * costhw * c6w/(lambdac6**2)
adim6azwwdwdpw = (e**3/costhw + costhw*(e**3)/(sinthw**2)) &
* vev**2 * 0.25_default * c6dpw/(lambdac6**2) &
+ (e**3/costhw + 3*costhw*(e**3)/(sinthw**2))* vev**2 * 0.5_default &
* c6dw/(lambdac6**2)
adim6wwwww = 6.0_default * e/sinthw * c6w/(lambdac6**2)
adim6wwwwdwdpw = (e**3)/(sinthw**3) * vev**2 * &
(0.5_default * c6dpw/(lambdac6**2) + 2.0_default * c6dw/(lambdac6**2))
adim6wwzzw = 6.0_default * costhw**2 * e/sinthw * c6w/(lambdac6**2)
- adim6wwzzdwdpw = 0.5_default * (costhw**2 * e**3 / sinthw**3 + &
+!!! Recalculated WK 2018-09-13: sign flip
+ adim6wwzzdwdpw = -0.5_default * (costhw**2 * e**3 / sinthw**3 + &
e**3 / sinthw) * vev**2 * c6dpw/(lambdac6**2) &
+ (2.0_default * costhw**2 * e**3 / sinthw**3 + e**3 / sinthw) * &
vev**2 *c6dw/(lambdac6**2)
+!!! Original version
+! adim6wwzzdwdpw = 0.5_default * (costhw**2 * e**3 / sinthw**3 + &
+! e**3 / sinthw) * vev**2 * c6dpw/(lambdac6**2) &
+! + (2.0_default * costhw**2 * e**3 / sinthw**3 + e**3 / sinthw) * &
+! vev**2 *c6dw/(lambdac6**2)
adim6hhaa = 4.0_default * costhw**2 * c6pb/(lambdac6**2)
adim6hhzzd = (costhw**2 * e / sinthw + e * sinthw ) * c6dw/(lambdac6**2) &
+ (costhw * e + sinthw**2 * e/costhw) *c6db/(lambdac6**2)
adim6hhzzdp = 0.5_default*(costhw**2 * e / sinthw + e * sinthw ) * &
c6dpw/(lambdac6**2) &
+ 0.5_default*(costhw * e + sinthw**2 * e/costhw) *c6dpb/(lambdac6**2)
adim6hhzzpb = 4.0_default * sinthw**2 * c6pb/(lambdac6**2)
adim6hhzzt = - 6.0_default * vev**2 * (g/costhw)**2 * c6t/(lambdac6**2)
end subroutine import_from_whizard
subroutine model_update_alpha_s (alpha_s)
real(default), intent(in) :: alpha_s
gs = sqrt(2.0_default*PI*alpha_s)
igs = cmplx(0.0_default, 1.0_default, kind=default) * gs
end subroutine model_update_alpha_s
end module parameters_sm_dim6
Index: trunk/src/mci/mci.nw
===================================================================
--- trunk/src/mci/mci.nw (revision 8482)
+++ trunk/src/mci/mci.nw (revision 8483)
@@ -1,14134 +1,14130 @@
%% -*- ess-noweb-default-code-mode: f90-mode; noweb-default-code-mode: f90-mode; -*-
% WHIZARD code as NOWEB source: integration and event generation
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\chapter{Multi-Channel Integration}
\includemodulegraph{mci}
The abstract representation of multi-channel
Monte Carlo algorithms for integration and event generation.
\begin{description}
\item[Module [[mci_base]]:]
The abstract types and their methods. It provides a test integrator
that is referenced in later unit tests.
\item[iterations]
Container for defining integration call and pass settings.
\item[integration\_results]
This module handles results from integrating processes. It records passes
and iterations, calculates statistical averages, and provides the user
output of integration results.
\end{description}
These are the implementations:
\begin{description}
\item[Module [[mci_midpoint]]:]
A simple integrator that uses the midpoint rule to sample the
integrand uniformly over the unit hypercube. There is only one
integration channel, so this can be matched only to single-channel
phase space.
\item[Module [[mci_vamp]]:]
Interface for the VAMP package.
\end{description}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\clearpage
\section{Generic Integrator}
This module provides a multi-channel integrator (MCI) base type, a
corresponding configuration type, and methods for integration and event
generation.
<<[[mci_base.f90]]>>=
<<File header>>
module mci_base
use kinds
use io_units
use format_utils, only: pac_fmt
use format_defs, only: FMT_14, FMT_17
use diagnostics
use cputime
use phs_base
use rng_base
<<Standard module head>>
<<MCI base: public>>
<<MCI base: types>>
<<MCI base: interfaces>>
contains
<<MCI base: procedures>>
end module mci_base
@ %def mci_base
@
\subsection{MCI: integrator}
The MCI object contains the methods for integration and event generation.
For the actual work and data storage, it spawns an MCI instance object.
The base object contains the number of integration dimensions and the number
of channels as configuration data. Further configuration data are stored in
the concrete extensions.
The MCI sum contains all relevant information about the integrand. It can be
used for comparing the current configuration against a previous one. If they
match, we can skip an actual integration. (Implemented only for the VAMP
version.)
There is a random-number generator (its state with associated methods)
available as [[rng]]. It may or may not be used for integration. It
will be used for event generation.
<<MCI base: public>>=
public :: mci_t
<<MCI base: types>>=
type, abstract :: mci_t
integer :: n_dim = 0
integer :: n_channel = 0
integer :: n_chain = 0
integer, dimension(:), allocatable :: chain
real(default), dimension(:), allocatable :: chain_weights
character(32) :: md5sum = ""
logical :: integral_known = .false.
logical :: error_known = .false.
logical :: efficiency_known = .false.
real(default) :: integral = 0
real(default) :: error = 0
real(default) :: efficiency = 0
logical :: use_timer = .false.
type(timer_t) :: timer
class(rng_t), allocatable :: rng
contains
<<MCI base: mci: TBP>>
end type mci_t
@ %def mci_t
@ Finalizer: the random-number generator may need one.
<<MCI base: mci: TBP>>=
procedure :: base_final => mci_final
procedure (mci_final), deferred :: final
<<MCI base: procedures>>=
subroutine mci_final (object)
class(mci_t), intent(inout) :: object
if (allocated (object%rng)) call object%rng%final ()
end subroutine mci_final
@ %def mci_final
@ Output: basic and extended output.
<<MCI base: mci: TBP>>=
procedure :: base_write => mci_write
procedure (mci_write), deferred :: write
<<MCI base: procedures>>=
subroutine mci_write (object, unit, pacify, md5sum_version)
class(mci_t), intent(in) :: object
integer, intent(in), optional :: unit
logical, intent(in), optional :: pacify
logical, intent(in), optional :: md5sum_version
logical :: md5sum_ver
integer :: u, i, j
character(len=7) :: fmt
call pac_fmt (fmt, FMT_17, FMT_14, pacify)
u = given_output_unit (unit)
md5sum_ver = .false.
if (present (md5sum_version)) md5sum_ver = md5sum_version
if (object%use_timer .and. .not. md5sum_ver) then
write (u, "(2x)", advance="no")
call object%timer%write (u)
end if
if (object%integral_known) then
write (u, "(3x,A," // fmt // ")") &
"Integral = ", object%integral
end if
if (object%error_known) then
write (u, "(3x,A," // fmt // ")") &
"Error = ", object%error
end if
if (object%efficiency_known) then
write (u, "(3x,A," // fmt // ")") &
"Efficiency = ", object%efficiency
end if
write (u, "(3x,A,I0)") "Number of channels = ", object%n_channel
write (u, "(3x,A,I0)") "Number of dimensions = ", object%n_dim
if (object%n_chain > 0) then
write (u, "(3x,A,I0)") "Number of chains = ", object%n_chain
write (u, "(3x,A)") "Chains:"
do i = 1, object%n_chain
write (u, "(5x,I0,':')", advance = "no") i
do j = 1, object%n_channel
if (object%chain(j) == i) &
write (u, "(1x,I0)", advance = "no") j
end do
write (u, "(A)")
end do
end if
end subroutine mci_write
@ %def mci_write
@ Print an informative message when starting integration.
<<MCI base: mci: TBP>>=
procedure (mci_startup_message), deferred :: startup_message
procedure :: base_startup_message => mci_startup_message
<<MCI base: procedures>>=
subroutine mci_startup_message (mci, unit, n_calls)
class(mci_t), intent(in) :: mci
integer, intent(in), optional :: unit, n_calls
if (mci%n_chain > 0) then
write (msg_buffer, "(A,3(1x,I0,1x,A))") &
"Integrator:", mci%n_chain, "chains,", &
mci%n_channel, "channels,", &
mci%n_dim, "dimensions"
else
write (msg_buffer, "(A,3(1x,I0,1x,A))") &
"Integrator:", &
mci%n_channel, "channels,", &
mci%n_dim, "dimensions"
end if
call msg_message (unit = unit)
end subroutine mci_startup_message
@ %def mci_startup_message
@ Dump type-specific info to a logfile.
<<MCI base: mci: TBP>>=
procedure(mci_write_log_entry), deferred :: write_log_entry
<<MCI base: interfaces>>=
abstract interface
subroutine mci_write_log_entry (mci, u)
import
class(mci_t), intent(in) :: mci
integer, intent(in) :: u
end subroutine mci_write_log_entry
end interface
@ %def mci_write_log_entry
In order to avoid dependencies on definite MCI implementations,
we introduce a MD5 sum calculator.
<<MCI base: mci: TBP>>=
procedure(mci_compute_md5sum), deferred :: compute_md5sum
<<MCI base: interfaces>>=
abstract interface
subroutine mci_compute_md5sum (mci, pacify)
import
class(mci_t), intent(inout) :: mci
logical, intent(in), optional :: pacify
end subroutine mci_compute_md5sum
end interface
@ %def mci_compute_md5sum@
@ Record the index of the MCI object within a process. For
multi-component processes with more than one integrator, the
integrator should know about its own index, so file names can be
unique, etc. The default implementation does nothing, however.
<<MCI base: mci: TBP>>=
procedure :: record_index => mci_record_index
<<MCI base: procedures>>=
subroutine mci_record_index (mci, i_mci)
class(mci_t), intent(inout) :: mci
integer, intent(in) :: i_mci
end subroutine mci_record_index
@ %def mci_record_index
@ There is no Initializer for the abstract type, but a generic setter
for the number of channels and dimensions. We make two aliases
available, to be able to override it.
<<MCI base: mci: TBP>>=
procedure :: set_dimensions => mci_set_dimensions
procedure :: base_set_dimensions => mci_set_dimensions
<<MCI base: procedures>>=
subroutine mci_set_dimensions (mci, n_dim, n_channel)
class(mci_t), intent(inout) :: mci
integer, intent(in) :: n_dim
integer, intent(in) :: n_channel
mci%n_dim = n_dim
mci%n_channel = n_channel
end subroutine mci_set_dimensions
@ %def mci_set_dimensions
@ Declare particular dimensions as flat. This information can be used
to simplify integration. When generating events, the flat dimensions
should be sampled with uniform and uncorrelated distribution. It
depends on the integrator what to do with that information.
<<MCI base: mci: TBP>>=
procedure (mci_declare_flat_dimensions), deferred :: declare_flat_dimensions
<<MCI base: interfaces>>=
abstract interface
subroutine mci_declare_flat_dimensions (mci, dim_flat)
import
class(mci_t), intent(inout) :: mci
integer, dimension(:), intent(in) :: dim_flat
end subroutine mci_declare_flat_dimensions
end interface
@ %def mci_declare_flat_dimensions
@ Declare particular channels as equivalent, possibly allowing for
permutations or reflections of dimensions. We use the information
stored in the [[phs_channel_t]] object array that the phase-space module
provides.
(We do not test this here, deferring the unit test to the [[mci_vamp]]
implementation where we actually use this feature.)
<<MCI base: mci: TBP>>=
procedure (mci_declare_equivalences), deferred :: declare_equivalences
<<MCI base: interfaces>>=
abstract interface
subroutine mci_declare_equivalences (mci, channel, dim_offset)
import
class(mci_t), intent(inout) :: mci
type(phs_channel_t), dimension(:), intent(in) :: channel
integer, intent(in) :: dim_offset
end subroutine mci_declare_equivalences
end interface
@ %def mci_declare_equivalences
@ Declare particular channels as chained together. The implementation may use
this array for keeping their weights equal to each other, etc.
The chain array is an array sized by the number of channels. For each
channel, there is an integer entry that indicates the correponding
chains. The total number of chains is the maximum value of this
entry.
<<MCI base: mci: TBP>>=
procedure :: declare_chains => mci_declare_chains
<<MCI base: procedures>>=
subroutine mci_declare_chains (mci, chain)
class(mci_t), intent(inout) :: mci
integer, dimension(:), intent(in) :: chain
allocate (mci%chain (size (chain)))
mci%n_chain = maxval (chain)
allocate (mci%chain_weights (mci%n_chain), source = 0._default)
mci%chain = chain
end subroutine mci_declare_chains
@ %def mci_declare_chains
@ Collect channel weights according to chains and store them in the
[[chain_weights]] for output. We sum up the weights for all channels that
share the same [[chain]] index and store the results in the [[chain_weights]]
array.
<<MCI base: mci: TBP>>=
procedure :: collect_chain_weights => mci_collect_chain_weights
<<MCI base: procedures>>=
subroutine mci_collect_chain_weights (mci, weight)
class(mci_t), intent(inout) :: mci
real(default), dimension(:), intent(in) :: weight
integer :: i, c
if (allocated (mci%chain)) then
mci%chain_weights = 0
do i = 1, size (mci%chain)
c = mci%chain(i)
mci%chain_weights(c) = mci%chain_weights(c) + weight(i)
end do
end if
end subroutine mci_collect_chain_weights
@ %def mci_collect_chain_weights
@ Check if there are chains.
<<MCI base: mci: TBP>>=
procedure :: has_chains => mci_has_chains
<<MCI base: procedures>>=
function mci_has_chains (mci) result (flag)
class(mci_t), intent(in) :: mci
logical :: flag
flag = allocated (mci%chain)
end function mci_has_chains
@ %def mci_has_chains
@ Output of the chain weights, kept separate from the main [[write]] method.
[The formatting will work as long as the number of chains is less than
$10^{10}$\ldots]
<<MCI base: mci: TBP>>=
procedure :: write_chain_weights => mci_write_chain_weights
<<MCI base: procedures>>=
subroutine mci_write_chain_weights (mci, unit)
class(mci_t), intent(in) :: mci
integer, intent(in), optional :: unit
integer :: u, i, n, n_digits
character(4) :: ifmt
u = given_output_unit (unit)
if (allocated (mci%chain_weights)) then
write (u, "(1x,A)") "Weights of channel chains (groves):"
n_digits = 0
n = size (mci%chain_weights)
do while (n > 0)
n = n / 10
n_digits = n_digits + 1
end do
write (ifmt, "(A1,I1)") "I", n_digits
do i = 1, size (mci%chain_weights)
write (u, "(3x," // ifmt // ",F13.10)") i, mci%chain_weights(i)
end do
end if
end subroutine mci_write_chain_weights
@ %def mci_write_chain_weights
@ Set the MD5 sum, independent of initialization.
<<MCI base: mci: TBP>>=
procedure :: set_md5sum => mci_set_md5sum
<<MCI base: procedures>>=
subroutine mci_set_md5sum (mci, md5sum)
class(mci_t), intent(inout) :: mci
character(32), intent(in) :: md5sum
mci%md5sum = md5sum
end subroutine mci_set_md5sum
@ %def mci_set_md5sum
@ Initialize a new integration pass. This is not necessarily
meaningful, so we provide an empty base method. The [[mci_vamp]]
implementation overrides this.
<<MCI base: mci: TBP>>=
procedure :: add_pass => mci_add_pass
<<MCI base: procedures>>=
subroutine mci_add_pass (mci, adapt_grids, adapt_weights, final_pass)
class(mci_t), intent(inout) :: mci
logical, intent(in), optional :: adapt_grids
logical, intent(in), optional :: adapt_weights
logical, intent(in), optional :: final_pass
end subroutine mci_add_pass
@ %def mci_add_pass
@ Allocate an instance with matching type. This must be deferred.
<<MCI base: mci: TBP>>=
procedure (mci_allocate_instance), deferred :: allocate_instance
<<MCI base: interfaces>>=
abstract interface
subroutine mci_allocate_instance (mci, mci_instance)
import
class(mci_t), intent(in) :: mci
class(mci_instance_t), intent(out), pointer :: mci_instance
end subroutine mci_allocate_instance
end interface
@ %def mci_allocate_instance
@ Import a random-number generator. We transfer the allocation of an
existing generator state into the object. The generator state may
already be initialized, or we can reset it by its [[init]]
method.
<<MCI base: mci: TBP>>=
procedure :: import_rng => mci_import_rng
<<MCI base: procedures>>=
subroutine mci_import_rng (mci, rng)
class(mci_t), intent(inout) :: mci
class(rng_t), intent(inout), allocatable :: rng
call move_alloc (rng, mci%rng)
end subroutine mci_import_rng
@ %def mci_import_rng
@ Activate or deactivate the timer.
<<MCI base: mci: TBP>>=
procedure :: set_timer => mci_set_timer
<<MCI base: procedures>>=
subroutine mci_set_timer (mci, active)
class(mci_t), intent(inout) :: mci
logical, intent(in) :: active
mci%use_timer = active
end subroutine mci_set_timer
@ %def mci_set_timer
@ Start and stop signal for the timer, if active. The elapsed time
can then be retrieved from the MCI record.
<<MCI base: mci: TBP>>=
procedure :: start_timer => mci_start_timer
procedure :: stop_timer => mci_stop_timer
<<MCI base: procedures>>=
subroutine mci_start_timer (mci)
class(mci_t), intent(inout) :: mci
if (mci%use_timer) call mci%timer%start ()
end subroutine mci_start_timer
subroutine mci_stop_timer (mci)
class(mci_t), intent(inout) :: mci
if (mci%use_timer) call mci%timer%stop ()
end subroutine mci_stop_timer
@ %def mci_start_timer
@ %def mci_stop_timer
@ Sampler test. Evaluate the sampler a given number of times. Results are
discarded, so we don't need the MCI instance which would record them.
The evaluation channel is iterated, and the [[x]] parameters are randomly
chosen.
<<MCI base: mci: TBP>>=
procedure :: sampler_test => mci_sampler_test
<<MCI base: procedures>>=
subroutine mci_sampler_test (mci, sampler, n_calls)
class(mci_t), intent(inout) :: mci
class(mci_sampler_t), intent(inout), target :: sampler
integer, intent(in) :: n_calls
real(default), dimension(:), allocatable :: x_in, f
real(default), dimension(:,:), allocatable :: x_out
real(default) :: val
integer :: i, c
allocate (x_in (mci%n_dim))
allocate (f (mci%n_channel))
allocate (x_out (mci%n_dim, mci%n_channel))
do i = 1, n_calls
c = mod (i, mci%n_channel) + 1
call mci%rng%generate_array (x_in)
call sampler%evaluate (c, x_in, val, x_out, f)
end do
end subroutine mci_sampler_test
@ %def mci_sampler_test
@ Integrate: this depends on the implementation. We foresee a pacify
flag to take care of small numerical noise on different platforms.
<<MCI base: mci: TBP>>=
procedure (mci_integrate), deferred :: integrate
<<MCI base: interfaces>>=
abstract interface
subroutine mci_integrate (mci, instance, sampler, &
n_it, n_calls, results, pacify)
import
class(mci_t), intent(inout) :: mci
class(mci_instance_t), intent(inout), target :: instance
class(mci_sampler_t), intent(inout), target :: sampler
integer, intent(in) :: n_it
integer, intent(in) :: n_calls
logical, intent(in), optional :: pacify
class(mci_results_t), intent(inout), optional :: results
end subroutine mci_integrate
end interface
@ %def mci_integrate
@ Event generation. Depending on the implementation,
event generation may or may not require a previous integration pass.
Instead of a black-box [[simulate]] method, we require an initializer,
a finalizer, and procedures for generating a single event. This
allows us to interface simulation event by event from the outside, and
it facilitates the further processing of an event after successful
generation. For integration, this is not necessary.
The initializer has [[intent(inout)]] for the [[mci]] passed object. The
reason is that the initializer can read integration results and grids from
file, where the results can modify the [[mci]] record.
<<MCI base: mci: TBP>>=
procedure (mci_prepare_simulation), deferred :: prepare_simulation
@ %def mci_final_simulation
<<MCI base: interfaces>>=
abstract interface
subroutine mci_prepare_simulation (mci)
import
class(mci_t), intent(inout) :: mci
end subroutine mci_prepare_simulation
end interface
@ %def mci_prepare_simulation
@
The generated event will reside in in the [[instance]] object (overall
results and weight) and in the [[sampler]] object (detailed data). In
the real application, we can subsequently call methods of the
[[sampler]] in order to further process the generated event.
The [[target]] attributes are required by the VAMP implementation,
which uses pointers to refer to the instance and sampler objects from
within the integration function.
<<MCI base: mci: TBP>>=
procedure (mci_generate), deferred :: generate_weighted_event
procedure (mci_generate), deferred :: generate_unweighted_event
@ %def mci_generate_weighted_event
@ %def mci_generate_unweighted_event
<<MCI base: interfaces>>=
abstract interface
subroutine mci_generate (mci, instance, sampler)
import
class(mci_t), intent(inout) :: mci
class(mci_instance_t), intent(inout), target :: instance
class(mci_sampler_t), intent(inout), target :: sampler
end subroutine mci_generate
end interface
@ %def mci_generate
@ This is analogous, but we rebuild the event from the information
stored in [[state]] instead of generating it.
Note: currently unused outside of tests, might be deleted later.
<<MCI base: mci: TBP>>=
procedure (mci_rebuild), deferred :: rebuild_event
<<MCI base: interfaces>>=
abstract interface
subroutine mci_rebuild (mci, instance, sampler, state)
import
class(mci_t), intent(inout) :: mci
class(mci_instance_t), intent(inout) :: instance
class(mci_sampler_t), intent(inout) :: sampler
class(mci_state_t), intent(in) :: state
end subroutine mci_rebuild
end interface
@ %def mci_rebuild
@
Pacify: reduce numerical noise. The base implementation does nothing.
<<MCI base: mci: TBP>>=
procedure :: pacify => mci_pacify
<<MCI base: procedures>>=
subroutine mci_pacify (object, efficiency_reset, error_reset)
class(mci_t), intent(inout) :: object
logical, intent(in), optional :: efficiency_reset, error_reset
end subroutine mci_pacify
@ %def mci_pacify
@
Return the value of the integral, error, efficiency, and time per call.
<<MCI base: mci: TBP>>=
procedure :: get_integral => mci_get_integral
procedure :: get_error => mci_get_error
procedure :: get_efficiency => mci_get_efficiency
procedure :: get_time => mci_get_time
<<MCI base: procedures>>=
function mci_get_integral (mci) result (integral)
class(mci_t), intent(in) :: mci
real(default) :: integral
if (mci%integral_known) then
integral = mci%integral
else
call msg_bug ("The integral is unknown. This is presumably a" // &
"WHIZARD bug.")
end if
end function mci_get_integral
function mci_get_error (mci) result (error)
class(mci_t), intent(in) :: mci
real(default) :: error
if (mci%error_known) then
error = mci%error
else
error = 0
end if
end function mci_get_error
function mci_get_efficiency (mci) result (efficiency)
class(mci_t), intent(in) :: mci
real(default) :: efficiency
if (mci%efficiency_known) then
efficiency = mci%efficiency
else
efficiency = 0
end if
end function mci_get_efficiency
function mci_get_time (mci) result (time)
class(mci_t), intent(in) :: mci
real(default) :: time
if (mci%use_timer) then
time = mci%timer
else
time = 0
end if
end function mci_get_time
@ %def mci_get_integral
@ %def mci_get_error
@ %def mci_get_efficiency
@ %def mci_get_time
@ Return the MD5 sum of the configuration. This may be overridden in
an extension, to return a different MD5 sum.
<<MCI base: mci: TBP>>=
procedure :: get_md5sum => mci_get_md5sum
<<MCI base: procedures>>=
pure function mci_get_md5sum (mci) result (md5sum)
class(mci_t), intent(in) :: mci
character(32) :: md5sum
md5sum = mci%md5sum
end function mci_get_md5sum
@ %def mci_get_md5sum
@
\subsection{MCI instance}
The base type contains an array of channel weights. The value [[mci_weight]]
is the combined MCI weight that corresponds to a particular sampling point.
For convenience, we also store the [[x]] and Jacobian values for this sampling
point.
<<MCI base: public>>=
public :: mci_instance_t
<<MCI base: types>>=
type, abstract :: mci_instance_t
logical :: valid = .false.
real(default), dimension(:), allocatable :: w
real(default), dimension(:), allocatable :: f
real(default), dimension(:,:), allocatable :: x
integer :: selected_channel = 0
real(default) :: mci_weight = 0
real(default) :: integrand = 0
logical :: negative_weights = .false.
integer :: n_dropped = 0
contains
<<MCI base: mci instance: TBP>>
end type mci_instance_t
@ %def mci_instance_t
@ Output: deferred
<<MCI base: mci instance: TBP>>=
procedure (mci_instance_write), deferred :: write
<<MCI base: interfaces>>=
abstract interface
subroutine mci_instance_write (object, unit, pacify)
import
class(mci_instance_t), intent(in) :: object
integer, intent(in), optional :: unit
logical, intent(in), optional :: pacify
end subroutine mci_instance_write
end interface
@ %def mci_instance_write
@ A finalizer, just in case.
<<MCI base: mci instance: TBP>>=
procedure (mci_instance_final), deferred :: final
<<MCI base: interfaces>>=
abstract interface
subroutine mci_instance_final (object)
import
class(mci_instance_t), intent(inout) :: object
end subroutine mci_instance_final
end interface
@ %def mci_instance_final
@ Init: basic initializer for the arrays, otherwise deferred. Assigning
the [[mci]] object is also deferred, because it depends on the concrete type.
The weights are initialized with an uniform normalized value.
<<MCI base: mci instance: TBP>>=
procedure (mci_instance_base_init), deferred :: init
procedure :: base_init => mci_instance_base_init
<<MCI base: procedures>>=
subroutine mci_instance_base_init (mci_instance, mci)
class(mci_instance_t), intent(out) :: mci_instance
class(mci_t), intent(in), target :: mci
allocate (mci_instance%w (mci%n_channel))
allocate (mci_instance%f (mci%n_channel))
allocate (mci_instance%x (mci%n_dim, mci%n_channel))
if (mci%n_channel > 0) then
call mci_instance%set_channel_weights &
(spread (1._default, dim=1, ncopies=mci%n_channel))
end if
mci_instance%f = 0
mci_instance%x = 0
end subroutine mci_instance_base_init
@ %def mci_instance_base_init
@ Explicitly set the array of channel weights.
<<MCI base: mci instance: TBP>>=
procedure :: set_channel_weights => mci_instance_set_channel_weights
<<MCI base: procedures>>=
subroutine mci_instance_set_channel_weights (mci_instance, weights, sum_non_zero)
class(mci_instance_t), intent(inout) :: mci_instance
real(default), dimension(:), intent(in) :: weights
logical, intent(out), optional :: sum_non_zero
real(default) :: wsum
wsum = sum (weights)
if (wsum /= 0) then
mci_instance%w = weights / wsum
if (present (sum_non_zero)) sum_non_zero = .true.
else
if (present (sum_non_zero)) sum_non_zero = .false.
call msg_warning ("MC sampler initialization:&
& sum of channel weights is zero")
end if
end subroutine mci_instance_set_channel_weights
@ %def mci_instance_set_channel_weights
@ Compute the overall weight factor for a configuration of $x$ values and
Jacobians $f$. The $x$ values come in [[n_channel]] rows with [[n_dim]]
entries each. The $f$ factors constitute an array with [[n_channel]] entries.
We assume that the $x$ and $f$ arrays are already stored inside the MC
instance. The result is also stored there.
<<MCI base: mci instance: TBP>>=
procedure (mci_instance_compute_weight), deferred :: compute_weight
<<MCI base: interfaces>>=
abstract interface
subroutine mci_instance_compute_weight (mci, c)
import
class(mci_instance_t), intent(inout) :: mci
integer, intent(in) :: c
end subroutine mci_instance_compute_weight
end interface
@ %def mci_instance_compute_weight
@ Record the integrand as returned by the sampler. Depending on the
implementation, this may merely copy the value, or do more complicated things.
We may need the MCI weight for the actual computations, so this should
be called after the previous routine.
<<MCI base: mci instance: TBP>>=
procedure (mci_instance_record_integrand), deferred :: record_integrand
<<MCI base: interfaces>>=
abstract interface
subroutine mci_instance_record_integrand (mci, integrand)
import
class(mci_instance_t), intent(inout) :: mci
real(default), intent(in) :: integrand
end subroutine mci_instance_record_integrand
end interface
@ %def mci_instance_record_integrand
@ Sample a point directly: evaluate the sampler, then compute the weight and
the weighted integrand. Finally, record the integrand within the MCI instance.
If a signal (interrupt) was raised recently, we abort the calculation before
entering the sampler. Thus, a previous calculation will have
completed and any data are already recorded, but any new point can be
discarded. If the [[abort]] flag is present, we may delay the interrupt, so
we can do some cleanup.
<<MCI base: mci instance: TBP>>=
procedure :: evaluate => mci_instance_evaluate
<<MCI base: procedures>>=
subroutine mci_instance_evaluate (mci, sampler, c, x)
class(mci_instance_t), intent(inout) :: mci
class(mci_sampler_t), intent(inout) :: sampler
integer, intent(in) :: c
real(default), dimension(:), intent(in) :: x
real(default) :: val
call sampler%evaluate (c, x, val, mci%x, mci%f)
mci%valid = sampler%is_valid ()
if (mci%valid) then
call mci%compute_weight (c)
call mci%record_integrand (val)
end if
end subroutine mci_instance_evaluate
@ %def mci_instance_evaluate
@ Initiate and terminate simulation. In contrast to integration, we implement
these as methods of the process instance, since the [[mci]] configuration
object is unchanged.
The safety factor reduces the acceptance probability for unweighted
events. The implementation of this feature depends on the concrete type.
<<MCI base: mci instance: TBP>>=
procedure (mci_instance_init_simulation), deferred :: init_simulation
procedure (mci_instance_final_simulation), deferred :: final_simulation
<<MCI base: interfaces>>=
abstract interface
subroutine mci_instance_init_simulation (instance, safety_factor)
import
class(mci_instance_t), intent(inout) :: instance
real(default), intent(in), optional :: safety_factor
end subroutine mci_instance_init_simulation
end interface
abstract interface
subroutine mci_instance_final_simulation (instance)
import
class(mci_instance_t), intent(inout) :: instance
end subroutine mci_instance_final_simulation
end interface
@ %def mci_instance_init_simulation mci_instance_final_simulation
@ Assuming that the sampler is in a completely defined state, just
extract the data that [[evaluate]] would compute. Also record the integrand.
<<MCI base: mci instance: TBP>>=
procedure :: fetch => mci_instance_fetch
<<MCI base: procedures>>=
subroutine mci_instance_fetch (mci, sampler, c)
class(mci_instance_t), intent(inout) :: mci
class(mci_sampler_t), intent(in) :: sampler
integer, intent(in) :: c
real(default) :: val
mci%valid = sampler%is_valid ()
if (mci%valid) then
call sampler%fetch (val, mci%x, mci%f)
call mci%compute_weight (c)
call mci%record_integrand (val)
end if
end subroutine mci_instance_fetch
@ %def mci_instance_fetch
@ The value, i.e., the weighted integrand, is the integrand (which
should be taken as-is from the sampler) multiplied by the MCI weight.
<<MCI base: mci instance: TBP>>=
procedure :: get_value => mci_instance_get_value
<<MCI base: procedures>>=
function mci_instance_get_value (mci) result (value)
class(mci_instance_t), intent(in) :: mci
real(default) :: value
if (mci%valid) then
value = mci%integrand * mci%mci_weight
else
value = 0
end if
end function mci_instance_get_value
@ %def mci_instance_get_value
@ This is an extra routine. By default, the event weight is equal to
the value returned by the previous routine. However, if we select a
channel for event generation not just based on the channel weights,
the event weight has to account for this bias, so the event weight
that applies to event generation is different. In that case, we
should override the default routine.
<<MCI base: mci instance: TBP>>=
procedure :: get_event_weight => mci_instance_get_value
@ %def mci_instance_get_event_weight
@ Excess weight can occur during unweighted event generation, if the
assumed maximum value of the integrand is too small. This excess
should be normalized in the same way as the event weight above (which
for unweighted events becomes unity).
<<MCI base: mci instance: TBP>>=
procedure (mci_instance_get_event_excess), deferred :: get_event_excess
<<MCI base: interfaces>>=
abstract interface
function mci_instance_get_event_excess (mci) result (excess)
import
class(mci_instance_t), intent(in) :: mci
real(default) :: excess
end function mci_instance_get_event_excess
end interface
@ %def mci_instance_get_event_excess
@ Dropped events (i.e., events with zero weight that are not retained)
are counted within the [[mci_instance]] object.
<<MCI base: mci instance: TBP>>=
procedure :: get_n_event_dropped => mci_instance_get_n_event_dropped
procedure :: reset_n_event_dropped => mci_instance_reset_n_event_dropped
procedure :: record_event_dropped => mci_instance_record_event_dropped
<<MCI base: procedures>>=
function mci_instance_get_n_event_dropped (mci) result (n_dropped)
class(mci_instance_t), intent(in) :: mci
integer :: n_dropped
n_dropped = mci%n_dropped
end function mci_instance_get_n_event_dropped
subroutine mci_instance_reset_n_event_dropped (mci)
class(mci_instance_t), intent(inout) :: mci
mci%n_dropped = 0
end subroutine mci_instance_reset_n_event_dropped
subroutine mci_instance_record_event_dropped (mci)
class(mci_instance_t), intent(inout) :: mci
mci%n_dropped = mci%n_dropped + 1
end subroutine mci_instance_record_event_dropped
@ %def mci_instance_get_n_event_dropped
@ %def mci_instance_reset_n_event_dropped
@ %def mci_instance_record_event_dropped
@
\subsection{MCI state}
This object can hold the relevant information that allows us to
reconstruct the MCI instance without re-evaluating the sampler completely.
We store the [[x_in]] MC input parameter set, which coincides with the
section of the complete [[x]] array that belongs to a particular
channel. We also store the MC function value. When we want to
reconstruct the state, we can use the input array to recover the
complete [[x]] and [[f]] arrays (i.e., the kinematics), but do not
need to recompute the MC function value (the dynamics).
The [[mci_state_t]] may be extended, to allow storing/recalling more
information. In that case, we would override the type-bound
procedures. However, the base type is also a concrete type and
self-contained.
<<MCI base: public>>=
public :: mci_state_t
<<MCI base: types>>=
type :: mci_state_t
integer :: selected_channel = 0
real(default), dimension(:), allocatable :: x_in
real(default) :: val
contains
<<MCI base: mci state: TBP>>
end type mci_state_t
@ %def mci_state_t
@ Output:
<<MCI base: mci state: TBP>>=
procedure :: write => mci_state_write
<<MCI base: procedures>>=
subroutine mci_state_write (object, unit)
class(mci_state_t), intent(in) :: object
integer, intent(in), optional :: unit
integer :: u
u = given_output_unit (unit)
write (u, "(1x,A)") "MCI state:"
write (u, "(3x,A,I0)") "Channel = ", object%selected_channel
write (u, "(3x,A,999(1x,F12.10))") "x (in) =", object%x_in
write (u, "(3x,A,ES19.12)") "Integrand = ", object%val
end subroutine mci_state_write
@ %def mci_state_write
@ To store the object, we take the relevant section of the [[x]]
array. The channel used for storing data is taken from the
[[instance]] object, but it could be arbitrary in principle.
<<MCI base: mci instance: TBP>>=
procedure :: store => mci_instance_store
<<MCI base: procedures>>=
subroutine mci_instance_store (mci, state)
class(mci_instance_t), intent(in) :: mci
class(mci_state_t), intent(out) :: state
state%selected_channel = mci%selected_channel
allocate (state%x_in (size (mci%x, 1)))
state%x_in = mci%x(:,mci%selected_channel)
state%val = mci%integrand
end subroutine mci_instance_store
@ %def mci_instance_store
@ Recalling the state, we must consult the sampler in order to fully
reconstruct the [[x]] and [[f]] arrays. The integrand value is known,
and we also give it to the sampler, bypassing evaluation.
The final steps are equivalent to the [[evaluate]] method above.
<<MCI base: mci instance: TBP>>=
procedure :: recall => mci_instance_recall
<<MCI base: procedures>>=
subroutine mci_instance_recall (mci, sampler, state)
class(mci_instance_t), intent(inout) :: mci
class(mci_sampler_t), intent(inout) :: sampler
class(mci_state_t), intent(in) :: state
if (size (state%x_in) == size (mci%x, 1) &
.and. state%selected_channel <= size (mci%x, 2)) then
call sampler%rebuild (state%selected_channel, &
state%x_in, state%val, mci%x, mci%f)
call mci%compute_weight (state%selected_channel)
call mci%record_integrand (state%val)
else
call msg_fatal ("Recalling event: mismatch in channel or dimension")
end if
end subroutine mci_instance_recall
@ %def mci_instance_recall
@
\subsection{MCI sampler}
A sampler is an object that implements a multi-channel parameterization of the
unit hypercube. Specifically, it is able to compute, given a channel and a
set of $x$ MC parameter values, the complete set of $x$ values and
associated Jacobian factors $f$ for all channels.
Furthermore, the sampler should return a single real value, the integrand, for
the given point in the hypercube.
It must implement a method [[evaluate]] for performing the above
computations.
<<MCI base: public>>=
public :: mci_sampler_t
<<MCI base: types>>=
type, abstract :: mci_sampler_t
contains
<<MCI base: mci sampler: TBP>>
end type mci_sampler_t
@ %def mci_sampler_t
@ Output, deferred to the implementation.
<<MCI base: mci sampler: TBP>>=
procedure (mci_sampler_write), deferred :: write
<<MCI base: interfaces>>=
abstract interface
subroutine mci_sampler_write (object, unit, testflag)
import
class(mci_sampler_t), intent(in) :: object
integer, intent(in), optional :: unit
logical, intent(in), optional :: testflag
end subroutine mci_sampler_write
end interface
@ %def mci_sampler_write
@ The evaluation routine. Input is the channel index [[c]] and the
one-dimensional parameter array [[x_in]]. Output are the integrand value
[[val]], the two-dimensional parameter array [[x]] and the Jacobian array
[[f]].
<<MCI base: mci sampler: TBP>>=
procedure (mci_sampler_evaluate), deferred :: evaluate
<<MCI base: interfaces>>=
abstract interface
subroutine mci_sampler_evaluate (sampler, c, x_in, val, x, f)
import
class(mci_sampler_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 mci_sampler_evaluate
end interface
@ %def mci_sampler_evaluate
@ Query the validity of the sampling point. Can be called after
[[evaluate]].
<<MCI base: mci sampler: TBP>>=
procedure (mci_sampler_is_valid), deferred :: is_valid
<<MCI base: interfaces>>=
abstract interface
function mci_sampler_is_valid (sampler) result (valid)
import
class(mci_sampler_t), intent(in) :: sampler
logical :: valid
end function mci_sampler_is_valid
end interface
@ %def mci_sampler_is_valid
@ The shortcut. Again, the channel index [[c]] and the parameter
array [[x_in]] are input. However, we also provide the integrand
value [[val]], and we just require that the complete parameter array
[[x]] and Jacobian array [[f]] are recovered.
<<MCI base: mci sampler: TBP>>=
procedure (mci_sampler_rebuild), deferred :: rebuild
<<MCI base: interfaces>>=
abstract interface
subroutine mci_sampler_rebuild (sampler, c, x_in, val, x, f)
import
class(mci_sampler_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 mci_sampler_rebuild
end interface
@ %def mci_sampler_rebuild
@ This routine should extract the important data from a sampler that
has been filled by other means. We fetch the integrand value [[val]],
the two-dimensional parameter array [[x]] and the Jacobian array [[f]].
<<MCI base: mci sampler: TBP>>=
procedure (mci_sampler_fetch), deferred :: fetch
<<MCI base: interfaces>>=
abstract interface
subroutine mci_sampler_fetch (sampler, val, x, f)
import
class(mci_sampler_t), intent(in) :: sampler
real(default), intent(out) :: val
real(default), dimension(:,:), intent(out) :: x
real(default), dimension(:), intent(out) :: f
end subroutine mci_sampler_fetch
end interface
@ %def mci_sampler_fetch
@
\subsection{Results record}
This is an abstract type which allows us to implement callback: each
integration results can optionally be recorded to an instance of this
object. The actual object may store a new result, average results,
etc. It may also display a result on-line or otherwise, whenever
the [[record]] method is called.
<<MCI base: public>>=
public :: mci_results_t
<<MCI base: types>>=
type, abstract :: mci_results_t
contains
<<MCI base: mci results: TBP>>
end type mci_results_t
@ %def mci_results_t
@ The output routine is deferred. We provide an extra [[verbose]]
flag, which could serve any purpose.
<<MCI base: mci results: TBP>>=
procedure (mci_results_write), deferred :: write
procedure (mci_results_write_verbose), deferred :: write_verbose
<<MCI base: interfaces>>=
abstract interface
subroutine mci_results_write (object, unit, suppress)
import
class(mci_results_t), intent(in) :: object
integer, intent(in), optional :: unit
logical, intent(in), optional :: suppress
end subroutine mci_results_write
subroutine mci_results_write_verbose (object, unit)
import
class(mci_results_t), intent(in) :: object
integer, intent(in), optional :: unit
end subroutine mci_results_write_verbose
end interface
@ %def mci_results_write
@ This is the generic [[record]] method, which can be called directly from the
integrator. The [[record_extended]] procedure store additionally the valid
calls, positive and negative efficiency.
<<MCI base: mci results: TBP>>=
generic :: record => record_simple, record_extended
procedure (mci_results_record_simple), deferred :: record_simple
procedure (mci_results_record_extended), deferred :: record_extended
<<MCI base: interfaces>>=
abstract interface
subroutine mci_results_record_simple (object, n_it, &
n_calls, integral, error, efficiency, chain_weights, suppress)
import
class(mci_results_t), intent(inout) :: object
integer, intent(in) :: n_it
integer, intent(in) :: n_calls
real(default), intent(in) :: integral
real(default), intent(in) :: error
real(default), intent(in) :: efficiency
real(default), dimension(:), intent(in), optional :: chain_weights
logical, intent(in), optional :: suppress
end subroutine mci_results_record_simple
subroutine mci_results_record_extended (object, n_it, n_calls,&
& n_calls_valid, integral, error, efficiency, efficiency_pos,&
& efficiency_neg, chain_weights, suppress)
import
class(mci_results_t), intent(inout) :: object
integer, intent(in) :: n_it
integer, intent(in) :: n_calls
integer, intent(in) :: n_calls_valid
real(default), intent(in) :: integral
real(default), intent(in) :: error
real(default), intent(in) :: efficiency
real(default), intent(in) :: efficiency_pos
real(default), intent(in) :: efficiency_neg
real(default), dimension(:), intent(in), optional :: chain_weights
logical, intent(in), optional :: suppress
end subroutine mci_results_record_extended
end interface
@ %def mci_results_record
@
\subsection{Unit tests}
Test module, followed by the corresponding implementation module.
<<[[mci_base_ut.f90]]>>=
<<File header>>
module mci_base_ut
use unit_tests
use mci_base_uti
<<Standard module head>>
<<MCI base: public test>>
<<MCI base: public test auxiliary>>
contains
<<MCI base: test driver>>
end module mci_base_ut
@ %def mci_base_ut
@
<<[[mci_base_uti.f90]]>>=
<<File header>>
module mci_base_uti
<<Use kinds>>
use io_units
use diagnostics
use phs_base
use rng_base
use mci_base
use rng_base_ut, only: rng_test_t
<<Standard module head>>
<<MCI base: public test auxiliary>>
<<MCI base: test declarations>>
<<MCI base: test types>>
contains
<<MCI base: tests>>
end module mci_base_uti
@ %def mci_base_ut
@ API: driver for the unit tests below.
<<MCI base: public test>>=
public :: mci_base_test
<<MCI base: test driver>>=
subroutine mci_base_test (u, results)
integer, intent(in) :: u
type(test_results_t), intent(inout) :: results
<<MCI base: execute tests>>
end subroutine mci_base_test
@ %def mci_base_test
@
\subsubsection{Test implementation of the configuration type}
The concrete type contains the number of requested calls and the integral
result, to be determined.
The [[max_factor]] entry is set for the actual test integration, where the
integrand is not unity but some other constant value. This value should be
set here, such that the actual maximum of the integrand is known when
vetoing unweighted events.
<<MCI base: public test auxiliary>>=
public :: mci_test_t
<<MCI base: test types>>=
type, extends (mci_t) :: mci_test_t
integer :: divisions = 0
integer :: tries = 0
real(default) :: max_factor = 1
contains
procedure :: final => mci_test_final
procedure :: write => mci_test_write
procedure :: startup_message => mci_test_startup_message
procedure :: write_log_entry => mci_test_write_log_entry
procedure :: compute_md5sum => mci_test_compute_md5sum
procedure :: declare_flat_dimensions => mci_test_ignore_flat_dimensions
procedure :: declare_equivalences => mci_test_ignore_equivalences
procedure :: set_divisions => mci_test_set_divisions
procedure :: set_max_factor => mci_test_set_max_factor
procedure :: allocate_instance => mci_test_allocate_instance
procedure :: integrate => mci_test_integrate
procedure :: prepare_simulation => mci_test_ignore_prepare_simulation
procedure :: generate_weighted_event => mci_test_generate_weighted_event
procedure :: generate_unweighted_event => &
mci_test_generate_unweighted_event
procedure :: rebuild_event => mci_test_rebuild_event
end type mci_test_t
@ %def mci_test_t
@ Finalizer: base version is sufficient
<<MCI base: tests>>=
subroutine mci_test_final (object)
class(mci_test_t), intent(inout) :: object
call object%base_final ()
end subroutine mci_test_final
@ %def mci_test_final
@ Output: trivial
<<MCI base: tests>>=
subroutine mci_test_write (object, unit, pacify, md5sum_version)
class(mci_test_t), intent(in) :: object
integer, intent(in), optional :: unit
logical, intent(in), optional :: pacify
logical, intent(in), optional :: md5sum_version
integer :: u
u = given_output_unit (unit)
write (u, "(1x,A)") "Test integrator:"
call object%base_write (u, pacify, md5sum_version)
if (object%divisions /= 0) then
write (u, "(3x,A,I0)") "Number of divisions = ", object%divisions
end if
if (allocated (object%rng)) call object%rng%write (u)
end subroutine mci_test_write
@ %def mci_test_write
@ Short version.
<<MCI base: tests>>=
subroutine mci_test_startup_message (mci, unit, n_calls)
class(mci_test_t), intent(in) :: mci
integer, intent(in), optional :: unit, n_calls
call mci%base_startup_message (unit = unit, n_calls = n_calls)
write (msg_buffer, "(A,1x,I0,1x,A)") &
"Integrator: Test:", mci%divisions, "divisions"
call msg_message (unit = unit)
end subroutine mci_test_startup_message
@ %def mci_test_startup_message
@ Log entry: nothing.
<<MCI base: tests>>=
subroutine mci_test_write_log_entry (mci, u)
class(mci_test_t), intent(in) :: mci
integer, intent(in) :: u
end subroutine mci_test_write_log_entry
@ %def mci_test_write_log_entry
@ Compute MD5 sum: nothing.
<<MCI base: tests>>=
subroutine mci_test_compute_md5sum (mci, pacify)
class(mci_test_t), intent(inout) :: mci
logical, intent(in), optional :: pacify
end subroutine mci_test_compute_md5sum
@ %def mci_test_compute_md5sum
@ This is a no-op for the test integrator.
<<MCI base: tests>>=
subroutine mci_test_ignore_flat_dimensions (mci, dim_flat)
class(mci_test_t), intent(inout) :: mci
integer, dimension(:), intent(in) :: dim_flat
end subroutine mci_test_ignore_flat_dimensions
@ %def mci_test_ignore_flat_dimensions
@ Ditto.
<<MCI base: tests>>=
subroutine mci_test_ignore_equivalences (mci, channel, dim_offset)
class(mci_test_t), intent(inout) :: mci
type(phs_channel_t), dimension(:), intent(in) :: channel
integer, intent(in) :: dim_offset
end subroutine mci_test_ignore_equivalences
@ %def mci_test_ignore_equivalences
@ Set the number of divisions to a nonzero value.
<<MCI base: tests>>=
subroutine mci_test_set_divisions (object, divisions)
class(mci_test_t), intent(inout) :: object
integer, intent(in) :: divisions
object%divisions = divisions
end subroutine mci_test_set_divisions
@ %def mci_test_set_divisions
@ Set the maximum factor (default is 1).
<<MCI base: tests>>=
subroutine mci_test_set_max_factor (object, max_factor)
class(mci_test_t), intent(inout) :: object
real(default), intent(in) :: max_factor
object%max_factor = max_factor
end subroutine mci_test_set_max_factor
@ %def mci_test_set_max_factor
@ Allocate instance with matching type.
<<MCI base: tests>>=
subroutine mci_test_allocate_instance (mci, mci_instance)
class(mci_test_t), intent(in) :: mci
class(mci_instance_t), intent(out), pointer :: mci_instance
allocate (mci_test_instance_t :: mci_instance)
end subroutine mci_test_allocate_instance
@ %def mci_test_allocate_instance
@ Integrate: sample at the midpoints of uniform bits and add the results.
We implement this for one and for two dimensions. In the latter case,
we scan over two channels and multiply with the channel weights.
The arguments [[n_it]] and [[n_calls]] are ignored in this implementations.
The test integrator does not set error or efficiency, so those will
remain undefined.
<<MCI base: tests>>=
subroutine mci_test_integrate (mci, instance, sampler, &
n_it, n_calls, results, pacify)
class(mci_test_t), intent(inout) :: mci
class(mci_instance_t), intent(inout), target :: instance
class(mci_sampler_t), intent(inout), target :: sampler
integer, intent(in) :: n_it
integer, intent(in) :: n_calls
logical, intent(in), optional :: pacify
class(mci_results_t), intent(inout), optional :: results
real(default), dimension(:), allocatable :: integral
real(default), dimension(:), allocatable :: x
integer :: i, j, c
select type (instance)
type is (mci_test_instance_t)
allocate (integral (mci%n_channel))
integral = 0
allocate (x (mci%n_dim))
select case (mci%n_dim)
case (1)
do c = 1, mci%n_channel
do i = 1, mci%divisions
x(1) = (i - 0.5_default) / mci%divisions
call instance%evaluate (sampler, c, x)
integral(c) = integral(c) + instance%get_value ()
end do
end do
mci%integral = dot_product (instance%w, integral) &
/ mci%divisions
mci%integral_known = .true.
case (2)
do c = 1, mci%n_channel
do i = 1, mci%divisions
x(1) = (i - 0.5_default) / mci%divisions
do j = 1, mci%divisions
x(2) = (j - 0.5_default) / mci%divisions
call instance%evaluate (sampler, c, x)
integral(c) = integral(c) + instance%get_value ()
end do
end do
end do
mci%integral = dot_product (instance%w, integral) &
/ mci%divisions / mci%divisions
mci%integral_known = .true.
end select
if (present (results)) then
call results%record (n_it, n_calls, &
mci%integral, mci%error, &
efficiency = 0._default)
end if
end select
end subroutine mci_test_integrate
@ %def mci_test_integrate
@ Simulation initializer and finalizer: nothing to do here.
<<MCI base: tests>>=
subroutine mci_test_ignore_prepare_simulation (mci)
class(mci_test_t), intent(inout) :: mci
end subroutine mci_test_ignore_prepare_simulation
@ %def mci_test_ignore_prepare_simulation
@ Event generator. We use mock random numbers for first selecting the
channel and then setting the $x$ values. The results reside in the
state of [[instance]] and [[sampler]].
<<MCI base: tests>>=
subroutine mci_test_generate_weighted_event (mci, instance, sampler)
class(mci_test_t), intent(inout) :: mci
class(mci_instance_t), intent(inout), target :: instance
class(mci_sampler_t), intent(inout), target :: sampler
real(default) :: r
real(default), dimension(:), allocatable :: x
integer :: c
select type (instance)
type is (mci_test_instance_t)
allocate (x (mci%n_dim))
select case (mci%n_channel)
case (1)
c = 1
call mci%rng%generate (x(1))
case (2)
call mci%rng%generate (r)
if (r < instance%w(1)) then
c = 1
else
c = 2
end if
call mci%rng%generate (x)
end select
call instance%evaluate (sampler, c, x)
end select
end subroutine mci_test_generate_weighted_event
@ %def mci_test_generate_weighted_event
@ For unweighted events, we generate weighted events and apply a
simple rejection step to the relative event weight, until an event passes.
(This might result in an endless loop if we happen to be in sync with
the mock random generator cycle. Therefore, limit the number of tries.)
<<MCI base: tests>>=
subroutine mci_test_generate_unweighted_event (mci, instance, sampler)
class(mci_test_t), intent(inout) :: mci
class(mci_instance_t), intent(inout), target :: instance
class(mci_sampler_t), intent(inout), target :: sampler
real(default) :: r
integer :: i
select type (instance)
type is (mci_test_instance_t)
mci%tries = 0
do i = 1, 10
call mci%generate_weighted_event (instance, sampler)
mci%tries = mci%tries + 1
call mci%rng%generate (r)
if (r < instance%rel_value) exit
end do
end select
end subroutine mci_test_generate_unweighted_event
@ %def mci_test_generate_unweighted_event
@ Here, we rebuild the event from the state without consulting the rng.
<<MCI base: tests>>=
subroutine mci_test_rebuild_event (mci, instance, sampler, state)
class(mci_test_t), intent(inout) :: mci
class(mci_instance_t), intent(inout) :: instance
class(mci_sampler_t), intent(inout) :: sampler
class(mci_state_t), intent(in) :: state
select type (instance)
type is (mci_test_instance_t)
call instance%recall (sampler, state)
end select
end subroutine mci_test_rebuild_event
@ %def mci_test_rebuild_event
@
\subsubsection{Instance of the test MCI type}
This instance type simulates the VAMP approach. We implement the VAMP
multi-channel formula, but keep the channel-specific probability
functions $g_i$ smooth and fixed. We also keep the weights fixed.
The setup is as follows: we have $n$ mappings of the unit hypercube
\begin{equation}
x = x (x^{(k)}) \qquad \text{where $x=(x_1,\ldots)$}.
\end{equation}
The Jacobian factors are the determinants
\begin{equation}
f^{(k)}(x^{(k)}) = \left|\frac{\partial x}{\partial x^{(k)}}\right|
\end{equation}
We introduce arbitrary probability functions
\begin{equation}
g^{(k)}(x^{(k)}) \qquad
\text{with}\quad \int dx^{(k)} g^{(k)}(x^{(k)}) = 1
\end{equation}
and weights
\begin{equation}
w_k \qquad \text{with}\quad \sum_k w_k = 1
\end{equation}
and construct the joint probability function
\begin{equation}
g(x) = \sum_k w_k\frac{g^{(k)}(x^{(k)}(x))}{f^{(k)}(x^{(k)}(x))}
\end{equation}
which also satisfies
\begin{equation}
\int g(x)\,dx = 1.
\end{equation}
The algorithm implements a resolution of unity as follows
\begin{align}
1 &= \int dx = \int\frac{g(x)}{g(x)} dx
\nonumber\\
&= \sum w_k \int \frac{g^{(k)}(x^{(k)}(x))}{f^{(k)}(x^{(k)}(x))}
\,\frac{dx}{g(x)}
\nonumber\\
&= \sum w_k \int g^{(k)}(x^{(k)}) \frac{dx^{(k)}}{g(x(x^{(k)}))}
\end{align}
where each of the integrals in the sum is evaluated using the
channel-specific variables $x^{(k)}$.
We provide two examples: (1) trivial with one channel, one dimension,
and all functions unity and (2) two channels and two dimensions with
\begin{align}
x (x^{(1)}) &= (x^{(1)}_1, x^{(1)}_2)
\nonumber\\
x (x^{(2)}) &= (x^{(2)}_1{}^2, x^{(2)}_2)
\end{align}
hence
\begin{align}
f^{(1)}&\equiv 1,
&f^{(2)}(x^{(2)}) &= 2x^{(2)}_1
\end{align}
The probability functions are
\begin{align}
g^{(1)}&\equiv 1,
&g^{(2)}(x^{(2)}) = 2 x^{(2)}_2
\end{align}
In the concrete implementation of the integrator instance we store
values for the channel probabilities $g_i$ and the accumulated
probability $g$.
We also store the result (product of integrand and MCI weight), the
expected maximum for the result in each channel.
<<XXX MCI base: public>>=
public :: mci_test_instance_t
<<MCI base: test types>>=
type, extends (mci_instance_t) :: mci_test_instance_t
type(mci_test_t), pointer :: mci => null ()
real(default) :: g = 0
real(default), dimension(:), allocatable :: gi
real(default) :: value = 0
real(default) :: rel_value = 0
real(default), dimension(:), allocatable :: max
contains
procedure :: write => mci_test_instance_write
procedure :: final => mci_test_instance_final
procedure :: init => mci_test_instance_init
procedure :: compute_weight => mci_test_instance_compute_weight
procedure :: record_integrand => mci_test_instance_record_integrand
procedure :: init_simulation => mci_test_instance_init_simulation
procedure :: final_simulation => mci_test_instance_final_simulation
procedure :: get_event_excess => mci_test_instance_get_event_excess
end type mci_test_instance_t
@ %def mci_test_instance_t
@ Output: trivial
<<MCI base: tests>>=
subroutine mci_test_instance_write (object, unit, pacify)
class(mci_test_instance_t), intent(in) :: object
integer, intent(in), optional :: unit
logical, intent(in), optional :: pacify
integer :: u, c
u = given_output_unit (unit)
write (u, "(1x,A,ES13.7)") "Result value = ", object%value
write (u, "(1x,A,ES13.7)") "Rel. weight = ", object%rel_value
write (u, "(1x,A,ES13.7)") "Integrand = ", object%integrand
write (u, "(1x,A,ES13.7)") "MCI weight = ", object%mci_weight
write (u, "(3x,A,I0)") "c = ", object%selected_channel
write (u, "(3x,A,ES13.7)") "g = ", object%g
write (u, "(1x,A)") "Channel parameters:"
do c = 1, object%mci%n_channel
write (u, "(1x,I0,A,4(1x,ES13.7))") c, ": w/f/g/m =", &
object%w(c), object%f(c), object%gi(c), object%max(c)
write (u, "(4x,A,9(1x,F9.7))") "x =", object%x(:,c)
end do
end subroutine mci_test_instance_write
@ %def mci_test_instance_write
@ The finalizer is empty.
<<MCI base: tests>>=
subroutine mci_test_instance_final (object)
class(mci_test_instance_t), intent(inout) :: object
end subroutine mci_test_instance_final
@ %def mci_test_instance_final
@ Initializer. We make use of the analytical result that the maximum of
the weighted integrand, in each channel, is equal to $1$
(one-dimensional case) and $2$ (two-dimensional case), respectively.
<<MCI base: tests>>=
subroutine mci_test_instance_init (mci_instance, mci)
class(mci_test_instance_t), intent(out) :: mci_instance
class(mci_t), intent(in), target :: mci
call mci_instance%base_init (mci)
select type (mci)
type is (mci_test_t)
mci_instance%mci => mci
end select
allocate (mci_instance%gi (mci%n_channel))
mci_instance%gi = 0
allocate (mci_instance%max (mci%n_channel))
select case (mci%n_channel)
case (1)
mci_instance%max = 1._default
case (2)
mci_instance%max = 2._default
end select
end subroutine mci_test_instance_init
@ %def mci_test_instance_init
@ Compute weight: we implement the VAMP multi-channel formula. The channel
probabilities [[gi]] are predefined functions.
<<MCI base: tests>>=
subroutine mci_test_instance_compute_weight (mci, c)
class(mci_test_instance_t), intent(inout) :: mci
integer, intent(in) :: c
integer :: i
mci%selected_channel = c
select case (mci%mci%n_dim)
case (1)
mci%gi(1) = 1
case (2)
mci%gi(1) = 1
mci%gi(2) = 2 * mci%x(2,2)
end select
mci%g = 0
do i = 1, mci%mci%n_channel
mci%g = mci%g + mci%w(i) * mci%gi(i) / mci%f(i)
end do
mci%mci_weight = mci%gi(c) / mci%g
end subroutine mci_test_instance_compute_weight
@ %def mci_test_instance_compute_weight
@ Record the integrand. Apply the Jacobian weight to get the absolute value.
Divide by the channel maximum and by any overall factor to get the value
relative to the maximum.
<<MCI base: tests>>=
subroutine mci_test_instance_record_integrand (mci, integrand)
class(mci_test_instance_t), intent(inout) :: mci
real(default), intent(in) :: integrand
mci%integrand = integrand
mci%value = mci%integrand * mci%mci_weight
mci%rel_value = mci%value / mci%max(mci%selected_channel) &
/ mci%mci%max_factor
end subroutine mci_test_instance_record_integrand
@ %def mci_test_instance_record_integrand
@ Nothing to do here.
<<MCI base: tests>>=
subroutine mci_test_instance_init_simulation (instance, safety_factor)
class(mci_test_instance_t), intent(inout) :: instance
real(default), intent(in), optional :: safety_factor
end subroutine mci_test_instance_init_simulation
subroutine mci_test_instance_final_simulation (instance)
class(mci_test_instance_t), intent(inout) :: instance
end subroutine mci_test_instance_final_simulation
@ %def mci_test_instance_init_simulation
@ %def mci_test_instance_final_simulation
@ Return always zero.
<<MCI base: tests>>=
function mci_test_instance_get_event_excess (mci) result (excess)
class(mci_test_instance_t), intent(in) :: mci
real(default) :: excess
excess = 0
end function mci_test_instance_get_event_excess
@ %def mci_test_instance_get_event_excess
@
\subsubsection{Test sampler}
The test sampler implements a fixed configuration, either trivial
(one-channel, one-dimension), or slightly nontrivial (two-channel,
two-dimension). In the second channel, the first parameter is mapped
according to $x_1 = x^{(2)}_1{}^2$, so we have $f^{(2)}(x^{(2)}) =
2x^{(2)}_1$.
For display purposes, we store the return values inside the object. This is
not strictly necessary.
<<MCI base: test types>>=
type, extends (mci_sampler_t) :: test_sampler_t
real(default) :: integrand = 0
integer :: selected_channel = 0
real(default), dimension(:,:), allocatable :: x
real(default), dimension(:), allocatable :: f
contains
procedure :: init => test_sampler_init
procedure :: write => test_sampler_write
procedure :: compute => test_sampler_compute
procedure :: is_valid => test_sampler_is_valid
procedure :: evaluate => test_sampler_evaluate
procedure :: rebuild => test_sampler_rebuild
procedure :: fetch => test_sampler_fetch
end type test_sampler_t
@ %def test_sampler_t
<<MCI base: tests>>=
subroutine test_sampler_init (sampler, n)
class(test_sampler_t), intent(out) :: sampler
integer, intent(in) :: n
allocate (sampler%x (n, n))
allocate (sampler%f (n))
end subroutine test_sampler_init
@ %def test_sampler_init
@ Output
<<MCI base: tests>>=
subroutine test_sampler_write (object, unit, testflag)
class(test_sampler_t), intent(in) :: object
integer, intent(in), optional :: unit
logical, intent(in), optional :: testflag
integer :: u, c
u = given_output_unit (unit)
write (u, "(1x,A)") "Test sampler:"
write (u, "(3x,A,ES13.7)") "Integrand = ", object%integrand
write (u, "(3x,A,I0)") "Channel = ", object%selected_channel
do c = 1, size (object%f)
write (u, "(1x,I0,':',1x,A,ES13.7)") c, "f = ", object%f(c)
write (u, "(4x,A,9(1x,F9.7))") "x =", object%x(:,c)
end do
end subroutine test_sampler_write
@ %def test_sampler_write
@ Compute $x$ and Jacobians, given the input parameter array. This is called
both by [[evaluate]] and [[rebuild]].
<<MCI base: tests>>=
subroutine test_sampler_compute (sampler, c, x_in)
class(test_sampler_t), intent(inout) :: sampler
integer, intent(in) :: c
real(default), dimension(:), intent(in) :: x_in
sampler%selected_channel = c
select case (size (sampler%f))
case (1)
sampler%x(:,1) = x_in
sampler%f = 1
case (2)
select case (c)
case (1)
sampler%x(:,1) = x_in
sampler%x(1,2) = sqrt (x_in(1))
sampler%x(2,2) = x_in(2)
case (2)
sampler%x(1,1) = x_in(1) ** 2
sampler%x(2,1) = x_in(2)
sampler%x(:,2) = x_in
end select
sampler%f(1) = 1
sampler%f(2) = 2 * sampler%x(1,2)
end select
end subroutine test_sampler_compute
@ %def test_sampler_kineamtics
@ The point is always valid.
<<MCI base: tests>>=
function test_sampler_is_valid (sampler) result (valid)
class(test_sampler_t), intent(in) :: sampler
logical :: valid
valid = .true.
end function test_sampler_is_valid
@ %def test_sampler_is_valid
@ The integrand is always equal to 1.
<<MCI base: tests>>=
subroutine test_sampler_evaluate (sampler, c, x_in, val, x, f)
class(test_sampler_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%compute (c, x_in)
sampler%integrand = 1
val = sampler%integrand
x = sampler%x
f = sampler%f
end subroutine test_sampler_evaluate
@ %def test_sampler_evaluate
@ Construct kinematics from the input $x$ array. Set the integrand
instead of evaluating it.
<<MCI base: tests>>=
subroutine test_sampler_rebuild (sampler, c, x_in, val, x, f)
class(test_sampler_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 sampler%compute (c, x_in)
sampler%integrand = val
x = sampler%x
f = sampler%f
end subroutine test_sampler_rebuild
@ %def test_sampler_rebuild
@ Recall contents.
<<MCI base: tests>>=
subroutine test_sampler_fetch (sampler, val, x, f)
class(test_sampler_t), intent(in) :: sampler
real(default), intent(out) :: val
real(default), dimension(:,:), intent(out) :: x
real(default), dimension(:), intent(out) :: f
val = sampler%integrand
x = sampler%x
f = sampler%f
end subroutine test_sampler_fetch
@ %def test_sampler_fetch
@
\subsubsection{Test results object}
This mock object just stores and displays the current result.
<<MCI base: test types>>=
type, extends (mci_results_t) :: mci_test_results_t
integer :: n_it = 0
integer :: n_calls = 0
real(default) :: integral = 0
real(default) :: error = 0
real(default) :: efficiency = 0
contains
<<MCI base: mci test results: TBP>>
end type mci_test_results_t
@ %def mci_test_results_t
@ Output.
<<MCI base: mci test results: TBP>>=
procedure :: write => mci_test_results_write
procedure :: write_verbose => mci_test_results_write_verbose
<<MCI base: tests>>=
subroutine mci_test_results_write (object, unit, suppress)
class(mci_test_results_t), intent(in) :: object
integer, intent(in), optional :: unit
logical, intent(in), optional :: suppress
integer :: u
u = given_output_unit (unit)
write (u, "(3x,A,1x,I0)") "Iterations = ", object%n_it
write (u, "(3x,A,1x,I0)") "Calls = ", object%n_calls
write (u, "(3x,A,1x,F12.10)") "Integral = ", object%integral
write (u, "(3x,A,1x,F12.10)") "Error = ", object%error
write (u, "(3x,A,1x,F12.10)") "Efficiency = ", object%efficiency
end subroutine mci_test_results_write
subroutine mci_test_results_write_verbose (object, unit)
class(mci_test_results_t), intent(in) :: object
integer, intent(in), optional :: unit
integer :: u
u = given_output_unit (unit)
write (u, "(3x,A,1x,I0)") "Iterations = ", object%n_it
write (u, "(3x,A,1x,I0)") "Calls = ", object%n_calls
write (u, "(3x,A,1x,F12.10)") "Integral = ", object%integral
write (u, "(3x,A,1x,F12.10)") "Error = ", object%error
write (u, "(3x,A,1x,F12.10)") "Efficiency = ", object%efficiency
end subroutine mci_test_results_write_verbose
@ %def mci_test_results_write
@ Record result.
<<MCI base: mci test results: TBP>>=
procedure :: record_simple => mci_test_results_record_simple
procedure :: record_extended => mci_test_results_record_extended
<<MCI base: tests>>=
subroutine mci_test_results_record_simple (object, n_it, n_calls, &
integral, error, efficiency, chain_weights, suppress)
class(mci_test_results_t), intent(inout) :: object
integer, intent(in) :: n_it
integer, intent(in) :: n_calls
real(default), intent(in) :: integral
real(default), intent(in) :: error
real(default), intent(in) :: efficiency
real(default), dimension(:), intent(in), optional :: chain_weights
logical, intent(in), optional :: suppress
object%n_it = n_it
object%n_calls = n_calls
object%integral = integral
object%error = error
object%efficiency = efficiency
end subroutine mci_test_results_record_simple
subroutine mci_test_results_record_extended (object, n_it, n_calls, &
& n_calls_valid, integral, error, efficiency, efficiency_pos, &
& efficiency_neg, chain_weights, suppress)
class(mci_test_results_t), intent(inout) :: object
integer, intent(in) :: n_it
integer, intent(in) :: n_calls
integer, intent(in) :: n_calls_valid
real(default), intent(in) :: integral
real(default), intent(in) :: error
real(default), intent(in) :: efficiency
real(default), intent(in) :: efficiency_pos
real(default), intent(in) :: efficiency_neg
real(default), dimension(:), intent(in), optional :: chain_weights
logical, intent(in), optional :: suppress
object%n_it = n_it
object%n_calls = n_calls
object%integral = integral
object%error = error
object%efficiency = efficiency
end subroutine mci_test_results_record_extended
@ %def mci_test_results_record
@
\subsubsection{Integrator configuration data}
Construct and display a test integrator configuration object.
<<MCI base: execute tests>>=
call test (mci_base_1, "mci_base_1", &
"integrator configuration", &
u, results)
<<MCI base: test declarations>>=
public :: mci_base_1
<<MCI base: tests>>=
subroutine mci_base_1 (u)
integer, intent(in) :: u
class(mci_t), allocatable, target :: mci
class(mci_instance_t), pointer :: mci_instance => null ()
class(mci_sampler_t), allocatable :: sampler
real(default) :: integrand
write (u, "(A)") "* Test output: mci_base_1"
write (u, "(A)") "* Purpose: initialize and display &
&test integrator"
write (u, "(A)")
write (u, "(A)") "* Initialize integrator"
write (u, "(A)")
allocate (mci_test_t :: mci)
call mci%set_dimensions (2, 2)
call mci%write (u)
write (u, "(A)")
write (u, "(A)") "* Initialize instance"
write (u, "(A)")
call mci%allocate_instance (mci_instance)
call mci_instance%init (mci)
write (u, "(A)") "* Initialize test sampler"
write (u, "(A)")
allocate (test_sampler_t :: sampler)
select type (sampler)
type is (test_sampler_t)
call sampler%init (2)
end select
write (u, "(A)") "* Evaluate sampler for given point and channel"
write (u, "(A)")
call sampler%evaluate (1, [0.25_default, 0.8_default], &
integrand, mci_instance%x, mci_instance%f)
call sampler%write (u)
write (u, "(A)")
write (u, "(A)") "* Compute MCI weight"
write (u, "(A)")
call mci_instance%compute_weight (1)
call mci_instance%write (u)
write (u, "(A)")
write (u, "(A)") "* Get integrand and compute weight for another point"
write (u, "(A)")
call mci_instance%evaluate (sampler, 2, [0.5_default, 0.6_default])
call mci_instance%write (u)
write (u, "(A)")
write (u, "(A)") "* Recall results, again"
write (u, "(A)")
call mci_instance%final ()
deallocate (mci_instance)
call mci%allocate_instance (mci_instance)
call mci_instance%init (mci)
call mci_instance%fetch (sampler, 2)
call mci_instance%write (u)
write (u, "(A)")
write (u, "(A)") "* Retrieve value"
write (u, "(A)")
write (u, "(1x,A,ES13.7)") "Weighted integrand = ", &
mci_instance%get_value ()
call mci_instance%final ()
call mci%final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: mci_base_1"
end subroutine mci_base_1
@ %def mci_base_1
@
\subsubsection{Trivial integral}
Use the MCI approach to compute a trivial one-dimensional integral.
<<MCI base: execute tests>>=
call test (mci_base_2, "mci_base_2", &
"integration", &
u, results)
<<MCI base: test declarations>>=
public :: mci_base_2
<<MCI base: tests>>=
subroutine mci_base_2 (u)
integer, intent(in) :: u
class(mci_t), allocatable, target :: mci
class(mci_instance_t), pointer :: mci_instance => null ()
class(mci_sampler_t), allocatable :: sampler
write (u, "(A)") "* Test output: mci_base_2"
write (u, "(A)") "* Purpose: perform a test integral"
write (u, "(A)")
write (u, "(A)") "* Initialize integrator"
write (u, "(A)")
allocate (mci_test_t :: mci)
call mci%set_dimensions (1, 1)
select type (mci)
type is (mci_test_t)
call mci%set_divisions (10)
end select
call mci%write (u)
write (u, "(A)")
write (u, "(A)") "* Initialize instance"
write (u, "(A)")
call mci%allocate_instance (mci_instance)
call mci_instance%init (mci)
write (u, "(A)") "* Initialize test sampler"
write (u, "(A)")
allocate (test_sampler_t :: sampler)
select type (sampler)
type is (test_sampler_t)
call sampler%init (1)
end select
write (u, "(A)") "* Integrate"
write (u, "(A)")
call mci%integrate (mci_instance, sampler, 0, 0)
call mci%write (u)
call mci_instance%final ()
call mci%final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: mci_base_2"
end subroutine mci_base_2
@ %def mci_base_2
@
\subsubsection{Nontrivial integral}
Use the MCI approach to compute a simple two-dimensional integral with
two channels.
<<MCI base: execute tests>>=
call test (mci_base_3, "mci_base_3", &
"integration (two channels)", &
u, results)
<<MCI base: test declarations>>=
public :: mci_base_3
<<MCI base: tests>>=
subroutine mci_base_3 (u)
integer, intent(in) :: u
class(mci_t), allocatable, target :: mci
class(mci_instance_t), pointer :: mci_instance => null ()
class(mci_sampler_t), allocatable :: sampler
write (u, "(A)") "* Test output: mci_base_3"
write (u, "(A)") "* Purpose: perform a nontrivial test integral"
write (u, "(A)")
write (u, "(A)") "* Initialize integrator"
write (u, "(A)")
allocate (mci_test_t :: mci)
call mci%set_dimensions (2, 2)
select type (mci)
type is (mci_test_t)
call mci%set_divisions (10)
end select
write (u, "(A)") "* Initialize instance"
write (u, "(A)")
call mci%allocate_instance (mci_instance)
call mci_instance%init (mci)
write (u, "(A)") "* Initialize test sampler"
write (u, "(A)")
allocate (test_sampler_t :: sampler)
select type (sampler)
type is (test_sampler_t)
call sampler%init (2)
end select
write (u, "(A)") "* Integrate"
write (u, "(A)")
call mci%integrate (mci_instance, sampler, 0, 0)
call mci%write (u)
write (u, "(A)")
write (u, "(A)") "* Integrate with higher resolution"
write (u, "(A)")
select type (mci)
type is (mci_test_t)
call mci%set_divisions (100)
end select
call mci%integrate (mci_instance, sampler, 0, 0)
call mci%write (u)
call mci_instance%final ()
call mci%final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: mci_base_3"
end subroutine mci_base_3
@ %def mci_base_3
@
\subsubsection{Event generation}
We generate ``random'' events, one weighted and one unweighted. The
test implementation does not require an integration pass, we can
generate events immediately.
<<MCI base: execute tests>>=
call test (mci_base_4, "mci_base_4", &
"event generation (two channels)", &
u, results)
<<MCI base: test declarations>>=
public :: mci_base_4
<<MCI base: tests>>=
subroutine mci_base_4 (u)
integer, intent(in) :: u
class(mci_t), allocatable, target :: mci
class(mci_instance_t), pointer :: mci_instance => null ()
class(mci_sampler_t), allocatable :: sampler
class(rng_t), allocatable :: rng
write (u, "(A)") "* Test output: mci_base_4"
write (u, "(A)") "* Purpose: generate events"
write (u, "(A)")
write (u, "(A)") "* Initialize integrator, instance, sampler"
write (u, "(A)")
allocate (mci_test_t :: mci)
call mci%set_dimensions (2, 2)
select type (mci)
type is (mci_test_t)
call mci%set_divisions (10)
end select
call mci%allocate_instance (mci_instance)
call mci_instance%init (mci)
allocate (test_sampler_t :: sampler)
select type (sampler)
type is (test_sampler_t)
call sampler%init (2)
end select
allocate (rng_test_t :: rng)
call mci%import_rng (rng)
write (u, "(A)") "* Generate weighted event"
write (u, "(A)")
call mci%generate_weighted_event (mci_instance, sampler)
call sampler%write (u)
write (u, *)
call mci_instance%write (u)
write (u, "(A)")
write (u, "(A)") "* Generate unweighted event"
write (u, "(A)")
call mci%generate_unweighted_event (mci_instance, sampler)
select type (mci)
type is (mci_test_t)
write (u, "(A,I0)") " Success in try ", mci%tries
write (u, "(A)")
end select
call sampler%write (u)
write (u, *)
call mci_instance%write (u)
call mci_instance%final ()
call mci%final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: mci_base_4"
end subroutine mci_base_4
@ %def mci_base_4
@
\subsubsection{Store and recall data}
We generate an event and store the relevant data, i.e., the input
parameters and the result value for a particular channel. Then we use
those data to recover the event, as far as the MCI record is concerned.
<<MCI base: execute tests>>=
call test (mci_base_5, "mci_base_5", &
"store and recall", &
u, results)
<<MCI base: test declarations>>=
public :: mci_base_5
<<MCI base: tests>>=
subroutine mci_base_5 (u)
integer, intent(in) :: u
class(mci_t), allocatable, target :: mci
class(mci_instance_t), pointer :: mci_instance => null ()
class(mci_sampler_t), allocatable :: sampler
class(rng_t), allocatable :: rng
class(mci_state_t), allocatable :: state
write (u, "(A)") "* Test output: mci_base_5"
write (u, "(A)") "* Purpose: store and recall an event"
write (u, "(A)")
write (u, "(A)") "* Initialize integrator, instance, sampler"
write (u, "(A)")
allocate (mci_test_t :: mci)
call mci%set_dimensions (2, 2)
select type (mci)
type is (mci_test_t)
call mci%set_divisions (10)
end select
call mci%allocate_instance (mci_instance)
call mci_instance%init (mci)
allocate (test_sampler_t :: sampler)
select type (sampler)
type is (test_sampler_t)
call sampler%init (2)
end select
allocate (rng_test_t :: rng)
call mci%import_rng (rng)
write (u, "(A)") "* Generate weighted event"
write (u, "(A)")
call mci%generate_weighted_event (mci_instance, sampler)
call sampler%write (u)
write (u, *)
call mci_instance%write (u)
write (u, "(A)")
write (u, "(A)") "* Store data"
write (u, "(A)")
allocate (state)
call mci_instance%store (state)
call mci_instance%final ()
deallocate (mci_instance)
call state%write (u)
write (u, "(A)")
write (u, "(A)") "* Recall data and rebuild event"
write (u, "(A)")
call mci%allocate_instance (mci_instance)
call mci_instance%init (mci)
call mci%rebuild_event (mci_instance, sampler, state)
call sampler%write (u)
write (u, *)
call mci_instance%write (u)
call mci_instance%final ()
call mci%final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: mci_base_5"
end subroutine mci_base_5
@ %def mci_base_5
@
\subsubsection{Chained channels}
Chain channels together. In the base configuration, this just fills entries
in an extra array (each channel may belong to a chain). In type
implementations, this will be used for grouping equivalent channels by keeping
their weights equal.
<<MCI base: execute tests>>=
call test (mci_base_6, "mci_base_6", &
"chained channels", &
u, results)
<<MCI base: test declarations>>=
public :: mci_base_6
<<MCI base: tests>>=
subroutine mci_base_6 (u)
integer, intent(in) :: u
class(mci_t), allocatable, target :: mci
write (u, "(A)") "* Test output: mci_base_6"
write (u, "(A)") "* Purpose: initialize and display &
&test integrator with chains"
write (u, "(A)")
write (u, "(A)") "* Initialize integrator"
write (u, "(A)")
allocate (mci_test_t :: mci)
call mci%set_dimensions (1, 5)
write (u, "(A)") "* Introduce chains"
write (u, "(A)")
call mci%declare_chains ([1, 2, 2, 1, 2])
call mci%write (u)
call mci%final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: mci_base_6"
end subroutine mci_base_6
@ %def mci_base_6
@
\subsubsection{Recording results}
Compute a simple two-dimensional integral and record the result.
<<MCI base: execute tests>>=
call test (mci_base_7, "mci_base_7", &
"recording results", &
u, results)
<<MCI base: test declarations>>=
public :: mci_base_7
<<MCI base: tests>>=
subroutine mci_base_7 (u)
integer, intent(in) :: u
class(mci_t), allocatable, target :: mci
class(mci_instance_t), pointer :: mci_instance => null ()
class(mci_sampler_t), allocatable :: sampler
class(mci_results_t), allocatable :: results
write (u, "(A)") "* Test output: mci_base_7"
write (u, "(A)") "* Purpose: perform a nontrivial test integral &
&and record results"
write (u, "(A)")
write (u, "(A)") "* Initialize integrator"
write (u, "(A)")
allocate (mci_test_t :: mci)
call mci%set_dimensions (2, 2)
select type (mci)
type is (mci_test_t)
call mci%set_divisions (10)
end select
write (u, "(A)") "* Initialize instance"
write (u, "(A)")
call mci%allocate_instance (mci_instance)
call mci_instance%init (mci)
write (u, "(A)") "* Initialize test sampler"
write (u, "(A)")
allocate (test_sampler_t :: sampler)
select type (sampler)
type is (test_sampler_t)
call sampler%init (2)
end select
allocate (mci_test_results_t :: results)
write (u, "(A)") "* Integrate"
write (u, "(A)")
call mci%integrate (mci_instance, sampler, 1, 1000, results)
call mci%write (u)
write (u, "(A)")
write (u, "(A)") "* Display results"
write (u, "(A)")
call results%write (u)
call mci_instance%final ()
call mci%final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: mci_base_7"
end subroutine mci_base_7
@ %def mci_base_7
@
\subsubsection{Timer}
Simple checks for the embedded timer.
<<MCI base: execute tests>>=
call test (mci_base_8, "mci_base_8", &
"timer", &
u, results)
<<MCI base: test declarations>>=
public :: mci_base_8
<<MCI base: tests>>=
subroutine mci_base_8 (u)
integer, intent(in) :: u
class(mci_t), allocatable, target :: mci
real(default) :: dummy
write (u, "(A)") "* Test output: mci_base_8"
write (u, "(A)") "* Purpose: check timer availability"
write (u, "(A)")
write (u, "(A)") "* Initialize integrator with timer"
write (u, "(A)")
allocate (mci_test_t :: mci)
call mci%set_dimensions (2, 2)
select type (mci)
type is (mci_test_t)
call mci%set_divisions (10)
end select
call mci%set_timer (active = .true.)
call mci%write (u)
write (u, "(A)")
write (u, "(A)") "* Start timer"
write (u, "(A)")
call mci%start_timer ()
call mci%write (u)
write (u, "(A)")
write (u, "(A)") "* Stop timer"
write (u, "(A)")
call mci%stop_timer ()
write (u, "(A)") " (ok)"
write (u, "(A)")
write (u, "(A)") "* Readout"
write (u, "(A)")
dummy = mci%get_time ()
write (u, "(A)") " (ok)"
write (u, "(A)")
write (u, "(A)") "* Deactivate timer"
write (u, "(A)")
call mci%set_timer (active = .false.)
call mci%write (u)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call mci%final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: mci_base_8"
end subroutine mci_base_8
@ %def mci_base_8
@
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{Iterations}
This module defines a container for the list of iterations and calls, to be
submitted to integration.
<<[[iterations.f90]]>>=
<<File header>>
module iterations
<<Use kinds>>
<<Use strings>>
use io_units
use diagnostics
<<Standard module head>>
<<Iterations: public>>
<<Iterations: types>>
contains
<<Iterations: procedures>>
end module iterations
@ %def iterations
@
\subsection{The iterations list}
Each integration pass has a number of iterations and a number of calls
per iteration. The last pass produces the end result; the previous
passes are used for adaptation.
The flags [[adapt_grid]] and [[adapt_weight]] are used only if
[[custom_adaptation]] is set. Otherwise, default settings are used
that depend on the integration pass.
<<Iterations: types>>=
type :: iterations_spec_t
private
integer :: n_it = 0
integer :: n_calls = 0
logical :: custom_adaptation = .false.
logical :: adapt_grids = .false.
logical :: adapt_weights = .false.
end type iterations_spec_t
@ %def iterations_spec_t
@ We build up a list of iterations.
<<Iterations: public>>=
public :: iterations_list_t
<<Iterations: types>>=
type :: iterations_list_t
private
integer :: n_pass = 0
type(iterations_spec_t), dimension(:), allocatable :: pass
contains
<<Iterations: iterations list: TBP>>
end type iterations_list_t
@ %def iterations_list_t
@ Initialize an iterations list. For each pass, we have to specify
the number of iterations and calls. We may provide the adaption
conventions explicitly, either as character codes or as logicals.
For passes where the adaptation conventions are not specified, we use
the following default setting: adapt weights and grids for all passes
except the last one.
<<Iterations: iterations list: TBP>>=
procedure :: init => iterations_list_init
<<Iterations: procedures>>=
subroutine iterations_list_init &
(it_list, n_it, n_calls, adapt, adapt_code, adapt_grids, adapt_weights)
class(iterations_list_t), intent(inout) :: it_list
integer, dimension(:), intent(in) :: n_it, n_calls
logical, dimension(:), intent(in), optional :: adapt
type(string_t), dimension(:), intent(in), optional :: adapt_code
logical, dimension(:), intent(in), optional :: adapt_grids, adapt_weights
integer :: i
it_list%n_pass = size (n_it)
if (allocated (it_list%pass)) deallocate (it_list%pass)
allocate (it_list%pass (it_list%n_pass))
it_list%pass%n_it = n_it
it_list%pass%n_calls = n_calls
if (present (adapt)) then
it_list%pass%custom_adaptation = adapt
do i = 1, it_list%n_pass
if (adapt(i)) then
if (verify (adapt_code(i), "wg") /= 0) then
call msg_error ("iteration specification: " &
// "adaptation code letters must be 'w' or 'g'")
end if
it_list%pass(i)%adapt_grids = scan (adapt_code(i), "g") /= 0
it_list%pass(i)%adapt_weights = scan (adapt_code(i), "w") /= 0
end if
end do
else if (present (adapt_grids) .and. present (adapt_weights)) then
it_list%pass%custom_adaptation = .true.
it_list%pass%adapt_grids = adapt_grids
it_list%pass%adapt_weights = adapt_weights
end if
do i = 1, it_list%n_pass - 1
if (.not. it_list%pass(i)%custom_adaptation) then
it_list%pass(i)%adapt_grids = .true.
it_list%pass(i)%adapt_weights = .true.
end if
end do
end subroutine iterations_list_init
@ %def iterations_list_init
<<Iterations: iterations list: TBP>>=
procedure :: clear => iterations_list_clear
<<Iterations: procedures>>=
subroutine iterations_list_clear (it_list)
class(iterations_list_t), intent(inout) :: it_list
it_list%n_pass = 0
deallocate (it_list%pass)
end subroutine iterations_list_clear
@ %def iterations_list_clear
@ Write the list of iterations.
<<Iterations: iterations list: TBP>>=
procedure :: write => iterations_list_write
<<Iterations: procedures>>=
subroutine iterations_list_write (it_list, unit)
class(iterations_list_t), intent(in) :: it_list
integer, intent(in), optional :: unit
integer :: u
u = given_output_unit (unit)
write (u, "(A)") char (it_list%to_string ())
end subroutine iterations_list_write
@ %def iterations_list_write
@ The output as a single-line string.
<<Iterations: iterations list: TBP>>=
procedure :: to_string => iterations_list_to_string
<<Iterations: procedures>>=
function iterations_list_to_string (it_list) result (buffer)
class(iterations_list_t), intent(in) :: it_list
type(string_t) :: buffer
character(30) :: ibuf
integer :: i
buffer = "iterations = "
if (it_list%n_pass > 0) then
do i = 1, it_list%n_pass
if (i > 1) buffer = buffer // ", "
write (ibuf, "(I0,':',I0)") &
it_list%pass(i)%n_it, it_list%pass(i)%n_calls
buffer = buffer // trim (ibuf)
if (it_list%pass(i)%custom_adaptation &
.or. it_list%pass(i)%adapt_grids &
.or. it_list%pass(i)%adapt_weights) then
buffer = buffer // ':"'
if (it_list%pass(i)%adapt_grids) buffer = buffer // "g"
if (it_list%pass(i)%adapt_weights) buffer = buffer // "w"
buffer = buffer // '"'
end if
end do
else
buffer = buffer // "[undefined]"
end if
end function iterations_list_to_string
@ %def iterations_list_to_string
@
\subsection{Tools}
Return the total number of passes.
<<Iterations: iterations list: TBP>>=
procedure :: get_n_pass => iterations_list_get_n_pass
<<Iterations: procedures>>=
function iterations_list_get_n_pass (it_list) result (n_pass)
class(iterations_list_t), intent(in) :: it_list
integer :: n_pass
n_pass = it_list%n_pass
end function iterations_list_get_n_pass
@ %def iterations_list_get_n_pass
@ Return the number of calls for a specific pass.
<<Iterations: iterations list: TBP>>=
procedure :: get_n_calls => iterations_list_get_n_calls
<<Iterations: procedures>>=
function iterations_list_get_n_calls (it_list, pass) result (n_calls)
class(iterations_list_t), intent(in) :: it_list
integer :: n_calls
integer, intent(in) :: pass
if (pass <= it_list%n_pass) then
n_calls = it_list%pass(pass)%n_calls
else
n_calls = 0
end if
end function iterations_list_get_n_calls
@ %def iterations_list_get_n_calls
@
<<Iterations: iterations list: TBP>>=
procedure :: set_n_calls => iterations_list_set_n_calls
<<Iterations: procedures>>=
subroutine iterations_list_set_n_calls (it_list, pass, n_calls)
class(iterations_list_t), intent(inout) :: it_list
integer, intent(in) :: pass, n_calls
it_list%pass(pass)%n_calls = n_calls
end subroutine iterations_list_set_n_calls
@ %def iterations_list_set_n_calls
@ Get the adaptation mode (automatic/custom) and, for custom adaptation, the
flags for a specific pass.
<<Iterations: iterations list: TBP>>=
procedure :: adapt_grids => iterations_list_adapt_grids
procedure :: adapt_weights => iterations_list_adapt_weights
<<Iterations: procedures>>=
function iterations_list_adapt_grids (it_list, pass) result (flag)
logical :: flag
class(iterations_list_t), intent(in) :: it_list
integer, intent(in) :: pass
if (pass <= it_list%n_pass) then
flag = it_list%pass(pass)%adapt_grids
else
flag = .false.
end if
end function iterations_list_adapt_grids
function iterations_list_adapt_weights (it_list, pass) result (flag)
logical :: flag
class(iterations_list_t), intent(in) :: it_list
integer, intent(in) :: pass
if (pass <= it_list%n_pass) then
flag = it_list%pass(pass)%adapt_weights
else
flag = .false.
end if
end function iterations_list_adapt_weights
@ %def iterations_list_has_custom_adaptation
@ %def iterations_list_adapt_grids
@ %def iterations_list_adapt_weights
@ Return the total number of iterations / the iterations for a specific pass.
<<Iterations: iterations list: TBP>>=
procedure :: get_n_it => iterations_list_get_n_it
<<Iterations: procedures>>=
function iterations_list_get_n_it (it_list, pass) result (n_it)
class(iterations_list_t), intent(in) :: it_list
integer :: n_it
integer, intent(in) :: pass
if (pass <= it_list%n_pass) then
n_it = it_list%pass(pass)%n_it
else
n_it = 0
end if
end function iterations_list_get_n_it
@ %def iterations_list_get_n_it
@
\subsection{Iteration Multipliers}
<<Iterations: public>>=
public :: iteration_multipliers_t
<<Iterations: types>>=
type :: iteration_multipliers_t
real(default) :: mult_real = 1._default
real(default) :: mult_virt = 1._default
real(default) :: mult_dglap = 1._default
real(default) :: mult_threshold = 1._default
integer, dimension(:), allocatable :: n_calls0
end type iteration_multipliers_t
@ %def iterations_multipliers
@
\subsection{Unit tests}
Test module, followed by the corresponding implementation module.
<<[[iterations_ut.f90]]>>=
<<File header>>
module iterations_ut
use unit_tests
use iterations_uti
<<Standard module head>>
<<Iterations: public test>>
contains
<<Iterations: test driver>>
end module iterations_ut
@ %def iterations_ut
@
<<[[iterations_uti.f90]]>>=
<<File header>>
module iterations_uti
<<Use strings>>
use iterations
<<Standard module head>>
<<Iterations: test declarations>>
contains
<<Iterations: tests>>
end module iterations_uti
@ %def iterations_ut
@ API: driver for the unit tests below.
<<Iterations: public test>>=
public :: iterations_test
<<Iterations: test driver>>=
subroutine iterations_test (u, results)
integer, intent(in) :: u
type(test_results_t), intent(inout) :: results
<<Iterations: execute tests>>
end subroutine iterations_test
@ %def iterations_test
@
\subsubsection{Empty list}
<<Iterations: execute tests>>=
call test (iterations_1, "iterations_1", &
"empty iterations list", &
u, results)
<<Iterations: test declarations>>=
public :: iterations_1
<<Iterations: tests>>=
subroutine iterations_1 (u)
integer, intent(in) :: u
type(iterations_list_t) :: it_list
write (u, "(A)") "* Test output: iterations_1"
write (u, "(A)") "* Purpose: display empty iterations list"
write (u, "(A)")
call it_list%write (u)
write (u, "(A)")
write (u, "(A)") "* Test output end: iterations_1"
end subroutine iterations_1
@ %def iterations_1
@
\subsubsection{Fill list}
<<Iterations: execute tests>>=
call test (iterations_2, "iterations_2", &
"create iterations list", &
u, results)
<<Iterations: test declarations>>=
public :: iterations_2
<<Iterations: tests>>=
subroutine iterations_2 (u)
integer, intent(in) :: u
type(iterations_list_t) :: it_list
write (u, "(A)") "* Test output: iterations_2"
write (u, "(A)") "* Purpose: fill and display iterations list"
write (u, "(A)")
write (u, "(A)") "* Minimal setup (2 passes)"
write (u, "(A)")
call it_list%init ([2, 4], [5000, 20000])
call it_list%write (u)
call it_list%clear ()
write (u, "(A)")
write (u, "(A)") "* Setup with flags (3 passes)"
write (u, "(A)")
call it_list%init ([2, 4, 5], [5000, 20000, 400], &
[.false., .true., .true.], &
[var_str (""), var_str ("g"), var_str ("wg")])
call it_list%write (u)
write (u, "(A)")
write (u, "(A)") "* Extract data"
write (u, "(A)")
write (u, "(A,I0)") "n_pass = ", it_list%get_n_pass ()
write (u, "(A)")
write (u, "(A,I0)") "n_calls(2) = ", it_list%get_n_calls (2)
write (u, "(A)")
write (u, "(A,I0)") "n_it(3) = ", it_list%get_n_it (3)
write (u, "(A)")
write (u, "(A)") "* Test output end: iterations_2"
end subroutine iterations_2
@ %def iterations_2
@
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{Integration results}
We record integration results and errors in a dedicated type. This
allows us to do further statistics such as weighted average,
chi-squared, grouping by integration passes, etc.
Note WHIZARD 2.2.0: This code is taken from the previous [[processes]]
module essentially unchanged and converted into a separate module. It
lacks an overhaul and, in particular, self-tests.
<<[[integration_results.f90]]>>=
module integration_results
<<Use kinds>>
<<Use strings>>
use io_units
use format_utils, only: mp_format, pac_fmt
use format_defs, only: FMT_10, FMT_14
use diagnostics
use md5
use os_interface
use mci_base
<<Standard module head>>
<<Integration results: public>>
<<Integration results: parameters>>
<<Integration results: types>>
<<Integration results: interfaces>>
contains
<<Integration results: procedures>>
end module integration_results
@ %def integration_results
@
\subsection{Integration results entry}
This object collects the results of an integration pass and makes them
available to the outside.
The results object has to distinguish the process type:
We store the process type, the index of the integration pass and the
absolute iteration index, the number of iterations contained in this
result (for averages), and the integral (cross section or partial
width), error estimate, efficiency.
For intermediate results, we set a flag if this result is an
improvement w.r.t. previous ones.
The process type indicates decay or scattering. Dummy entries
(skipped iterations) have a process type of [[PRC_UNKNOWN]].
The additional information [[n_calls_valid]], [[efficiency_pos]] and
[[efficiency_neg]] are stored, but only used in verbose mode.
<<Integration results: public>>=
public :: integration_entry_t
<<Integration results: types>>=
type :: integration_entry_t
private
integer :: process_type = PRC_UNKNOWN
integer :: pass = 0
integer :: it = 0
integer :: n_it = 0
integer :: n_calls = 0
integer :: n_calls_valid = 0
logical :: improved = .false.
real(default) :: integral = 0
real(default) :: error = 0
real(default) :: efficiency = 0
real(default) :: efficiency_pos = 0
real(default) :: efficiency_neg = 0
real(default) :: chi2 = 0
real(default), dimension(:), allocatable :: chain_weights
contains
<<Integration results: integration entry: TBP>>
end type integration_entry_t
@ %def integration_result_t
@
The possible values of the type indicator:
<<Integration results: parameters>>=
integer, parameter, public :: PRC_UNKNOWN = 0
integer, parameter, public :: PRC_DECAY = 1
integer, parameter, public :: PRC_SCATTERING = 2
@ %def PRC_UNKNOWN PRC_DECAY PRC_SCATTERING
@ Initialize with all relevant data.
<<Integration results: interfaces>>=
interface integration_entry_t
module procedure integration_entry_init
end interface integration_entry_t
<<Integration results: procedures>>=
type(integration_entry_t) function integration_entry_init (process_type, pass,&
& it, n_it, n_calls, n_calls_valid, improved, integral, error,&
& efficiency, efficiency_pos, efficiency_neg, chi2, chain_weights)&
& result (entry)
integer, intent(in) :: process_type, pass, it, n_it, n_calls, n_calls_valid
logical, intent(in) :: improved
real(default), intent(in) :: integral, error, efficiency, efficiency_pos, efficiency_neg
real(default), intent(in), optional :: chi2
real(default), dimension(:), intent(in), optional :: chain_weights
entry%process_type = process_type
entry%pass = pass
entry%it = it
entry%n_it = n_it
entry%n_calls = n_calls
entry%n_calls_valid = n_calls_valid
entry%improved = improved
entry%integral = integral
entry%error = error
entry%efficiency = efficiency
entry%efficiency_pos = efficiency_pos
entry%efficiency_neg = efficiency_neg
if (present (chi2)) entry%chi2 = chi2
if (present (chain_weights)) then
allocate (entry%chain_weights (size (chain_weights)))
entry%chain_weights = chain_weights
end if
end function integration_entry_init
@ %def integration_entry_init
@ Access values, some of them computed on demand:
<<Integration results: integration entry: TBP>>=
procedure :: get_pass => integration_entry_get_pass
procedure :: get_n_calls => integration_entry_get_n_calls
procedure :: get_n_calls_valid => integration_entry_get_n_calls_valid
procedure :: get_integral => integration_entry_get_integral
procedure :: get_error => integration_entry_get_error
procedure :: get_rel_error => integration_entry_get_relative_error
procedure :: get_accuracy => integration_entry_get_accuracy
procedure :: get_efficiency => integration_entry_get_efficiency
procedure :: get_efficiency_pos => integration_entry_get_efficiency_pos
procedure :: get_efficiency_neg => integration_entry_get_efficiency_neg
procedure :: get_chi2 => integration_entry_get_chi2
procedure :: has_improved => integration_entry_has_improved
procedure :: get_n_groves => integration_entry_get_n_groves
<<Integration results: procedures>>=
elemental function integration_entry_get_pass (entry) result (n)
integer :: n
class(integration_entry_t), intent(in) :: entry
n = entry%pass
end function integration_entry_get_pass
elemental function integration_entry_get_n_calls (entry) result (n)
integer :: n
class(integration_entry_t), intent(in) :: entry
n = entry%n_calls
end function integration_entry_get_n_calls
elemental function integration_entry_get_n_calls_valid (entry) result (n)
integer :: n
class(integration_entry_t), intent(in) :: entry
n = entry%n_calls_valid
end function integration_entry_get_n_calls_valid
elemental function integration_entry_get_integral (entry) result (int)
real(default) :: int
class(integration_entry_t), intent(in) :: entry
int = entry%integral
end function integration_entry_get_integral
elemental function integration_entry_get_error (entry) result (err)
real(default) :: err
class(integration_entry_t), intent(in) :: entry
err = entry%error
end function integration_entry_get_error
elemental function integration_entry_get_relative_error (entry) result (err)
real(default) :: err
class(integration_entry_t), intent(in) :: entry
err = 0
if (entry%integral /= 0) then
err = entry%error / entry%integral
end if
end function integration_entry_get_relative_error
elemental function integration_entry_get_accuracy (entry) result (acc)
real(default) :: acc
class(integration_entry_t), intent(in) :: entry
acc = accuracy (entry%integral, entry%error, entry%n_calls)
end function integration_entry_get_accuracy
elemental function accuracy (integral, error, n_calls) result (acc)
real(default) :: acc
real(default), intent(in) :: integral, error
integer, intent(in) :: n_calls
acc = 0
if (integral /= 0) then
acc = error / integral * sqrt (real (n_calls, default))
end if
end function accuracy
elemental function integration_entry_get_efficiency (entry) result (eff)
real(default) :: eff
class(integration_entry_t), intent(in) :: entry
eff = entry%efficiency
end function integration_entry_get_efficiency
elemental function integration_entry_get_efficiency_pos (entry) result (eff)
real(default) :: eff
class(integration_entry_t), intent(in) :: entry
eff = entry%efficiency_pos
end function integration_entry_get_efficiency_pos
elemental function integration_entry_get_efficiency_neg (entry) result (eff)
real(default) :: eff
class(integration_entry_t), intent(in) :: entry
eff = entry%efficiency_neg
end function integration_entry_get_efficiency_neg
elemental function integration_entry_get_chi2 (entry) result (chi2)
real(default) :: chi2
class(integration_entry_t), intent(in) :: entry
chi2 = entry%chi2
end function integration_entry_get_chi2
elemental function integration_entry_has_improved (entry) result (flag)
logical :: flag
class(integration_entry_t), intent(in) :: entry
flag = entry%improved
end function integration_entry_has_improved
elemental function integration_entry_get_n_groves (entry) result (n_groves)
integer :: n_groves
class(integration_entry_t), intent(in) :: entry
n_groves = 0
if (allocated (entry%chain_weights)) then
n_groves = size (entry%chain_weights, 1)
end if
end function integration_entry_get_n_groves
@ %def integration_entry_get_pass
@ %def integration_entry_get_integral
@ %def integration_entry_get_error
@ %def integration_entry_get_relative_error
@ %def integration_entry_get_accuracy
@ %def accuracy
@ %def integration_entry_get_efficiency
@ %def integration_entry_get_chi2
@ %def integration_entry_has_improved
@ %def integration_entry_get_n_groves
@ This writes the standard result account into one screen line. The
verbose version uses multiple lines and prints the unabridged values.
Dummy entries are not written.
<<Integration results: integration entry: TBP>>=
procedure :: write => integration_entry_write
procedure :: write_verbose => integration_entry_write_verbose
<<Integration results: procedures>>=
subroutine integration_entry_write (entry, unit, verbosity, suppress)
class(integration_entry_t), intent(in) :: entry
integer, intent(in), optional :: unit
integer, intent(in), optional :: verbosity
logical, intent(in), optional :: suppress
integer :: u
character(1) :: star
character(12) :: fmt
character(7) :: fmt2
character(120) :: buffer
integer :: verb
logical :: supp
u = given_output_unit (unit); if (u < 0) return
verb = 0; if (present (verbosity)) verb = verbosity
supp = .false.; if (present (suppress)) supp = suppress
if (entry%process_type /= PRC_UNKNOWN) then
if (entry%improved .and. .not. supp) then
star = "*"
else
star = " "
end if
call pac_fmt (fmt, FMT_14, "3x," // FMT_10 // ",1x", suppress)
call pac_fmt (fmt2, "1x,F6.2", "2x,F5.1", suppress)
write (buffer, "(1x,I3,1x,I10)") entry%it, entry%n_calls
if (verb > 1) then
write (buffer, "(A,1x,I10)") trim (buffer), entry%n_calls_valid
end if
write (buffer, "(A,1x," // fmt // ",1x,ES9.2,1x,F7.2," // &
"1x,F7.2,A1," // fmt2 // ")") &
trim (buffer), &
entry%integral, &
abs(entry%error), &
abs(integration_entry_get_relative_error (entry)) * 100, &
abs(integration_entry_get_accuracy (entry)), &
star, &
entry%efficiency * 100
if (verb > 2) then
write (buffer, "(A,1X," // fmt2 // ",1X," // fmt2 // ")") &
trim (buffer), &
entry%efficiency_pos * 100, &
entry%efficiency_neg * 100
end if
if (entry%n_it /= 1) then
write (buffer, "(A,1x,F7.2,1x,I3)") &
trim (buffer), &
entry%chi2, &
entry%n_it
end if
write (u, "(A)") trim (buffer)
end if
flush (u)
end subroutine integration_entry_write
subroutine integration_entry_write_verbose (entry, unit)
class(integration_entry_t), intent(in) :: entry
integer, intent(in) :: unit
integer :: u
u = given_output_unit (unit); if (u < 0) return
write (u, *) " process_type = ", entry%process_type
write (u, *) " pass = ", entry%pass
write (u, *) " it = ", entry%it
write (u, *) " n_it = ", entry%n_it
write (u, *) " n_calls = ", entry%n_calls
write (u, *) " n_calls_valid = ", entry%n_calls_valid
write (u, *) " improved = ", entry%improved
write (u, *) " integral = ", entry%integral
write (u, *) " error = ", entry%error
write (u, *) " efficiency = ", entry%efficiency
write (u, *) "efficiency_pos = ", entry%efficiency_pos
write (u, *) "efficiency_neg = ", entry%efficiency_neg
write (u, *) " chi2 = ", entry%chi2
if (allocated (entry%chain_weights)) then
write (u, *) " n_groves = ", size (entry%chain_weights)
write (u, *) "chain_weights = ", entry%chain_weights
else
write (u, *) " n_groves = 0"
end if
flush (u)
end subroutine integration_entry_write_verbose
@ %def integration_entry_write
@ Read the entry, assuming it has been written in verbose format.
<<Integration results: integration entry: TBP>>=
procedure :: read => integration_entry_read
<<Integration results: procedures>>=
subroutine integration_entry_read (entry, unit)
class(integration_entry_t), intent(out) :: entry
integer, intent(in) :: unit
character(30) :: dummy
character :: equals
integer :: n_groves
read (unit, *) dummy, equals, entry%process_type
read (unit, *) dummy, equals, entry%pass
read (unit, *) dummy, equals, entry%it
read (unit, *) dummy, equals, entry%n_it
read (unit, *) dummy, equals, entry%n_calls
read (unit, *) dummy, equals, entry%n_calls_valid
read (unit, *) dummy, equals, entry%improved
read (unit, *) dummy, equals, entry%integral
read (unit, *) dummy, equals, entry%error
read (unit, *) dummy, equals, entry%efficiency
read (unit, *) dummy, equals, entry%efficiency_pos
read (unit, *) dummy, equals, entry%efficiency_neg
read (unit, *) dummy, equals, entry%chi2
read (unit, *) dummy, equals, n_groves
if (n_groves /= 0) then
allocate (entry%chain_weights (n_groves))
read (unit, *) dummy, equals, entry%chain_weights
end if
end subroutine integration_entry_read
@ %def integration_entry_read
@ Write an account of the channel weights, accumulated by groves.
<<Integration results: integration entry: TBP>>=
procedure :: write_chain_weights => integration_entry_write_chain_weights
<<Integration results: procedures>>=
subroutine integration_entry_write_chain_weights (entry, unit)
class(integration_entry_t), intent(in) :: entry
integer, intent(in), optional :: unit
integer :: u, i
u = given_output_unit (unit); if (u < 0) return
if (allocated (entry%chain_weights)) then
do i = 1, size (entry%chain_weights)
write (u, "(1x,I3)", advance="no") nint (entry%chain_weights(i) * 100)
end do
write (u, *)
end if
end subroutine integration_entry_write_chain_weights
@ %def integration_entry_write_chain_weights
@
\subsection{Combined integration results}
We collect a list of results which grows during the execution of the
program. This is implemented as an array which grows if necessary; so
we can easily compute averages.
We implement this as an extension of the [[mci_results_t]] which is
defined in [[mci_base]] as an abstract type. We thus decouple the
implementation of the integrator from the implementation of the
results display, but nevertheless can record intermediate results
during integration. This implies that the present extension
implements a [[record]] method.
<<Integration results: public>>=
public :: integration_results_t
<<Integration results: types>>=
type, extends (mci_results_t) :: integration_results_t
private
integer :: process_type = PRC_UNKNOWN
integer :: current_pass = 0
integer :: n_pass = 0
integer :: n_it = 0
logical :: screen = .false.
integer :: unit = 0
integer :: verbosity = 0
real(default) :: error_threshold = 0
type(integration_entry_t), dimension(:), allocatable :: entry
type(integration_entry_t), dimension(:), allocatable :: average
contains
<<Integration results: integration results: TBP>>
end type integration_results_t
@ %def integration_results_t
@ The array is extended in chunks of 10 entries.
<<Integration results: parameters>>=
integer, parameter :: RESULTS_CHUNK_SIZE = 10
@ %def RESULTS_CHUNK_SIZE
@
<<Integration results: integration results: TBP>>=
procedure :: init => integration_results_init
<<Integration results: procedures>>=
subroutine integration_results_init (results, process_type)
class(integration_results_t), intent(out) :: results
integer, intent(in) :: process_type
results%process_type = process_type
results%n_pass = 0
results%n_it = 0
allocate (results%entry (RESULTS_CHUNK_SIZE))
allocate (results%average (RESULTS_CHUNK_SIZE))
end subroutine integration_results_init
@ %def integration_results_init
@ Set verbose output of the integration results. In verbose mode, valid calls,
negative as positive efficiency will be printed.
<<Integration results: integration results: TBP>>=
procedure :: set_verbosity => integration_results_set_verbosity
<<Integration results: procedures>>=
subroutine integration_results_set_verbosity (results, verbosity)
class(integration_results_t), intent(inout) :: results
integer, intent(in) :: verbosity
results%verbosity = verbosity
end subroutine integration_results_set_verbosity
@ %def integration_results_set_verbose
@ Set additional parameters: the [[error_threshold]] declares that any error
value (in absolute numbers) smaller than this is to be considered zero.
<<Integration results: integration results: TBP>>=
procedure :: set_error_threshold => integration_results_set_error_threshold
<<Integration results: procedures>>=
subroutine integration_results_set_error_threshold (results, error_threshold)
class(integration_results_t), intent(inout) :: results
real(default), intent(in) :: error_threshold
results%error_threshold = error_threshold
end subroutine integration_results_set_error_threshold
@ %def integration_results_set_error_threshold
@ Output (ASCII format). The [[verbose]] format is used for writing
the header in grid files.
<<Integration results: integration results: TBP>>=
procedure :: write => integration_results_write
procedure :: write_verbose => integration_results_write_verbose
<<Integration results: procedures>>=
subroutine integration_results_write (object, unit, suppress)
class(integration_results_t), intent(in) :: object
integer, intent(in), optional :: unit
logical, intent(in), optional :: suppress
logical :: verb
integer :: u, n
u = given_output_unit (unit); if (u < 0) return
call object%write_dline (unit)
if (object%n_it /= 0) then
call object%write_header (unit, logfile = .false.)
call object%write_dline (unit)
do n = 1, object%n_it
if (n > 1) then
if (object%entry(n)%pass /= object%entry(n-1)%pass) then
call object%write_hline (unit)
call object%average(object%entry(n-1)%pass)%write ( &
& unit, suppress = suppress)
call object%write_hline (unit)
end if
end if
call object%entry(n)%write (unit, &
suppress = suppress)
end do
call object%write_hline(unit)
call object%average(object%n_pass)%write (unit, suppress = suppress)
else
call msg_message ("[WHIZARD integration results: empty]", unit)
end if
call object%write_dline (unit)
flush (u)
end subroutine integration_results_write
subroutine integration_results_write_verbose (object, unit)
class(integration_results_t), intent(in) :: object
integer, intent(in), optional :: unit
integer :: u, n
u = given_output_unit (unit); if (u < 0) return
write (u, *) "begin(integration_results)"
write (u, *) " n_pass = ", object%n_pass
write (u, *) " n_it = ", object%n_it
if (object%n_it > 0) then
write (u, *) "begin(integration_pass)"
do n = 1, object%n_it
if (n > 1) then
if (object%entry(n)%pass /= object%entry(n-1)%pass) then
write (u, *) "end(integration_pass)"
write (u, *) "begin(integration_pass)"
end if
end if
write (u, *) "begin(iteration)"
call object%entry(n)%write_verbose (unit)
write (u, *) "end(iteration)"
end do
write (u, *) "end(integration_pass)"
end if
write (u, *) "end(integration_results)"
flush (u)
end subroutine integration_results_write_verbose
@ %def integration_results_write integration_results_verbose
@ Write a concise table of chain weights, i.e., the channel history where
channels are collected by chains.
<<Integration results: integration results: TBP>>=
procedure :: write_chain_weights => &
integration_results_write_chain_weights
<<Integration results: procedures>>=
subroutine integration_results_write_chain_weights (results, unit)
class(integration_results_t), intent(in) :: results
integer, intent(in), optional :: unit
integer :: u, i, n
u = given_output_unit (unit); if (u < 0) return
if (allocated (results%entry(1)%chain_weights) .and. results%n_it /= 0) then
call msg_message ("Phase-space chain (grove) weight history: " &
// "(numbers in %)", unit)
write (u, "(A9)", advance="no") "| chain |"
do i = 1, integration_entry_get_n_groves (results%entry(1))
write (u, "(1x,I3)", advance="no") i
end do
write (u, *)
call results%write_dline (unit)
do n = 1, results%n_it
if (n > 1) then
if (results%entry(n)%pass /= results%entry(n-1)%pass) then
call results%write_hline (unit)
end if
end if
write (u, "(1x,I6,1x,A1)", advance="no") n, "|"
call results%entry(n)%write_chain_weights (unit)
end do
flush (u)
call results%write_dline(unit)
end if
end subroutine integration_results_write_chain_weights
@ %def integration_results_write_chain_weights
@ Read the list from file. The file must be written using the
[[verbose]] option of the writing routine.
<<Integration results: integration results: TBP>>=
procedure :: read => integration_results_read
<<Integration results: procedures>>=
subroutine integration_results_read (results, unit)
class(integration_results_t), intent(out) :: results
integer, intent(in) :: unit
character(80) :: buffer
character :: equals
integer :: pass, it
read (unit, *) buffer
if (trim (adjustl (buffer)) /= "begin(integration_results)") then
call read_err (); return
end if
read (unit, *) buffer, equals, results%n_pass
read (unit, *) buffer, equals, results%n_it
allocate (results%entry (results%n_it + RESULTS_CHUNK_SIZE))
allocate (results%average (results%n_it + RESULTS_CHUNK_SIZE))
it = 0
do pass = 1, results%n_pass
read (unit, *) buffer
if (trim (adjustl (buffer)) /= "begin(integration_pass)") then
call read_err (); return
end if
READ_ENTRIES: do
read (unit, *) buffer
if (trim (adjustl (buffer)) /= "begin(iteration)") then
exit READ_ENTRIES
end if
it = it + 1
call results%entry(it)%read (unit)
read (unit, *) buffer
if (trim (adjustl (buffer)) /= "end(iteration)") then
call read_err (); return
end if
end do READ_ENTRIES
if (trim (adjustl (buffer)) /= "end(integration_pass)") then
call read_err (); return
end if
results%average(pass) = compute_average (results%entry, pass)
end do
read (unit, *) buffer
if (trim (adjustl (buffer)) /= "end(integration_results)") then
call read_err (); return
end if
contains
subroutine read_err ()
call msg_fatal ("Reading integration results from file: syntax error")
end subroutine read_err
end subroutine integration_results_read
@ %def integration_results_read
@ Auxiliary output.
<<Integration results: integration results: TBP>>=
procedure, private :: write_header
procedure, private :: write_hline
procedure, private :: write_dline
<<Integration results: procedures>>=
subroutine write_header (results, unit, logfile)
class(integration_results_t), intent(in) :: results
integer, intent(in), optional :: unit
logical, intent(in), optional :: logfile
character(5) :: phys_unit
integer :: u
u = given_output_unit (unit); if (u < 0) return
select case (results%process_type)
case (PRC_DECAY); phys_unit = "[GeV]"
case (PRC_SCATTERING); phys_unit = "[fb] "
case default
phys_unit = " "
end select
write (msg_buffer, "(A, A)") &
"It Calls"
if (results%verbosity > 1) then
write (msg_buffer, "(A, A)") trim (msg_buffer), &
" Valid"
end if
write (msg_buffer, "(A, A)") trim (msg_buffer), &
" Integral" // phys_unit // &
" Error" // phys_unit // &
" Err[%] Acc Eff[%]"
if (results%verbosity > 2) then
write (msg_buffer, "(A, A)") trim (msg_buffer), &
" (+)[%] (-)[%]"
end if
write (msg_buffer, "(A, A)") trim (msg_buffer), &
" Chi2 N[It] |"
call msg_message (unit=u, logfile=logfile)
end subroutine write_header
subroutine write_hline (results, unit)
class(integration_results_t), intent(in) :: results
integer, intent(in), optional :: unit
integer :: u, len
u = given_output_unit (unit); if (u < 0) return
len = 77
if (results%verbosity > 1) len = len + 11
if (results%verbosity > 2) len = len + 16
write (u, "(A)") "|" // (repeat ("-", len)) // "|"
flush (u)
end subroutine write_hline
subroutine write_dline (results, unit)
class(integration_results_t), intent(in) :: results
integer, intent(in), optional :: unit
integer :: u, len
u = given_output_unit (unit); if (u < 0) return
len = 77
if (results%verbosity > 1) len = len + 11
if (results%verbosity > 2) len = len + 16
write (u, "(A)") "|" // (repeat ("=", len)) // "|"
flush (u)
end subroutine write_dline
@ %def write_header write_hline write_dline
@ During integration, we do not want to print all results at once, but
each intermediate result as soon as we get it. Thus, the previous procedure
is chopped in pieces. First piece: store the
output unit and a flag whether we want to print to standard output as
well. Then write the header if the results are still empty, i.e.,
before integration has started. The second piece writes a single
result to the saved output channels. We call this from the [[record]]
method, which can be called from the integrator directly. The third
piece writes the average result, once a pass has been completed. The
fourth piece writes a footer (if any), assuming that this is the final result.
<<Integration results: integration results: TBP>>=
procedure :: display_init => integration_results_display_init
procedure :: display_current => integration_results_display_current
procedure :: display_pass => integration_results_display_pass
procedure :: display_final => integration_results_display_final
<<Integration results: procedures>>=
subroutine integration_results_display_init &
(results, screen, unit)
class(integration_results_t), intent(inout) :: results
logical, intent(in) :: screen
integer, intent(in), optional :: unit
integer :: u
if (present (unit)) results%unit = unit
u = given_output_unit ()
results%screen = screen
if (results%n_it == 0) then
if (results%screen) then
call results%write_dline (u)
call results%write_header (u, &
logfile=.false.)
call results%write_dline (u)
end if
if (results%unit /= 0) then
call results%write_dline (results%unit)
call results%write_header (results%unit, &
logfile=.false.)
call results%write_dline (results%unit)
end if
else
if (results%screen) then
call results%write_hline (u)
end if
if (results%unit /= 0) then
call results%write_hline (results%unit)
end if
end if
end subroutine integration_results_display_init
subroutine integration_results_display_current (results, pacify)
class(integration_results_t), intent(in) :: results
integer :: u
logical, intent(in), optional :: pacify
u = given_output_unit ()
if (results%screen) then
call results%entry(results%n_it)%write (u, &
verbosity = results%verbosity, suppress = pacify)
end if
if (results%unit /= 0) then
call results%entry(results%n_it)%write ( &
results%unit, verbosity = results%verbosity, suppress = pacify)
end if
end subroutine integration_results_display_current
subroutine integration_results_display_pass (results, pacify)
class(integration_results_t), intent(in) :: results
logical, intent(in), optional :: pacify
integer :: u
u = given_output_unit ()
if (results%screen) then
call results%write_hline (u)
call results%average(results%entry(results%n_it)%pass)%write ( &
u, verbosity = results%verbosity, suppress = pacify)
end if
if (results%unit /= 0) then
call results%write_hline (results%unit)
call results%average(results%entry(results%n_it)%pass)%write ( &
results%unit, verbosity = results%verbosity, suppress = pacify)
end if
end subroutine integration_results_display_pass
subroutine integration_results_display_final (results)
class(integration_results_t), intent(inout) :: results
integer :: u
u = given_output_unit ()
if (results%screen) then
call results%write_dline (u)
end if
if (results%unit /= 0) then
call results%write_dline (results%unit)
end if
results%screen = .false.
results%unit = 0
end subroutine integration_results_display_final
@ %def integration_results_display_init
@ %def integration_results_display_current
@ %def integration_results_display_pass
@ Expand the list of entries if the limit has been reached:
<<Integration results: integration results: TBP>>=
procedure :: expand => integration_results_expand
<<Integration results: procedures>>=
subroutine integration_results_expand (results)
class(integration_results_t), intent(inout) :: results
type(integration_entry_t), dimension(:), allocatable :: entry_tmp
if (results%n_it == size (results%entry)) then
allocate (entry_tmp (results%n_it))
entry_tmp = results%entry
deallocate (results%entry)
allocate (results%entry (results%n_it + RESULTS_CHUNK_SIZE))
results%entry(:results%n_it) = entry_tmp
deallocate (entry_tmp)
end if
if (results%n_pass == size (results%average)) then
allocate (entry_tmp (results%n_pass))
entry_tmp = results%average
deallocate (results%average)
allocate (results%average (results%n_it + RESULTS_CHUNK_SIZE))
results%average(:results%n_pass) = entry_tmp
deallocate (entry_tmp)
end if
end subroutine integration_results_expand
@ %def integration_results_expand
@ Increment the [[current_pass]] counter. Must be done before each new
integration pass; after integration, the recording method may use the value of
this counter to define the entry.
<<Integration results: integration results: TBP>>=
procedure :: new_pass => integration_results_new_pass
<<Integration results: procedures>>=
subroutine integration_results_new_pass (results)
class(integration_results_t), intent(inout) :: results
results%current_pass = results%current_pass + 1
end subroutine integration_results_new_pass
@ %def integration_results_new_pass
@ Enter results into the results list. For the error value, we may compare
them with a given threshold. This guards against numerical noise, if the
exact error would be zero.
<<Integration results: integration results: TBP>>=
procedure :: append => integration_results_append
<<Integration results: procedures>>=
subroutine integration_results_append (results, &
n_it, n_calls, n_calls_valid, &
integral, error, efficiency, efficiency_pos, efficiency_neg, &
chain_weights)
class(integration_results_t), intent(inout) :: results
integer, intent(in) :: n_it, n_calls, n_calls_valid
real(default), intent(in) :: integral, error, efficiency, efficiency_pos, &
& efficiency_neg
real(default), dimension(:), intent(in), optional :: chain_weights
logical :: improved
type(integration_entry_t) :: entry
real(default) :: err_checked
improved = .true.
if (results%n_it /= 0) improved = abs(accuracy (integral, error, n_calls)) &
< abs(results%entry(results%n_it)%get_accuracy ())
err_checked = 0
if (abs (error) >= results%error_threshold) err_checked = error
entry = integration_entry_t ( &
results%process_type, results%current_pass, &
results%n_it+1, n_it, n_calls, n_calls_valid, improved, &
integral, err_checked, efficiency, efficiency_pos, efficiency_neg, &
chain_weights=chain_weights)
if (results%n_it == 0) then
results%n_it = 1
results%n_pass = 1
else
call results%expand ()
if (entry%pass /= results%entry(results%n_it)%pass) &
results%n_pass = results%n_pass + 1
results%n_it = results%n_it + 1
end if
results%entry(results%n_it) = entry
results%average(results%n_pass) = &
compute_average (results%entry, entry%pass)
end subroutine integration_results_append
@ %def integration_results_append
@ Record an integration pass executed by an [[mci]] integrator
object.
There is a tolerance below we treat an error (relative to the
integral) as zero.
<<Integration results: parameters>>=
real(default), parameter, public :: INTEGRATION_ERROR_TOLERANCE = 1e-10
@ %def INTEGRATION_ERROR_TOLERANCE
@
<<Integration results: integration results: TBP>>=
procedure :: record_simple => integration_results_record_simple
<<Integration results: procedures>>=
subroutine integration_results_record_simple &
(object, n_it, n_calls, integral, error, efficiency, &
chain_weights, suppress)
class(integration_results_t), intent(inout) :: object
integer, intent(in) :: n_it, n_calls
real(default), intent(in) :: integral, error, efficiency
real(default), dimension(:), intent(in), optional :: chain_weights
real(default) :: err
logical, intent(in), optional :: suppress
err = 0._default
if (abs (error) >= abs (integral) * INTEGRATION_ERROR_TOLERANCE) then
err = error
end if
call object%append (n_it, n_calls, 0, integral, err, efficiency, 0._default,&
& 0._default, chain_weights)
call object%display_current (suppress)
end subroutine integration_results_record_simple
@ %def integration_results_record_simple
@ Record extended results from integration pass.
<<Integration results: integration results: TBP>>=
procedure :: record_extended => integration_results_record_extended
<<Integration results: procedures>>=
subroutine integration_results_record_extended (object, n_it, n_calls,&
& n_calls_valid, integral, error, efficiency, efficiency_pos,&
& efficiency_neg, chain_weights, suppress)
class(integration_results_t), intent(inout) :: object
integer, intent(in) :: n_it, n_calls, n_calls_valid
real(default), intent(in) :: integral, error, efficiency, efficiency_pos,&
& efficiency_neg
real(default), dimension(:), intent(in), optional :: chain_weights
real(default) :: err
logical, intent(in), optional :: suppress
err = 0._default
if (abs (error) >= abs (integral) * INTEGRATION_ERROR_TOLERANCE) then
err = error
end if
call object%append (n_it, n_calls, n_calls_valid, integral, err, efficiency,&
& efficiency_pos, efficiency_neg, chain_weights)
call object%display_current (suppress)
end subroutine integration_results_record_extended
@ %def integration_results_record_extended
@ Compute the average for all entries in the specified integration
pass. The integrals are weighted w.r.t.\ their individual errors.
The quoted error of the result is the expected error, computed from
the weighted average of the given individual errors.
This should be compared to the actual distribution of the results,
from which we also can compute an error estimate if there is more than
one iteration. The ratio of the distribution error and the averaged
error, is the $\chi^2$ value.
All error distributions are assumed Gaussian, of course. The $\chi^2$
value is a partial check for this assumption. If it is significantly
greater than unity, there is something wrong with the individual errors.
The efficiency returned is the one of the last entry in the
integration pass.
If any error vanishes, averaging by this algorithm would fail. In this case,
we simply average the entries and use the deviations from this average (if
any) to estimate the error.
<<Integration results: procedures>>=
type(integration_entry_t) function compute_average (entry, pass) &
& result (result)
type(integration_entry_t), dimension(:), intent(in) :: entry
integer, intent(in) :: pass
integer :: i
logical, dimension(size(entry)) :: mask
real(default), dimension(size(entry)) :: ivar
real(default) :: sum_ivar, variance
result%process_type = entry(1)%process_type
result%pass = pass
mask = entry%pass == pass .and. entry%process_type /= PRC_UNKNOWN
result%it = maxval (entry%it, mask)
result%n_it = count (mask)
result%n_calls = sum (entry%n_calls, mask)
result%n_calls_valid = sum (entry%n_calls_valid, mask)
if (.not. any (mask .and. entry%error == 0)) then
where (mask)
ivar = 1 / entry%error ** 2
elsewhere
ivar = 0
end where
sum_ivar = sum (ivar, mask)
variance = 0
if (sum_ivar /= 0) then
variance = 1 / sum_ivar
end if
result%integral = sum (entry%integral * ivar, mask) * variance
if (result%n_it > 1) then
result%chi2 = &
sum ((entry%integral - result%integral)**2 * ivar, mask) &
/ (result%n_it - 1)
end if
else if (result%n_it /= 0) then
result%integral = sum (entry%integral, mask) / result%n_it
variance = 0
if (result%n_it > 1) then
variance = &
sum ((entry%integral - result%integral)**2, mask) &
/ (result%n_it - 1)
if (result%integral /= 0) then
if (abs (variance / result%integral) &
< 100 * epsilon (1._default)) then
variance = 0
end if
end if
end if
result%chi2 = variance / result%n_it
end if
result%error = sqrt (variance)
result%efficiency = entry(last_index (mask))%efficiency
result%efficiency_pos = entry(last_index (mask))%efficiency_pos
result%efficiency_neg = entry(last_index (mask))%efficiency_neg
contains
integer function last_index (mask) result (index)
logical, dimension(:), intent(in) :: mask
integer :: i
do i = size (mask), 1, -1
if (mask(i)) exit
end do
index = i
end function last_index
end function compute_average
@ %def compute_average
@
\subsection{Access results}
Return true if the results object has entries.
<<Integration results: integration results: TBP>>=
procedure :: exist => integration_results_exist
<<Integration results: procedures>>=
function integration_results_exist (results) result (flag)
logical :: flag
class(integration_results_t), intent(in) :: results
flag = results%n_pass > 0
end function integration_results_exist
@ %def integration_results_exist
@ Retrieve information from the results record. If [[last]] is set and
true, take the last iteration. If [[it]] is set instead, take this
iteration. If [[pass]] is set, take this average. If none is set,
take the final average.
If the result would be invalid, the entry is not assigned. Due to
default initialization, this returns a null entry.
<<Integration results: integration results: TBP>>=
procedure :: get_entry => results_get_entry
<<Integration results: procedures>>=
function results_get_entry (results, last, it, pass) result (entry)
class(integration_results_t), intent(in) :: results
type(integration_entry_t) :: entry
logical, intent(in), optional :: last
integer, intent(in), optional :: it, pass
if (present (last)) then
if (allocated (results%entry) .and. results%n_it > 0) then
entry = results%entry(results%n_it)
else
call error ()
end if
else if (present (it)) then
if (allocated (results%entry) .and. it > 0 .and. it <= results%n_it) then
entry = results%entry(it)
else
call error ()
end if
else if (present (pass)) then
if (allocated (results%average) &
.and. pass > 0 .and. pass <= results%n_pass) then
entry = results%average (pass)
else
call error ()
end if
else
if (allocated (results%average) .and. results%n_pass > 0) then
entry = results%average (results%n_pass)
else
call error ()
end if
end if
contains
subroutine error ()
call msg_fatal ("Requested integration result is not available")
end subroutine error
end function results_get_entry
@ %def results_get_entry
@ The individual procedures. The [[results]] record should have the
[[target]] attribute, but only locally within the function.
<<Integration results: integration results: TBP>>=
procedure :: get_n_calls => integration_results_get_n_calls
procedure :: get_integral => integration_results_get_integral
procedure :: get_error => integration_results_get_error
procedure :: get_accuracy => integration_results_get_accuracy
procedure :: get_chi2 => integration_results_get_chi2
procedure :: get_efficiency => integration_results_get_efficiency
<<Integration results: procedures>>=
function integration_results_get_n_calls (results, last, it, pass) &
result (n_calls)
class(integration_results_t), intent(in), target :: results
integer :: n_calls
logical, intent(in), optional :: last
integer, intent(in), optional :: it, pass
type(integration_entry_t) :: entry
entry = results%get_entry (last, it, pass)
n_calls = entry%get_n_calls ()
end function integration_results_get_n_calls
function integration_results_get_integral (results, last, it, pass) &
result (integral)
class(integration_results_t), intent(in), target :: results
real(default) :: integral
logical, intent(in), optional :: last
integer, intent(in), optional :: it, pass
type(integration_entry_t) :: entry
entry = results%get_entry (last, it, pass)
integral = entry%get_integral ()
end function integration_results_get_integral
function integration_results_get_error (results, last, it, pass) &
result (error)
class(integration_results_t), intent(in), target :: results
real(default) :: error
logical, intent(in), optional :: last
integer, intent(in), optional :: it, pass
type(integration_entry_t) :: entry
entry = results%get_entry (last, it, pass)
error = entry%get_error ()
end function integration_results_get_error
function integration_results_get_accuracy (results, last, it, pass) &
result (accuracy)
class(integration_results_t), intent(in), target :: results
real(default) :: accuracy
logical, intent(in), optional :: last
integer, intent(in), optional :: it, pass
type(integration_entry_t) :: entry
entry = results%get_entry (last, it, pass)
accuracy = entry%get_accuracy ()
end function integration_results_get_accuracy
function integration_results_get_chi2 (results, last, it, pass) &
result (chi2)
class(integration_results_t), intent(in), target :: results
real(default) :: chi2
logical, intent(in), optional :: last
integer, intent(in), optional :: it, pass
type(integration_entry_t) :: entry
entry = results%get_entry (last, it, pass)
chi2 = entry%get_chi2 ()
end function integration_results_get_chi2
function integration_results_get_efficiency (results, last, it, pass) &
result (efficiency)
class(integration_results_t), intent(in), target :: results
real(default) :: efficiency
logical, intent(in), optional :: last
integer, intent(in), optional :: it, pass
type(integration_entry_t) :: entry
entry = results%get_entry (last, it, pass)
efficiency = entry%get_efficiency ()
end function integration_results_get_efficiency
@ %def integration_results_get_n_calls
@ %def integration_results_get_integral
@ %def integration_results_get_error
@ %def integration_results_get_accuracy
@ %def integration_results_get_chi2
@ %def integration_results_get_efficiency
@ Return the last pass index and the index of the last iteration
\emph{within} the last pass. The third routine returns the absolute
index of the last iteration.
<<Integration results: procedures>>=
function integration_results_get_current_pass (results) result (pass)
integer :: pass
type(integration_results_t), intent(in) :: results
pass = results%n_pass
end function integration_results_get_current_pass
function integration_results_get_current_it (results) result (it)
integer :: it
type(integration_results_t), intent(in) :: results
it = 0
if (allocated (results%entry)) then
it = count (results%entry(1:results%n_it)%pass == results%n_pass)
end if
end function integration_results_get_current_it
function integration_results_get_last_it (results) result (it)
integer :: it
type(integration_results_t), intent(in) :: results
it = results%n_it
end function integration_results_get_last_it
@ %def integration_results_get_current_pass
@ %def integration_results_get_current_it
@ %def integration_results_get_last_it
@ Return the index of the best iteration (lowest accuracy value)
within the current pass. If none qualifies, return zero.
<<Integration results: procedures>>=
function integration_results_get_best_it (results) result (it)
integer :: it
type(integration_results_t), intent(in) :: results
integer :: i
real(default) :: acc, acc_best
acc_best = -1
it = 0
do i = 1, results%n_it
if (results%entry(i)%pass == results%n_pass) then
acc = integration_entry_get_accuracy (results%entry(i))
if (acc_best < 0 .or. acc <= acc_best) then
acc_best = acc
it = i
end if
end if
end do
end function integration_results_get_best_it
@ %def integration_results_get_best_it
@ Compute the MD5 sum by printing everything and checksumming the
resulting file.
<<Integration results: procedures>>=
function integration_results_get_md5sum (results) result (md5sum_results)
character(32) :: md5sum_results
type(integration_results_t), intent(in) :: results
integer :: u
u = free_unit ()
open (unit = u, status = "scratch", action = "readwrite")
call results%write_verbose (u)
rewind (u)
md5sum_results = md5sum (u)
close (u)
end function integration_results_get_md5sum
@ %def integration_results_get_md5sum
@
This is (ab)used to suppress numerical noise when integrating constant
matrix elements.
<<Integration results: integration results: TBP>>=
procedure :: pacify => integration_results_pacify
<<Integration results: procedures>>=
subroutine integration_results_pacify (results, efficiency_reset)
class(integration_results_t), intent(inout) :: results
logical, intent(in), optional :: efficiency_reset
integer :: i
logical :: reset
reset = .false.
if (present (efficiency_reset)) reset = efficiency_reset
if (allocated (results%entry)) then
do i = 1, size (results%entry)
call pacify (results%entry(i)%error, &
results%entry(i)%integral * 1.E-9_default)
if (reset) results%entry(i)%efficiency = 1
end do
end if
if (allocated (results%average)) then
do i = 1, size (results%average)
call pacify (results%average(i)%error, &
results%average(i)%integral * 1.E-9_default)
if (reset) results%average(i)%efficiency = 1
end do
end if
end subroutine integration_results_pacify
@ %def integration_results_pacify
@
<<Integration results: integration results: TBP>>=
procedure :: record_correction => integration_results_record_correction
<<Integration results: procedures>>=
subroutine integration_results_record_correction (object, corr, err)
class(integration_results_t), intent(inout) :: object
real(default), intent(in) :: corr, err
integer :: u
u = given_output_unit ()
if (object%screen) then
call object%write_hline (u)
call msg_message ("NLO Correction: [O(alpha_s+1)/O(alpha_s)]")
write(msg_buffer,'(1X,A1,F8.4,A4,F9.5,1X,A3)') '(', corr, ' +- ', err, ') %'
call msg_message ()
end if
end subroutine integration_results_record_correction
@ %def integration_results_record_correction
@
\subsection{Results display}
Write a driver file for history visualization.
The ratio of $y$ range over $y$ value must not become too small, otherwise
we run into an arithmetic overflow in GAMELAN. 2\% appears to be safe.
<<Integration results: parameters>>=
real, parameter, public :: GML_MIN_RANGE_RATIO = 0.02
<<Integration results: public>>=
public :: integration_results_write_driver
<<Integration results: procedures>>=
subroutine integration_results_write_driver (results, filename, eff_reset)
type(integration_results_t), intent(inout) :: results
type(string_t), intent(in) :: filename
logical, intent(in), optional :: eff_reset
type(string_t) :: file_tex
integer :: unit
integer :: n, i, n_pass, pass
integer, dimension(:), allocatable :: ipass
real(default) :: ymin, ymax, yavg, ydif, y0, y1
real(default), dimension(results%n_it) :: ymin_arr, ymax_arr
logical :: reset
file_tex = filename // ".tex"
unit = free_unit ()
open (unit=unit, file=char(file_tex), action="write", status="replace")
reset = .false.; if (present (eff_reset)) reset = eff_reset
n = results%n_it
n_pass = results%n_pass
allocate (ipass (results%n_pass))
ipass(1) = 0
pass = 2
do i = 1, n-1
if (integration_entry_get_pass (results%entry(i)) &
/= integration_entry_get_pass (results%entry(i+1))) then
ipass(pass) = i
pass = pass + 1
end if
end do
ymin_arr = integration_entry_get_integral (results%entry(:n)) &
- integration_entry_get_error (results%entry(:n))
ymin = minval (ymin_arr)
ymax_arr = integration_entry_get_integral (results%entry(:n)) &
+ integration_entry_get_error (results%entry(:n))
ymax = maxval (ymax_arr)
yavg = (ymax + ymin) / 2
ydif = (ymax - ymin)
if (ydif * 1.5 > GML_MIN_RANGE_RATIO * yavg) then
y0 = yavg - ydif * 0.75
y1 = yavg + ydif * 0.75
else
y0 = yavg * (1 - GML_MIN_RANGE_RATIO / 2)
y1 = yavg * (1 + GML_MIN_RANGE_RATIO / 2)
end if
write (unit, "(A)") "\documentclass{article}"
write (unit, "(A)") "\usepackage{a4wide}"
write (unit, "(A)") "\usepackage{gamelan}"
write (unit, "(A)") "\usepackage{amsmath}"
write (unit, "(A)") ""
write (unit, "(A)") "\begin{document}"
write (unit, "(A)") "\begin{gmlfile}"
write (unit, "(A)") "\section*{Integration Results Display}"
write (unit, "(A)") ""
write (unit, "(A)") "Process: \verb|" // char (filename) // "|"
write (unit, "(A)") ""
write (unit, "(A)") "\vspace*{2\baselineskip}"
write (unit, "(A)") "\unitlength 1mm"
write (unit, "(A)") "\begin{gmlcode}"
write (unit, "(A)") " picture sym; sym = fshape (circle scaled 1mm)();"
write (unit, "(A)") " color col.band; col.band = 0.9white;"
write (unit, "(A)") " color col.eband; col.eband = 0.98white;"
write (unit, "(A)") "\end{gmlcode}"
write (unit, "(A)") "\begin{gmlgraph*}(130,180)[history]"
write (unit, "(A)") " setup (linear, linear);"
write (unit, "(A,I0,A)") " history.n_pass = ", n_pass, ";"
write (unit, "(A,I0,A)") " history.n_it = ", n, ";"
write (unit, "(A,A,A)") " history.y0 = #""", char (mp_format (y0)), """;"
write (unit, "(A,A,A)") " history.y1 = #""", char (mp_format (y1)), """;"
write (unit, "(A)") &
" graphrange (#0.5, history.y0), (#(n+0.5), history.y1);"
do pass = 1, n_pass
write (unit, "(A,I0,A,I0,A)") &
" history.pass[", pass, "] = ", ipass(pass), ";"
write (unit, "(A,I0,A,A,A)") &
" history.avg[", pass, "] = #""", &
char (mp_format &
(integration_entry_get_integral (results%average(pass)))), &
""";"
write (unit, "(A,I0,A,A,A)") &
" history.err[", pass, "] = #""", &
char (mp_format &
(integration_entry_get_error (results%average(pass)))), &
""";"
write (unit, "(A,I0,A,A,A)") &
" history.chi[", pass, "] = #""", &
char (mp_format &
(integration_entry_get_chi2 (results%average(pass)))), &
""";"
end do
write (unit, "(A,I0,A,I0,A)") &
" history.pass[", n_pass + 1, "] = ", n, ";"
write (unit, "(A)") " for i = 1 upto history.n_pass:"
write (unit, "(A)") " if history.chi[i] greater one:"
write (unit, "(A)") " fill plot ("
write (unit, "(A)") &
" (#(history.pass[i] +.5), " &
// "history.avg[i] minus history.err[i] times history.chi[i]),"
write (unit, "(A)") &
" (#(history.pass[i+1]+.5), " &
// "history.avg[i] minus history.err[i] times history.chi[i]),"
write (unit, "(A)") &
" (#(history.pass[i+1]+.5), " &
// "history.avg[i] plus history.err[i] times history.chi[i]),"
write (unit, "(A)") &
" (#(history.pass[i] +.5), " &
// "history.avg[i] plus history.err[i] times history.chi[i])"
write (unit, "(A)") " ) withcolor col.eband fi;"
write (unit, "(A)") " fill plot ("
write (unit, "(A)") &
" (#(history.pass[i] +.5), history.avg[i] minus history.err[i]),"
write (unit, "(A)") &
" (#(history.pass[i+1]+.5), history.avg[i] minus history.err[i]),"
write (unit, "(A)") &
" (#(history.pass[i+1]+.5), history.avg[i] plus history.err[i]),"
write (unit, "(A)") &
" (#(history.pass[i] +.5), history.avg[i] plus history.err[i])"
write (unit, "(A)") " ) withcolor col.band;"
write (unit, "(A)") " draw plot ("
write (unit, "(A)") &
" (#(history.pass[i] +.5), history.avg[i]),"
write (unit, "(A)") &
" (#(history.pass[i+1]+.5), history.avg[i])"
write (unit, "(A)") " ) dashed evenly;"
write (unit, "(A)") " endfor"
write (unit, "(A)") " for i = 1 upto history.n_pass + 1:"
write (unit, "(A)") " draw plot ("
write (unit, "(A)") &
" (#(history.pass[i]+.5), history.y0),"
write (unit, "(A)") &
" (#(history.pass[i]+.5), history.y1)"
write (unit, "(A)") " ) dashed withdots;"
write (unit, "(A)") " endfor"
do i = 1, n
write (unit, "(A,I0,A,A,A,A,A)") " plot (history) (#", &
i, ", #""", &
char (mp_format (integration_entry_get_integral (results%entry(i)))),&
""") vbar #""", &
char (mp_format (integration_entry_get_error (results%entry(i)))), &
""";"
end do
write (unit, "(A)") " draw piecewise from (history) " &
// "withsymbol sym;"
write (unit, "(A)") " fullgrid.lr (5,20);"
write (unit, "(A)") " standardgrid.bt (n);"
write (unit, "(A)") " begingmleps ""Whizard-Logo.eps"";"
write (unit, "(A)") " base := (120*unitlength,170*unitlength);"
write (unit, "(A)") " height := 9.6*unitlength;"
write (unit, "(A)") " width := 11.2*unitlength;"
write (unit, "(A)") " endgmleps;"
write (unit, "(A)") "\end{gmlgraph*}"
write (unit, "(A)") "\end{gmlfile}"
write (unit, "(A)") "\clearpage"
write (unit, "(A)") "\begin{verbatim}"
if (reset) then
call results%pacify (reset)
end if
call integration_results_write (results, unit)
write (unit, "(A)") "\end{verbatim}"
write (unit, "(A)") "\end{document}"
close (unit)
end subroutine integration_results_write_driver
@ %def integration_results_write_driver
@ Call \LaTeX\ and Metapost for the history driver file, and convert to PS and
PDF.
<<Integration results: public>>=
public :: integration_results_compile_driver
<<Integration results: procedures>>=
subroutine integration_results_compile_driver (results, filename, os_data)
type(integration_results_t), intent(in) :: results
type(string_t), intent(in) :: filename
type(os_data_t), intent(in) :: os_data
integer :: unit_dev, status
type(string_t) :: file_tex, file_dvi, file_ps, file_pdf, file_mp
type(string_t) :: setenv_tex, setenv_mp, pipe, pipe_dvi
if (.not. os_data%event_analysis) then
call msg_warning ("Skipping integration history display " &
// "because latex or mpost is not available")
return
end if
file_tex = filename // ".tex"
file_dvi = filename // ".dvi"
file_ps = filename // ".ps"
file_pdf = filename // ".pdf"
file_mp = filename // ".mp"
call msg_message ("Creating integration history display "&
// char (file_ps) // " and " // char (file_pdf))
BLOCK: do
unit_dev = free_unit ()
open (file = "/dev/null", unit = unit_dev, &
action = "write", iostat = status)
if (status /= 0) then
pipe = ""
pipe_dvi = ""
else
pipe = " > /dev/null"
pipe_dvi = " 2>/dev/null 1>/dev/null"
end if
close (unit_dev)
if (os_data%whizard_texpath /= "") then
setenv_tex = &
"TEXINPUTS=" // os_data%whizard_texpath // ":$TEXINPUTS "
setenv_mp = &
"MPINPUTS=" // os_data%whizard_texpath // ":$MPINPUTS "
else
setenv_tex = ""
setenv_mp = ""
end if
call os_system_call (setenv_tex // os_data%latex // " " // &
file_tex // pipe, status)
if (status /= 0) exit BLOCK
if (os_data%gml /= "") then
call os_system_call (setenv_mp // os_data%gml // " " // &
file_mp // pipe, status)
else
call msg_error ("Could not use GAMELAN/MetaPOST.")
exit BLOCK
end if
if (status /= 0) exit BLOCK
call os_system_call (setenv_tex // os_data%latex // " " // &
file_tex // pipe, status)
if (status /= 0) exit BLOCK
if (os_data%event_analysis_ps) then
call os_system_call (os_data%dvips // " " // &
file_dvi // pipe_dvi, status)
if (status /= 0) exit BLOCK
else
call msg_warning ("Skipping PostScript generation because dvips " &
// "is not available")
exit BLOCK
end if
if (os_data%event_analysis_pdf) then
call os_system_call (os_data%ps2pdf // " " // &
file_ps, status)
if (status /= 0) exit BLOCK
else
call msg_warning ("Skipping PDF generation because ps2pdf " &
// "is not available")
exit BLOCK
end if
exit BLOCK
end do BLOCK
if (status /= 0) then
call msg_error ("Unable to compile integration history display")
end if
end subroutine integration_results_compile_driver
@ %def integration_results_compile_driver
@
\subsection{Unit tests}
Test module, followed by the corresponding implementation module.
<<[[integration_results_ut.f90]]>>=
<<File header>>
module integration_results_ut
use unit_tests
use integration_results_uti
<<Standard module head>>
<<integration results: public test>>
contains
<<integration results: test driver>>
end module integration_results_ut
@ %def integration_results_ut
@
<<[[integration_results_uti.f90]]>>=
<<File header>>
module integration_results_uti
<<Use kinds>>
use integration_results
<<Standard module head>>
<<integration results: test declarations>>
contains
<<integration results: tests>>
end module integration_results_uti
@ %def integration_results_ut
@ API: driver for the unit tests below.
<<integration results: public test>>=
public :: integration_results_test
<<integration results: test driver>>=
subroutine integration_results_test (u, results)
integer, intent(in) :: u
type(test_results_t), intent(inout) :: results
<<integration results: execute tests>>
end subroutine integration_results_test
@ %def integration_results_test
@
\subsubsection{Integration entry}
<<integration results: execute tests>>=
call test (integration_results_1, "integration_results_1", &
"record single line and write to log", &
u, results)
<<integration results: test declarations>>=
public :: integration_results_1
<<integration results: tests>>=
subroutine integration_results_1 (u)
integer, intent(in) :: u
type(integration_entry_t) :: entry
write (u, "(A)") "* Test output: integration_results_1"
write (u, "(A)") "* Purpose: record single entry and write to log"
write (u, "(A)")
write (u, "(A)") "* Write single line output"
write (u, "(A)")
entry = integration_entry_t ( &
& process_type = 1, &
& pass = 1, &
& it = 1, &
& n_it = 10, &
& n_calls = 1000, &
& n_calls_valid = 500, &
& improved = .true., &
& integral = 1.0_default, &
& error = 0.5_default, &
& efficiency = 0.25_default, &
& efficiency_pos = 0.22_default, &
& efficiency_neg = 0.03_default)
call entry%write (u, 3)
write (u, "(A)")
write (u, "(A)") "* Test output end: integration_results_1"
end subroutine integration_results_1
@ %def integration_results_1
@
<<integration results: execute tests>>=
call test (integration_results_2, "integration_results_2", &
"record single result and write to log", &
u, results)
<<integration results: test declarations>>=
public :: integration_results_2
<<integration results: tests>>=
subroutine integration_results_2 (u)
integer, intent(in) :: u
type(integration_results_t) :: results
write (u, "(A)") "* Test output: integration_results_2"
write (u, "(A)") "* Purpose: record single result and write to log"
write (u, "(A)")
write (u, "(A)") "* Write single line output"
write (u, "(A)")
call results%init (PRC_DECAY)
call results%append (1, 250, 0, 1.0_default, 0.5_default, 0.25_default,&
& 0._default, 0._default)
call results%write (u)
write (u, "(A)")
write (u, "(A)") "* Test output end: integration_results_2"
end subroutine integration_results_2
@ %def integration_results_2
@
<<integration results: execute tests>>=
call test (integration_results_3, "integration_results_3", &
"initialize display and add/display each entry", &
u, results)
<<integration results: test declarations>>=
public :: integration_results_3
<<integration results: tests>>=
subroutine integration_results_3 (u)
integer, intent(in) :: u
type(integration_results_t) :: results
write (u, "(A)") "* Test output: integration_results_2"
write (u, "(A)") "* Purpose: intialize display, record three entries,&
& display pass average and finalize display"
write (u, "(A)")
write (u, "(A)") "* Initialize display and add entry"
write (u, "(A)")
call results%init (PRC_DECAY)
call results%set_verbosity (1)
call results%display_init (screen = .false., unit = u)
call results%new_pass ()
call results%record (1, 250, 1.0_default, 0.5_default, 0.25_default)
call results%record (1, 250, 1.1_default, 0.5_default, 0.25_default)
call results%record (1, 250, 0.9_default, 0.5_default, 0.25_default)
write (u, "(A)")
write (u, "(A)") "* Display pass"
write (u, "(A)")
call results%display_pass ()
write (u, "(A)")
write (u, "(A)") "* Finalize displays"
write (u, "(A)")
call results%display_final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: integration_results_3"
end subroutine integration_results_3
@ %def integration_results_3
@
<<integration results: execute tests>>=
call test (integration_results_4, "integration_results_4", &
"record extended results and display", &
u, results)
<<integration results: test declarations>>=
public :: integration_results_4
<<integration results: tests>>=
subroutine integration_results_4 (u)
integer, intent(in) :: u
type(integration_results_t) :: results
write (u, "(A)") "* Test output: integration_results_4"
write (u, "(A)") "* Purpose: record extended results and display with verbosity = 2"
write (u, "(A)")
write (u, "(A)") "* Initialize display and record extended result"
write (u, "(A)")
call results%init (PRC_DECAY)
call results%set_verbosity (2)
call results%display_init (screen = .false., unit = u)
call results%new_pass ()
call results%record (1, 250, 150, 1.0_default, 0.5_default, 0.25_default,&
& 0.22_default, 0.03_default)
call results%record (1, 250, 180, 1.1_default, 0.5_default, 0.25_default,&
& 0.23_default, 0.02_default)
call results%record (1, 250, 130, 0.9_default, 0.5_default, 0.25_default,&
& 0.25_default, 0.00_default)
write (u, "(A)")
write (u, "(A)") "* Display pass"
write (u, "(A)")
call results%display_pass ()
write (u, "(A)")
write (u, "(A)") "* Finalize displays"
write (u, "(A)")
call results%display_final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: integration_results_4"
end subroutine integration_results_4
@ %def integration_results_4
@
<<integration results: execute tests>>=
call test (integration_results_5, "integration_results_5", &
"record extended results and display", &
u, results)
<<integration results: test declarations>>=
public :: integration_results_5
<<integration results: tests>>=
subroutine integration_results_5 (u)
integer, intent(in) :: u
type(integration_results_t) :: results
write (u, "(A)") "* Test output: integration_results_5"
write (u, "(A)") "* Purpose: record extended results and display with verbosity = 3"
write (u, "(A)")
write (u, "(A)") "* Initialize display and record extended result"
write (u, "(A)")
call results%init (PRC_DECAY)
call results%set_verbosity (3)
call results%display_init (screen = .false., unit = u)
call results%new_pass ()
call results%record (1, 250, 150, 1.0_default, 0.5_default, 0.25_default,&
& 0.22_default, 0.03_default)
call results%record (1, 250, 180, 1.1_default, 0.5_default, 0.25_default,&
& 0.23_default, 0.02_default)
call results%record (1, 250, 130, 0.9_default, 0.5_default, 0.25_default,&
& 0.25_default, 0.00_default)
call results%display_pass ()
call results%display_final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: integration_results_5"
end subroutine integration_results_5
@ %def integration_results_5
@
\clearpage
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{Dummy integrator}
This implementation acts as a placeholder for cases where no
integration or event generation is required at all.
<<[[mci_none.f90]]>>=
<<File header>>
module mci_none
<<Use kinds>>
use io_units, only: given_output_unit
use diagnostics, only: msg_message, msg_fatal
use phs_base, only: phs_channel_t
use mci_base
<<Standard module head>>
<<MCI none: public>>
<<MCI none: types>>
contains
<<MCI none: procedures>>
end module mci_none
@ %def mci_none
@
\subsection{Integrator}
The object contains the methods for integration and event generation.
For the actual work and data storage, it spawns an instance object.
After an integration pass, we update the [[max]] parameter to indicate
the maximum absolute value of the integrand that the integrator
encountered. This is required for event generation.
<<MCI none: public>>=
public :: mci_none_t
<<MCI none: types>>=
type, extends (mci_t) :: mci_none_t
contains
<<MCI none: mci none: TBP>>
end type mci_none_t
@ %def mci_t
@ Finalizer: no-op.
<<MCI none: mci none: TBP>>=
procedure :: final => mci_none_final
<<MCI none: procedures>>=
subroutine mci_none_final (object)
class(mci_none_t), intent(inout) :: object
end subroutine mci_none_final
@ %def mci_none_final
@ Output.
<<MCI none: mci none: TBP>>=
procedure :: write => mci_none_write
<<MCI none: procedures>>=
subroutine mci_none_write (object, unit, pacify, md5sum_version)
class(mci_none_t), intent(in) :: object
integer, intent(in), optional :: unit
logical, intent(in), optional :: pacify
logical, intent(in), optional :: md5sum_version
integer :: u
u = given_output_unit (unit)
write (u, "(1x,A)") "Integrator: non-functional dummy"
end subroutine mci_none_write
@ %def mci_none_write
@ Startup message: short version.
<<MCI none: mci none: TBP>>=
procedure :: startup_message => mci_none_startup_message
<<MCI none: procedures>>=
subroutine mci_none_startup_message (mci, unit, n_calls)
class(mci_none_t), intent(in) :: mci
integer, intent(in), optional :: unit, n_calls
call msg_message ("Integrator: none")
end subroutine mci_none_startup_message
@ %def mci_none_startup_message
@ Log entry: just headline.
<<MCI none: mci none: TBP>>=
procedure :: write_log_entry => mci_none_write_log_entry
<<MCI none: procedures>>=
subroutine mci_none_write_log_entry (mci, u)
class(mci_none_t), intent(in) :: mci
integer, intent(in) :: u
write (u, "(1x,A)") "MC Integrator is none (no-op)"
end subroutine mci_none_write_log_entry
@ %def mci_none_write_log_entry
@ MD5 sum: nothing.
<<MCI none: mci none: TBP>>=
procedure :: compute_md5sum => mci_none_compute_md5sum
<<MCI none: procedures>>=
subroutine mci_none_compute_md5sum (mci, pacify)
class(mci_none_t), intent(inout) :: mci
logical, intent(in), optional :: pacify
end subroutine mci_none_compute_md5sum
@ %def mci_none_compute_md5sum
@ The number of channels must be one.
<<CCC MCI none: mci none: TBP>>=
procedure :: set_dimensions => mci_none_set_dimensions
<<CCC MCI none: procedures>>=
subroutine mci_none_set_dimensions (mci, n_dim, n_channel)
class(mci_none_t), intent(inout) :: mci
integer, intent(in) :: n_dim
integer, intent(in) :: n_channel
if (n_channel == 1) then
mci%n_channel = n_channel
mci%n_dim = n_dim
allocate (mci%dim_is_binned (mci%n_dim))
mci%dim_is_binned = .true.
mci%n_dim_binned = count (mci%dim_is_binned)
allocate (mci%n_bin (mci%n_dim))
mci%n_bin = 0
else
call msg_fatal ("Attempt to initialize single-channel integrator &
&for multiple channels")
end if
end subroutine mci_none_set_dimensions
@ %def mci_none_set_dimensions
@ Required by API.
<<MCI none: mci none: TBP>>=
procedure :: declare_flat_dimensions => mci_none_ignore_flat_dimensions
<<MCI none: procedures>>=
subroutine mci_none_ignore_flat_dimensions (mci, dim_flat)
class(mci_none_t), intent(inout) :: mci
integer, dimension(:), intent(in) :: dim_flat
end subroutine mci_none_ignore_flat_dimensions
@ %def mci_none_ignore_flat_dimensions
@ Required by API.
<<MCI none: mci none: TBP>>=
procedure :: declare_equivalences => mci_none_ignore_equivalences
<<MCI none: procedures>>=
subroutine mci_none_ignore_equivalences (mci, channel, dim_offset)
class(mci_none_t), intent(inout) :: mci
type(phs_channel_t), dimension(:), intent(in) :: channel
integer, intent(in) :: dim_offset
end subroutine mci_none_ignore_equivalences
@ %def mci_none_ignore_equivalences
@ Allocate instance with matching type.
<<MCI none: mci none: TBP>>=
procedure :: allocate_instance => mci_none_allocate_instance
<<MCI none: procedures>>=
subroutine mci_none_allocate_instance (mci, mci_instance)
class(mci_none_t), intent(in) :: mci
class(mci_instance_t), intent(out), pointer :: mci_instance
allocate (mci_none_instance_t :: mci_instance)
end subroutine mci_none_allocate_instance
@ %def mci_none_allocate_instance
@ Integrate. This must not be called at all.
<<MCI none: mci none: TBP>>=
procedure :: integrate => mci_none_integrate
<<MCI none: procedures>>=
subroutine mci_none_integrate (mci, instance, sampler, n_it, n_calls, &
results, pacify)
class(mci_none_t), intent(inout) :: mci
class(mci_instance_t), intent(inout), target :: instance
class(mci_sampler_t), intent(inout), target :: sampler
integer, intent(in) :: n_it
integer, intent(in) :: n_calls
logical, intent(in), optional :: pacify
class(mci_results_t), intent(inout), optional :: results
call msg_fatal ("Integration: attempt to integrate with the 'mci_none' method")
end subroutine mci_none_integrate
@ %def mci_none_integrate
@ Simulation initializer and finalizer: nothing to do here.
<<MCI none: mci none: TBP>>=
procedure :: prepare_simulation => mci_none_ignore_prepare_simulation
<<MCI none: procedures>>=
subroutine mci_none_ignore_prepare_simulation (mci)
class(mci_none_t), intent(inout) :: mci
end subroutine mci_none_ignore_prepare_simulation
@ %def mci_none_ignore_prepare_simulation
@ Generate events, must not be called.
<<MCI none: mci none: TBP>>=
procedure :: generate_weighted_event => mci_none_generate_no_event
procedure :: generate_unweighted_event => mci_none_generate_no_event
<<MCI none: procedures>>=
subroutine mci_none_generate_no_event (mci, instance, sampler)
class(mci_none_t), intent(inout) :: mci
class(mci_instance_t), intent(inout), target :: instance
class(mci_sampler_t), intent(inout), target :: sampler
call msg_fatal ("Integration: attempt to generate event with the 'mci_none' method")
end subroutine mci_none_generate_no_event
@ %def mci_none_generate_no_event
@ Rebuild an event, no-op.
<<MCI none: mci none: TBP>>=
procedure :: rebuild_event => mci_none_rebuild_event
<<MCI none: procedures>>=
subroutine mci_none_rebuild_event (mci, instance, sampler, state)
class(mci_none_t), intent(inout) :: mci
class(mci_instance_t), intent(inout) :: instance
class(mci_sampler_t), intent(inout) :: sampler
class(mci_state_t), intent(in) :: state
end subroutine mci_none_rebuild_event
@ %def mci_none_rebuild_event
@
\subsection{Integrator instance}
Covering the case of flat dimensions, we store a complete [[x]] array. This
is filled when generating events.
<<MCI none: public>>=
public :: mci_none_instance_t
<<MCI none: types>>=
type, extends (mci_instance_t) :: mci_none_instance_t
contains
<<MCI none: mci none instance: TBP>>
end type mci_none_instance_t
@ %def mci_none_instance_t
@ Output.
<<MCI none: mci none instance: TBP>>=
procedure :: write => mci_none_instance_write
<<MCI none: procedures>>=
subroutine mci_none_instance_write (object, unit, pacify)
class(mci_none_instance_t), intent(in) :: object
integer, intent(in), optional :: unit
logical, intent(in), optional :: pacify
integer :: u
u = given_output_unit (unit)
write (u, "(1x,A)") "Integrator instance: non-functional dummy"
end subroutine mci_none_instance_write
@ %def mci_none_instance_write
@ The finalizer is empty.
<<MCI none: mci none instance: TBP>>=
procedure :: final => mci_none_instance_final
<<MCI none: procedures>>=
subroutine mci_none_instance_final (object)
class(mci_none_instance_t), intent(inout) :: object
end subroutine mci_none_instance_final
@ %def mci_none_instance_final
@ Initializer, empty.
<<MCI none: mci none instance: TBP>>=
procedure :: init => mci_none_instance_init
<<MCI none: procedures>>=
subroutine mci_none_instance_init (mci_instance, mci)
class(mci_none_instance_t), intent(out) :: mci_instance
class(mci_t), intent(in), target :: mci
end subroutine mci_none_instance_init
@ %def mci_none_instance_init
@ Copy the stored extrema of the integrand in the instance record.
<<CCC MCI none: mci none instance: TBP>>=
procedure :: get_max => mci_none_instance_get_max
<<CCC MCI none: procedures>>=
subroutine mci_none_instance_get_max (instance)
class(mci_none_instance_t), intent(inout) :: instance
associate (mci => instance%mci)
if (mci%max_known) then
instance%max_known = .true.
instance%max = mci%max
instance%min = mci%min
instance%max_abs = mci%max_abs
instance%min_abs = mci%min_abs
end if
end associate
end subroutine mci_none_instance_get_max
@ %def mci_none_instance_get_max
@ Reverse operations: recall the extrema, but only if they are wider
than the extrema already stored in the configuration. Also recalculate the
efficiency value.
<<CCC MCI none: mci none instance: TBP>>=
procedure :: set_max => mci_none_instance_set_max
<<CCC MCI none: procedures>>=
subroutine mci_none_instance_set_max (instance)
class(mci_none_instance_t), intent(inout) :: instance
associate (mci => instance%mci)
if (instance%max_known) then
if (mci%max_known) then
mci%max = max (mci%max, instance%max)
mci%min = min (mci%min, instance%min)
mci%max_abs = max (mci%max_abs, instance%max_abs)
mci%min_abs = min (mci%min_abs, instance%min_abs)
else
mci%max = instance%max
mci%min = instance%min
mci%max_abs = instance%max_abs
mci%min_abs = instance%min_abs
mci%max_known = .true.
end if
if (mci%max_abs /= 0) then
if (mci%integral_neg == 0) then
mci%efficiency = mci%integral / mci%max_abs
mci%efficiency_known = .true.
else if (mci%n_calls /= 0) then
mci%efficiency = &
(mci%integral_pos - mci%integral_neg) / mci%max_abs
mci%efficiency_known = .true.
end if
end if
end if
end associate
end subroutine mci_none_instance_set_max
@ %def mci_none_instance_set_max
@ The weight cannot be computed.
<<MCI none: mci none instance: TBP>>=
procedure :: compute_weight => mci_none_instance_compute_weight
<<MCI none: procedures>>=
subroutine mci_none_instance_compute_weight (mci, c)
class(mci_none_instance_t), intent(inout) :: mci
integer, intent(in) :: c
call msg_fatal ("Integration: attempt to compute weight with the 'mci_none' method")
end subroutine mci_none_instance_compute_weight
@ %def mci_none_instance_compute_weight
@ Record the integrand, no-op.
<<MCI none: mci none instance: TBP>>=
procedure :: record_integrand => mci_none_instance_record_integrand
<<MCI none: procedures>>=
subroutine mci_none_instance_record_integrand (mci, integrand)
class(mci_none_instance_t), intent(inout) :: mci
real(default), intent(in) :: integrand
end subroutine mci_none_instance_record_integrand
@ %def mci_none_instance_record_integrand
@ No-op.
<<MCI none: mci none instance: TBP>>=
procedure :: init_simulation => mci_none_instance_init_simulation
procedure :: final_simulation => mci_none_instance_final_simulation
<<MCI none: procedures>>=
subroutine mci_none_instance_init_simulation (instance, safety_factor)
class(mci_none_instance_t), intent(inout) :: instance
real(default), intent(in), optional :: safety_factor
end subroutine mci_none_instance_init_simulation
subroutine mci_none_instance_final_simulation (instance)
class(mci_none_instance_t), intent(inout) :: instance
end subroutine mci_none_instance_final_simulation
@ %def mci_none_instance_init_simulation
@ %def mci_none_instance_final_simulation
@ Return excess weight for the current event: return zero, just in case.
<<MCI none: mci none instance: TBP>>=
procedure :: get_event_excess => mci_none_instance_get_event_excess
<<MCI none: procedures>>=
function mci_none_instance_get_event_excess (mci) result (excess)
class(mci_none_instance_t), intent(in) :: mci
real(default) :: excess
excess = 0
end function mci_none_instance_get_event_excess
@ %def mci_none_instance_get_event_excess
@
\subsection{Unit tests}
Test module, followed by the corresponding implementation module.
<<[[mci_none_ut.f90]]>>=
<<File header>>
module mci_none_ut
use unit_tests
use mci_none_uti
<<Standard module head>>
<<MCI none: public test>>
contains
<<MCI none: test driver>>
end module mci_none_ut
@ %def mci_none_ut
@
<<[[mci_none_uti.f90]]>>=
<<File header>>
module mci_none_uti
use mci_base
use mci_none
<<Standard module head>>
<<MCI none: test declarations>>
<<MCI none: test types>>
contains
<<MCI none: tests>>
end module mci_none_uti
@ %def mci_none_ut
@ API: driver for the unit tests below.
<<MCI none: public test>>=
public :: mci_none_test
<<MCI none: test driver>>=
subroutine mci_none_test (u, results)
integer, intent(in) :: u
type(test_results_t), intent(inout) :: results
<<MCI none: execute tests>>
end subroutine mci_none_test
@ %def mci_none_test
@
\subsubsection{Trivial sanity check}
Construct an integrator and display it.
<<MCI none: execute tests>>=
call test (mci_none_1, "mci_none_1", &
"dummy integrator", &
u, results)
<<MCI none: test declarations>>=
public :: mci_none_1
<<MCI none: tests>>=
subroutine mci_none_1 (u)
integer, intent(in) :: u
class(mci_t), allocatable, target :: mci
class(mci_instance_t), pointer :: mci_instance => null ()
class(mci_sampler_t), allocatable :: sampler
write (u, "(A)") "* Test output: mci_none_1"
write (u, "(A)") "* Purpose: display mci configuration"
write (u, "(A)")
write (u, "(A)") "* Allocate integrator"
write (u, "(A)")
allocate (mci_none_t :: mci)
call mci%write (u)
write (u, "(A)")
write (u, "(A)") "* Initialize instance"
write (u, "(A)")
call mci%allocate_instance (mci_instance)
call mci_instance%init (mci)
call mci_instance%write (u)
call mci_instance%final ()
call mci%final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: mci_none_1"
end subroutine mci_none_1
@ %def mci_none_1
@
\clearpage
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{Simple midpoint integration}
This is a most simple implementation of an integrator. The algorithm
is the straightforward multi-dimensional midpoint rule, i.e., the
integration hypercube is binned uniformly, the integrand is evaluated
at the midpoints of each bin, and the result is the average. The
binning is equivalent for all integration dimensions.
This rule is accurate to the order $h^2$, where $h$ is the bin width.
Given that $h=N^{-1/d}$, where $d$ is the integration dimension and
$N$ is the total number of sampling points, we get a relative error
of order $N^{-2/d}$. This is superior to MC integration if $d<4$, and
equivalent if $d=4$. It is not worse than higher-order formulas
(such as Gauss integration) if the integrand is not smooth, e.g., if
it contains cuts.
The integrator is specifically single-channel. However, we do not
limit the dimension.
<<[[mci_midpoint.f90]]>>=
<<File header>>
module mci_midpoint
<<Use kinds>>
use io_units
use diagnostics
use phs_base
use mci_base
<<Standard module head>>
<<MCI midpoint: public>>
<<MCI midpoint: types>>
contains
<<MCI midpoint: procedures>>
end module mci_midpoint
@ %def mci_midpoint
@
\subsection{Integrator}
The object contains the methods for integration and event generation.
For the actual work and data storage, it spawns an instance object.
After an integration pass, we update the [[max]] parameter to indicate
the maximum absolute value of the integrand that the integrator
encountered. This is required for event generation.
<<MCI midpoint: public>>=
public :: mci_midpoint_t
<<MCI midpoint: types>>=
type, extends (mci_t) :: mci_midpoint_t
integer :: n_dim_binned = 0
logical, dimension(:), allocatable :: dim_is_binned
logical :: calls_known = .false.
integer :: n_calls = 0
integer :: n_calls_pos = 0
integer :: n_calls_nul = 0
integer :: n_calls_neg = 0
real(default) :: integral_pos = 0
real(default) :: integral_neg = 0
integer, dimension(:), allocatable :: n_bin
logical :: max_known = .false.
real(default) :: max = 0
real(default) :: min = 0
real(default) :: max_abs = 0
real(default) :: min_abs = 0
contains
<<MCI midpoint: mci midpoint: TBP>>
end type mci_midpoint_t
@ %def mci_t
@ Finalizer: base version is sufficient
<<MCI midpoint: mci midpoint: TBP>>=
procedure :: final => mci_midpoint_final
<<MCI midpoint: procedures>>=
subroutine mci_midpoint_final (object)
class(mci_midpoint_t), intent(inout) :: object
call object%base_final ()
end subroutine mci_midpoint_final
@ %def mci_midpoint_final
@ Output.
<<MCI midpoint: mci midpoint: TBP>>=
procedure :: write => mci_midpoint_write
<<MCI midpoint: procedures>>=
subroutine mci_midpoint_write (object, unit, pacify, md5sum_version)
class(mci_midpoint_t), intent(in) :: object
integer, intent(in), optional :: unit
logical, intent(in), optional :: pacify
logical, intent(in), optional :: md5sum_version
integer :: u, i
u = given_output_unit (unit)
write (u, "(1x,A)") "Single-channel midpoint rule integrator:"
call object%base_write (u, pacify, md5sum_version)
if (object%n_dim_binned < object%n_dim) then
write (u, "(3x,A,99(1x,I0))") "Flat dimensions =", &
pack ([(i, i = 1, object%n_dim)], mask = .not. object%dim_is_binned)
write (u, "(3x,A,I0)") "Number of binned dim = ", object%n_dim_binned
end if
if (object%calls_known) then
write (u, "(3x,A,99(1x,I0))") "Number of bins =", object%n_bin
write (u, "(3x,A,I0)") "Number of calls = ", object%n_calls
if (object%n_calls_pos /= object%n_calls) then
write (u, "(3x,A,I0)") " positive value = ", object%n_calls_pos
write (u, "(3x,A,I0)") " zero value = ", object%n_calls_nul
write (u, "(3x,A,I0)") " negative value = ", object%n_calls_neg
write (u, "(3x,A,ES17.10)") &
"Integral (pos. part) = ", object%integral_pos
write (u, "(3x,A,ES17.10)") &
"Integral (neg. part) = ", object%integral_neg
end if
end if
if (object%max_known) then
write (u, "(3x,A,ES17.10)") "Maximum of integrand = ", object%max
write (u, "(3x,A,ES17.10)") "Minimum of integrand = ", object%min
if (object%min /= object%min_abs) then
write (u, "(3x,A,ES17.10)") "Maximum (abs. value) = ", object%max_abs
write (u, "(3x,A,ES17.10)") "Minimum (abs. value) = ", object%min_abs
end if
end if
if (allocated (object%rng)) call object%rng%write (u)
end subroutine mci_midpoint_write
@ %def mci_midpoint_write
@ Startup message: short version.
<<MCI midpoint: mci midpoint: TBP>>=
procedure :: startup_message => mci_midpoint_startup_message
<<MCI midpoint: procedures>>=
subroutine mci_midpoint_startup_message (mci, unit, n_calls)
class(mci_midpoint_t), intent(in) :: mci
integer, intent(in), optional :: unit, n_calls
call mci%base_startup_message (unit = unit, n_calls = n_calls)
if (mci%n_dim_binned < mci%n_dim) then
write (msg_buffer, "(A,2(1x,I0,1x,A))") &
"Integrator: Midpoint rule:", &
mci%n_dim_binned, "binned dimensions"
else
write (msg_buffer, "(A,2(1x,I0,1x,A))") &
"Integrator: Midpoint rule"
end if
call msg_message (unit = unit)
end subroutine mci_midpoint_startup_message
@ %def mci_midpoint_startup_message
@ Log entry: just headline.
<<MCI midpoint: mci midpoint: TBP>>=
procedure :: write_log_entry => mci_midpoint_write_log_entry
<<MCI midpoint: procedures>>=
subroutine mci_midpoint_write_log_entry (mci, u)
class(mci_midpoint_t), intent(in) :: mci
integer, intent(in) :: u
write (u, "(1x,A)") "MC Integrator is Midpoint rule"
end subroutine mci_midpoint_write_log_entry
@ %def mci_midpoint_write_log_entry
@ MD5 sum: nothing.
<<MCI midpoint: mci midpoint: TBP>>=
procedure :: compute_md5sum => mci_midpoint_compute_md5sum
<<MCI midpoint: procedures>>=
subroutine mci_midpoint_compute_md5sum (mci, pacify)
class(mci_midpoint_t), intent(inout) :: mci
logical, intent(in), optional :: pacify
end subroutine mci_midpoint_compute_md5sum
@ %def mci_midpoint_compute_md5sum
@ The number of channels must be one.
<<MCI midpoint: mci midpoint: TBP>>=
procedure :: set_dimensions => mci_midpoint_set_dimensions
<<MCI midpoint: procedures>>=
subroutine mci_midpoint_set_dimensions (mci, n_dim, n_channel)
class(mci_midpoint_t), intent(inout) :: mci
integer, intent(in) :: n_dim
integer, intent(in) :: n_channel
if (n_channel == 1) then
mci%n_channel = n_channel
mci%n_dim = n_dim
allocate (mci%dim_is_binned (mci%n_dim))
mci%dim_is_binned = .true.
mci%n_dim_binned = count (mci%dim_is_binned)
allocate (mci%n_bin (mci%n_dim))
mci%n_bin = 0
else
call msg_fatal ("Attempt to initialize single-channel integrator &
&for multiple channels")
end if
end subroutine mci_midpoint_set_dimensions
@ %def mci_midpoint_set_dimensions
@ Declare particular dimensions as flat. These dimensions will not be binned.
<<MCI midpoint: mci midpoint: TBP>>=
procedure :: declare_flat_dimensions => mci_midpoint_declare_flat_dimensions
<<MCI midpoint: procedures>>=
subroutine mci_midpoint_declare_flat_dimensions (mci, dim_flat)
class(mci_midpoint_t), intent(inout) :: mci
integer, dimension(:), intent(in) :: dim_flat
integer :: d
mci%n_dim_binned = mci%n_dim - size (dim_flat)
do d = 1, size (dim_flat)
mci%dim_is_binned(dim_flat(d)) = .false.
end do
mci%n_dim_binned = count (mci%dim_is_binned)
end subroutine mci_midpoint_declare_flat_dimensions
@ %def mci_midpoint_declare_flat_dimensions
@ Declare particular channels as equivalent. This has no effect.
<<MCI midpoint: mci midpoint: TBP>>=
procedure :: declare_equivalences => mci_midpoint_ignore_equivalences
<<MCI midpoint: procedures>>=
subroutine mci_midpoint_ignore_equivalences (mci, channel, dim_offset)
class(mci_midpoint_t), intent(inout) :: mci
type(phs_channel_t), dimension(:), intent(in) :: channel
integer, intent(in) :: dim_offset
end subroutine mci_midpoint_ignore_equivalences
@ %def mci_midpoint_ignore_equivalences
@ Allocate instance with matching type.
<<MCI midpoint: mci midpoint: TBP>>=
procedure :: allocate_instance => mci_midpoint_allocate_instance
<<MCI midpoint: procedures>>=
subroutine mci_midpoint_allocate_instance (mci, mci_instance)
class(mci_midpoint_t), intent(in) :: mci
class(mci_instance_t), intent(out), pointer :: mci_instance
allocate (mci_midpoint_instance_t :: mci_instance)
end subroutine mci_midpoint_allocate_instance
@ %def mci_midpoint_allocate_instance
@ Integrate. The number of dimensions is arbitrary. We make sure
that the number of calls is evenly distributed among the dimensions.
The actual number of calls will typically be smaller than the
requested number, but never smaller than 1.
The sampling over a variable number of dimensions implies a variable
number of nested loops. We implement this by a recursive subroutine,
one loop in each recursion level.
The number of iterations [[n_it]] is ignored. Also, the error is set
to zero in the current implementation.
With this integrator, we allow the calculation to abort immediately when
forced by a signal. There is no state that we can save, hence we do not catch
an interrupt.
<<MCI midpoint: mci midpoint: TBP>>=
procedure :: integrate => mci_midpoint_integrate
<<MCI midpoint: procedures>>=
subroutine mci_midpoint_integrate (mci, instance, sampler, n_it, n_calls, &
results, pacify)
class(mci_midpoint_t), intent(inout) :: mci
class(mci_instance_t), intent(inout), target :: instance
class(mci_sampler_t), intent(inout), target :: sampler
integer, intent(in) :: n_it
integer, intent(in) :: n_calls
logical, intent(in), optional :: pacify
class(mci_results_t), intent(inout), optional :: results
real(default), dimension(:), allocatable :: x
real(default) :: integral, integral_pos, integral_neg
integer :: n_bin
select type (instance)
type is (mci_midpoint_instance_t)
allocate (x (mci%n_dim))
integral = 0
integral_pos = 0
integral_neg = 0
select case (mci%n_dim_binned)
case (1)
n_bin = n_calls
case (2:)
n_bin = max (int (n_calls ** (1. / mci%n_dim_binned)), 1)
end select
where (mci%dim_is_binned)
mci%n_bin = n_bin
elsewhere
mci%n_bin = 1
end where
mci%n_calls = product (mci%n_bin)
mci%n_calls_pos = 0
mci%n_calls_nul = 0
mci%n_calls_neg = 0
mci%calls_known = .true.
call sample_dim (mci%n_dim)
mci%integral = integral / mci%n_calls
mci%integral_pos = integral_pos / mci%n_calls
mci%integral_neg = integral_neg / mci%n_calls
mci%integral_known = .true.
call instance%set_max ()
if (present (results)) then
call results%record (1, mci%n_calls, &
mci%integral, mci%error, mci%efficiency)
end if
end select
contains
recursive subroutine sample_dim (d)
integer, intent(in) :: d
integer :: i
real(default) :: value
do i = 1, mci%n_bin(d)
x(d) = (i - 0.5_default) / mci%n_bin(d)
if (d > 1) then
call sample_dim (d - 1)
else
if (signal_is_pending ()) return
call instance%evaluate (sampler, 1, x)
value = instance%get_value ()
if (value > 0) then
mci%n_calls_pos = mci%n_calls_pos + 1
integral = integral + value
integral_pos = integral_pos + value
else if (value == 0) then
mci%n_calls_nul = mci%n_calls_nul + 1
else
mci%n_calls_neg = mci%n_calls_neg + 1
integral = integral + value
integral_neg = integral_neg + value
end if
end if
end do
end subroutine sample_dim
end subroutine mci_midpoint_integrate
@ %def mci_midpoint_integrate
@ Simulation initializer and finalizer: nothing to do here.
<<MCI midpoint: mci midpoint: TBP>>=
procedure :: prepare_simulation => mci_midpoint_ignore_prepare_simulation
<<MCI midpoint: procedures>>=
subroutine mci_midpoint_ignore_prepare_simulation (mci)
class(mci_midpoint_t), intent(inout) :: mci
end subroutine mci_midpoint_ignore_prepare_simulation
@ %def mci_midpoint_ignore_prepare_simulation
@ Generate weighted event.
<<MCI midpoint: mci midpoint: TBP>>=
procedure :: generate_weighted_event => mci_midpoint_generate_weighted_event
<<MCI midpoint: procedures>>=
subroutine mci_midpoint_generate_weighted_event (mci, instance, sampler)
class(mci_midpoint_t), intent(inout) :: mci
class(mci_instance_t), intent(inout), target :: instance
class(mci_sampler_t), intent(inout), target :: sampler
real(default), dimension(mci%n_dim) :: x
select type (instance)
type is (mci_midpoint_instance_t)
call mci%rng%generate (x)
call instance%evaluate (sampler, 1, x)
instance%excess_weight = 0
end select
end subroutine mci_midpoint_generate_weighted_event
@ %def mci_midpoint_generate_weighted_event
@ For unweighted events, we generate weighted events and apply a
simple rejection step to the relative event weight, until an event
passes.
Note that we use the [[max_abs]] value stored in the configuration
record, not the one stored in the instance. The latter may change
during event generation. After an event generation pass is over, we
may update the value for a subsequent pass.
<<MCI midpoint: mci midpoint: TBP>>=
procedure :: generate_unweighted_event => &
mci_midpoint_generate_unweighted_event
<<MCI midpoint: procedures>>=
subroutine mci_midpoint_generate_unweighted_event (mci, instance, sampler)
class(mci_midpoint_t), intent(inout) :: mci
class(mci_instance_t), intent(inout), target :: instance
class(mci_sampler_t), intent(inout), target :: sampler
real(default) :: x, norm, int
select type (instance)
type is (mci_midpoint_instance_t)
if (mci%max_known .and. mci%max_abs > 0) then
norm = abs (mci%max_abs * instance%safety_factor)
REJECTION: do
call mci%generate_weighted_event (instance, sampler)
if (sampler%is_valid ()) then
call mci%rng%generate (x)
int = abs (instance%integrand)
if (x * norm <= int) then
if (norm > 0 .and. norm < int) then
instance%excess_weight = int / norm - 1
end if
exit REJECTION
end if
end if
if (signal_is_pending ()) return
end do REJECTION
else
call msg_fatal ("Unweighted event generation: &
&maximum of integrand is zero or unknown")
end if
end select
end subroutine mci_midpoint_generate_unweighted_event
@ %def mci_midpoint_generate_unweighted_event
@ Rebuild an event, using the [[state]] input.
<<MCI midpoint: mci midpoint: TBP>>=
procedure :: rebuild_event => mci_midpoint_rebuild_event
<<MCI midpoint: procedures>>=
subroutine mci_midpoint_rebuild_event (mci, instance, sampler, state)
class(mci_midpoint_t), intent(inout) :: mci
class(mci_instance_t), intent(inout) :: instance
class(mci_sampler_t), intent(inout) :: sampler
class(mci_state_t), intent(in) :: state
select type (instance)
type is (mci_midpoint_instance_t)
call instance%recall (sampler, state)
end select
end subroutine mci_midpoint_rebuild_event
@ %def mci_midpoint_rebuild_event
@
\subsection{Integrator instance}
Covering the case of flat dimensions, we store a complete [[x]] array. This
is filled when generating events.
<<MCI midpoint: public>>=
public :: mci_midpoint_instance_t
<<MCI midpoint: types>>=
type, extends (mci_instance_t) :: mci_midpoint_instance_t
type(mci_midpoint_t), pointer :: mci => null ()
logical :: max_known = .false.
real(default) :: max = 0
real(default) :: min = 0
real(default) :: max_abs = 0
real(default) :: min_abs = 0
real(default) :: safety_factor = 1
real(default) :: excess_weight = 0
contains
<<MCI midpoint: mci midpoint instance: TBP>>
end type mci_midpoint_instance_t
@ %def mci_midpoint_instance_t
@ Output.
<<MCI midpoint: mci midpoint instance: TBP>>=
procedure :: write => mci_midpoint_instance_write
<<MCI midpoint: procedures>>=
subroutine mci_midpoint_instance_write (object, unit, pacify)
class(mci_midpoint_instance_t), intent(in) :: object
integer, intent(in), optional :: unit
logical, intent(in), optional :: pacify
integer :: u
u = given_output_unit (unit)
write (u, "(1x,A,9(1x,F12.10))") "x =", object%x(:,1)
write (u, "(1x,A,ES19.12)") "Integrand = ", object%integrand
write (u, "(1x,A,ES19.12)") "Weight = ", object%mci_weight
if (object%safety_factor /= 1) then
write (u, "(1x,A,ES19.12)") "Safety f = ", object%safety_factor
end if
if (object%excess_weight /= 0) then
write (u, "(1x,A,ES19.12)") "Excess = ", object%excess_weight
end if
if (object%max_known) then
write (u, "(1x,A,ES19.12)") "Maximum = ", object%max
write (u, "(1x,A,ES19.12)") "Minimum = ", object%min
if (object%min /= object%min_abs) then
write (u, "(1x,A,ES19.12)") "Max.(abs) = ", object%max_abs
write (u, "(1x,A,ES19.12)") "Min.(abs) = ", object%min_abs
end if
end if
end subroutine mci_midpoint_instance_write
@ %def mci_midpoint_instance_write
@ The finalizer is empty.
<<MCI midpoint: mci midpoint instance: TBP>>=
procedure :: final => mci_midpoint_instance_final
<<MCI midpoint: procedures>>=
subroutine mci_midpoint_instance_final (object)
class(mci_midpoint_instance_t), intent(inout) :: object
end subroutine mci_midpoint_instance_final
@ %def mci_midpoint_instance_final
@ Initializer.
<<MCI midpoint: mci midpoint instance: TBP>>=
procedure :: init => mci_midpoint_instance_init
<<MCI midpoint: procedures>>=
subroutine mci_midpoint_instance_init (mci_instance, mci)
class(mci_midpoint_instance_t), intent(out) :: mci_instance
class(mci_t), intent(in), target :: mci
call mci_instance%base_init (mci)
select type (mci)
type is (mci_midpoint_t)
mci_instance%mci => mci
call mci_instance%get_max ()
mci_instance%selected_channel = 1
end select
end subroutine mci_midpoint_instance_init
@ %def mci_midpoint_instance_init
@ Copy the stored extrema of the integrand in the instance record.
<<MCI midpoint: mci midpoint instance: TBP>>=
procedure :: get_max => mci_midpoint_instance_get_max
<<MCI midpoint: procedures>>=
subroutine mci_midpoint_instance_get_max (instance)
class(mci_midpoint_instance_t), intent(inout) :: instance
associate (mci => instance%mci)
if (mci%max_known) then
instance%max_known = .true.
instance%max = mci%max
instance%min = mci%min
instance%max_abs = mci%max_abs
instance%min_abs = mci%min_abs
end if
end associate
end subroutine mci_midpoint_instance_get_max
@ %def mci_midpoint_instance_get_max
@ Reverse operations: recall the extrema, but only if they are wider
than the extrema already stored in the configuration. Also recalculate the
efficiency value.
<<MCI midpoint: mci midpoint instance: TBP>>=
procedure :: set_max => mci_midpoint_instance_set_max
<<MCI midpoint: procedures>>=
subroutine mci_midpoint_instance_set_max (instance)
class(mci_midpoint_instance_t), intent(inout) :: instance
associate (mci => instance%mci)
if (instance%max_known) then
if (mci%max_known) then
mci%max = max (mci%max, instance%max)
mci%min = min (mci%min, instance%min)
mci%max_abs = max (mci%max_abs, instance%max_abs)
mci%min_abs = min (mci%min_abs, instance%min_abs)
else
mci%max = instance%max
mci%min = instance%min
mci%max_abs = instance%max_abs
mci%min_abs = instance%min_abs
mci%max_known = .true.
end if
if (mci%max_abs /= 0) then
if (mci%integral_neg == 0) then
mci%efficiency = mci%integral / mci%max_abs
mci%efficiency_known = .true.
else if (mci%n_calls /= 0) then
mci%efficiency = &
(mci%integral_pos - mci%integral_neg) / mci%max_abs
mci%efficiency_known = .true.
end if
end if
end if
end associate
end subroutine mci_midpoint_instance_set_max
@ %def mci_midpoint_instance_set_max
@ The weight is the Jacobian of the mapping for the only channel.
<<MCI midpoint: mci midpoint instance: TBP>>=
procedure :: compute_weight => mci_midpoint_instance_compute_weight
<<MCI midpoint: procedures>>=
subroutine mci_midpoint_instance_compute_weight (mci, c)
class(mci_midpoint_instance_t), intent(inout) :: mci
integer, intent(in) :: c
select case (c)
case (1)
mci%mci_weight = mci%f(1)
case default
call msg_fatal ("MCI midpoint integrator: only single channel supported")
end select
end subroutine mci_midpoint_instance_compute_weight
@ %def mci_midpoint_instance_compute_weight
@ Record the integrand. Update stored values for maximum and minimum.
<<MCI midpoint: mci midpoint instance: TBP>>=
procedure :: record_integrand => mci_midpoint_instance_record_integrand
<<MCI midpoint: procedures>>=
subroutine mci_midpoint_instance_record_integrand (mci, integrand)
class(mci_midpoint_instance_t), intent(inout) :: mci
real(default), intent(in) :: integrand
mci%integrand = integrand
if (mci%max_known) then
mci%max = max (mci%max, integrand)
mci%min = min (mci%min, integrand)
mci%max_abs = max (mci%max_abs, abs (integrand))
mci%min_abs = min (mci%min_abs, abs (integrand))
else
mci%max = integrand
mci%min = integrand
mci%max_abs = abs (integrand)
mci%min_abs = abs (integrand)
mci%max_known = .true.
end if
end subroutine mci_midpoint_instance_record_integrand
@ %def mci_midpoint_instance_record_integrand
@ We store the safety factor, otherwise nothing to do here.
<<MCI midpoint: mci midpoint instance: TBP>>=
procedure :: init_simulation => mci_midpoint_instance_init_simulation
procedure :: final_simulation => mci_midpoint_instance_final_simulation
<<MCI midpoint: procedures>>=
subroutine mci_midpoint_instance_init_simulation (instance, safety_factor)
class(mci_midpoint_instance_t), intent(inout) :: instance
real(default), intent(in), optional :: safety_factor
if (present (safety_factor)) instance%safety_factor = safety_factor
end subroutine mci_midpoint_instance_init_simulation
subroutine mci_midpoint_instance_final_simulation (instance)
class(mci_midpoint_instance_t), intent(inout) :: instance
end subroutine mci_midpoint_instance_final_simulation
@ %def mci_midpoint_instance_init_simulation
@ %def mci_midpoint_instance_final_simulation
@ Return excess weight for the current event.
<<MCI midpoint: mci midpoint instance: TBP>>=
procedure :: get_event_excess => mci_midpoint_instance_get_event_excess
<<MCI midpoint: procedures>>=
function mci_midpoint_instance_get_event_excess (mci) result (excess)
class(mci_midpoint_instance_t), intent(in) :: mci
real(default) :: excess
excess = mci%excess_weight
end function mci_midpoint_instance_get_event_excess
@ %def mci_midpoint_instance_get_event_excess
@
\subsection{Unit tests}
Test module, followed by the corresponding implementation module.
<<[[mci_midpoint_ut.f90]]>>=
<<File header>>
module mci_midpoint_ut
use unit_tests
use mci_midpoint_uti
<<Standard module head>>
<<MCI midpoint: public test>>
contains
<<MCI midpoint: test driver>>
end module mci_midpoint_ut
@ %def mci_midpoint_ut
@
<<[[mci_midpoint_uti.f90]]>>=
<<File header>>
module mci_midpoint_uti
<<Use kinds>>
use io_units
use rng_base
use mci_base
use mci_midpoint
use rng_base_ut, only: rng_test_t
<<Standard module head>>
<<MCI midpoint: test declarations>>
<<MCI midpoint: test types>>
contains
<<MCI midpoint: tests>>
end module mci_midpoint_uti
@ %def mci_midpoint_ut
@ API: driver for the unit tests below.
<<MCI midpoint: public test>>=
public :: mci_midpoint_test
<<MCI midpoint: test driver>>=
subroutine mci_midpoint_test (u, results)
integer, intent(in) :: u
type(test_results_t), intent(inout) :: results
<<MCI midpoint: execute tests>>
end subroutine mci_midpoint_test
@ %def mci_midpoint_test
@
\subsubsection{Test sampler}
A test sampler object should implement a function with known integral that
we can use to check the integrator.
This is the function $f(x) = 3 x^2$ with integral $\int_0^1
f(x)\,dx=1$ and maximum $f(1)=3$. If the integration dimension is
greater than one, the function is extended as a constant in the other
dimension(s).
Mimicking the behavior of a process object, we store the argument
and result inside the sampler, so we can [[fetch]] results.
<<MCI midpoint: test types>>=
type, extends (mci_sampler_t) :: test_sampler_1_t
real(default), dimension(:), allocatable :: x
real(default) :: val
contains
<<MCI midpoint: test sampler 1: TBP>>
end type test_sampler_1_t
@ %def test_sampler_1_t
@ Output: There is nothing stored inside, so just print an informative line.
<<MCI midpoint: test sampler 1: TBP>>=
procedure :: write => test_sampler_1_write
<<MCI midpoint: tests>>=
subroutine test_sampler_1_write (object, unit, testflag)
class(test_sampler_1_t), intent(in) :: object
integer, intent(in), optional :: unit
logical, intent(in), optional :: testflag
integer :: u
u = given_output_unit (unit)
write (u, "(1x,A)") "Test sampler: f(x) = 3 x^2"
end subroutine test_sampler_1_write
@ %def test_sampler_1_write
@ Evaluation: compute the function value. The output $x$ parameter
(only one channel) is identical to the input $x$, and the Jacobian is 1.
<<MCI midpoint: test sampler 1: TBP>>=
procedure :: evaluate => test_sampler_1_evaluate
<<MCI midpoint: tests>>=
subroutine test_sampler_1_evaluate (sampler, c, x_in, val, x, f)
class(test_sampler_1_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
if (allocated (sampler%x)) deallocate (sampler%x)
allocate (sampler%x (size (x_in)))
sampler%x = x_in
sampler%val = 3 * x_in(1) ** 2
call sampler%fetch (val, x, f)
end subroutine test_sampler_1_evaluate
@ %def test_sampler_1_evaluate
@ The point is always valid.
<<MCI midpoint: test sampler 1: TBP>>=
procedure :: is_valid => test_sampler_1_is_valid
<<MCI midpoint: tests>>=
function test_sampler_1_is_valid (sampler) result (valid)
class(test_sampler_1_t), intent(in) :: sampler
logical :: valid
valid = .true.
end function test_sampler_1_is_valid
@ %def test_sampler_1_is_valid
@ Rebuild: compute all but the function value.
<<MCI midpoint: test sampler 1: TBP>>=
procedure :: rebuild => test_sampler_1_rebuild
<<MCI midpoint: tests>>=
subroutine test_sampler_1_rebuild (sampler, c, x_in, val, x, f)
class(test_sampler_1_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
if (allocated (sampler%x)) deallocate (sampler%x)
allocate (sampler%x (size (x_in)))
sampler%x = x_in
sampler%val = val
x(:,1) = sampler%x
f = 1
end subroutine test_sampler_1_rebuild
@ %def test_sampler_1_rebuild
@ Extract the results.
<<MCI midpoint: test sampler 1: TBP>>=
procedure :: fetch => test_sampler_1_fetch
<<MCI midpoint: tests>>=
subroutine test_sampler_1_fetch (sampler, val, x, f)
class(test_sampler_1_t), intent(in) :: sampler
real(default), intent(out) :: val
real(default), dimension(:,:), intent(out) :: x
real(default), dimension(:), intent(out) :: f
val = sampler%val
x(:,1) = sampler%x
f = 1
end subroutine test_sampler_1_fetch
@ %def test_sampler_1_fetch
@
This is the function $f(x) = 3 x^2 + 2 y$ with integral $\int_0^1
f(x,y)\,dx\,dy=2$ and maximum $f(1)=5$.
<<MCI midpoint: test types>>=
type, extends (mci_sampler_t) :: test_sampler_2_t
real(default) :: val
real(default), dimension(2) :: x
contains
<<MCI midpoint: test sampler 2: TBP>>
end type test_sampler_2_t
@ %def test_sampler_2_t
@ Output: There is nothing stored inside, so just print an informative line.
<<MCI midpoint: test sampler 2: TBP>>=
procedure :: write => test_sampler_2_write
<<MCI midpoint: tests>>=
subroutine test_sampler_2_write (object, unit, testflag)
class(test_sampler_2_t), intent(in) :: object
integer, intent(in), optional :: unit
logical, intent(in), optional :: testflag
integer :: u
u = given_output_unit (unit)
write (u, "(1x,A)") "Test sampler: f(x) = 3 x^2 + 2 y"
end subroutine test_sampler_2_write
@ %def test_sampler_2_write
@ Evaluate: compute the function value. The output $x$ parameter
(only one channel) is identical to the input $x$, and the Jacobian is 1.
<<MCI midpoint: test sampler 2: TBP>>=
procedure :: evaluate => test_sampler_2_evaluate
<<MCI midpoint: tests>>=
subroutine test_sampler_2_evaluate (sampler, c, x_in, val, x, f)
class(test_sampler_2_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
sampler%x = x_in
sampler%val = 3 * x_in(1) ** 2 + 2 * x_in(2)
call sampler%fetch (val, x, f)
end subroutine test_sampler_2_evaluate
@ %def test_sampler_2_evaluate
@ The point is always valid.
<<MCI midpoint: test sampler 2: TBP>>=
procedure :: is_valid => test_sampler_2_is_valid
<<MCI midpoint: tests>>=
function test_sampler_2_is_valid (sampler) result (valid)
class(test_sampler_2_t), intent(in) :: sampler
logical :: valid
valid = .true.
end function test_sampler_2_is_valid
@ %def test_sampler_2_is_valid
@ Rebuild: compute all but the function value.
<<MCI midpoint: test sampler 2: TBP>>=
procedure :: rebuild => test_sampler_2_rebuild
<<MCI midpoint: tests>>=
subroutine test_sampler_2_rebuild (sampler, c, x_in, val, x, f)
class(test_sampler_2_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
sampler%x = x_in
sampler%val = val
x(:,1) = sampler%x
f = 1
end subroutine test_sampler_2_rebuild
@ %def test_sampler_2_rebuild
<<MCI midpoint: test sampler 2: TBP>>=
procedure :: fetch => test_sampler_2_fetch
<<MCI midpoint: tests>>=
subroutine test_sampler_2_fetch (sampler, val, x, f)
class(test_sampler_2_t), intent(in) :: sampler
real(default), intent(out) :: val
real(default), dimension(:,:), intent(out) :: x
real(default), dimension(:), intent(out) :: f
val = sampler%val
x(:,1) = sampler%x
f = 1
end subroutine test_sampler_2_fetch
@ %def test_sampler_2_fetch
@
This is the function $f(x) = (1 - 3 x^2)\,\theta(x-1/2)$ with integral
$\int_0^1 f(x)\,dx=-3/8$, minimum $f(1)=-2$ and maximum $f(1/2)=1/4$.
If the integration dimension is greater than one, the function is
extended as a constant in the other dimension(s).
<<MCI midpoint: test types>>=
type, extends (mci_sampler_t) :: test_sampler_4_t
real(default) :: val
real(default), dimension(:), allocatable :: x
contains
<<MCI midpoint: test sampler 4: TBP>>
end type test_sampler_4_t
@ %def test_sampler_4_t
@ Output: There is nothing stored inside, so just print an informative line.
<<MCI midpoint: test sampler 4: TBP>>=
procedure :: write => test_sampler_4_write
<<MCI midpoint: tests>>=
subroutine test_sampler_4_write (object, unit, testflag)
class(test_sampler_4_t), intent(in) :: object
integer, intent(in), optional :: unit
logical, intent(in), optional :: testflag
integer :: u
u = given_output_unit (unit)
write (u, "(1x,A)") "Test sampler: f(x) = 1 - 3 x^2"
end subroutine test_sampler_4_write
@ %def test_sampler_4_write
@ Evaluation: compute the function value. The output $x$ parameter
(only one channel) is identical to the input $x$, and the Jacobian is 1.
<<MCI midpoint: test sampler 4: TBP>>=
procedure :: evaluate => test_sampler_4_evaluate
<<MCI midpoint: tests>>=
subroutine test_sampler_4_evaluate (sampler, c, x_in, val, x, f)
class(test_sampler_4_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
if (x_in(1) >= .5_default) then
sampler%val = 1 - 3 * x_in(1) ** 2
else
sampler%val = 0
end if
if (.not. allocated (sampler%x)) allocate (sampler%x (size (x_in)))
sampler%x = x_in
call sampler%fetch (val, x, f)
end subroutine test_sampler_4_evaluate
@ %def test_sampler_4_evaluate
@ The point is always valid.
<<MCI midpoint: test sampler 4: TBP>>=
procedure :: is_valid => test_sampler_4_is_valid
<<MCI midpoint: tests>>=
function test_sampler_4_is_valid (sampler) result (valid)
class(test_sampler_4_t), intent(in) :: sampler
logical :: valid
valid = .true.
end function test_sampler_4_is_valid
@ %def test_sampler_4_is_valid
@ Rebuild: compute all but the function value.
<<MCI midpoint: test sampler 4: TBP>>=
procedure :: rebuild => test_sampler_4_rebuild
<<MCI midpoint: tests>>=
subroutine test_sampler_4_rebuild (sampler, c, x_in, val, x, f)
class(test_sampler_4_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
sampler%x = x_in
sampler%val = val
x(:,1) = sampler%x
f = 1
end subroutine test_sampler_4_rebuild
@ %def test_sampler_4_rebuild
<<MCI midpoint: test sampler 4: TBP>>=
procedure :: fetch => test_sampler_4_fetch
<<MCI midpoint: tests>>=
subroutine test_sampler_4_fetch (sampler, val, x, f)
class(test_sampler_4_t), intent(in) :: sampler
real(default), intent(out) :: val
real(default), dimension(:,:), intent(out) :: x
real(default), dimension(:), intent(out) :: f
val = sampler%val
x(:,1) = sampler%x
f = 1
end subroutine test_sampler_4_fetch
@ %def test_sampler_4_fetch
@
\subsubsection{One-dimensional integration}
Construct an integrator and use it for a one-dimensional sampler.
<<MCI midpoint: execute tests>>=
call test (mci_midpoint_1, "mci_midpoint_1", &
"one-dimensional integral", &
u, results)
<<MCI midpoint: test declarations>>=
public :: mci_midpoint_1
<<MCI midpoint: tests>>=
subroutine mci_midpoint_1 (u)
integer, intent(in) :: u
class(mci_t), allocatable, target :: mci
class(mci_instance_t), pointer :: mci_instance => null ()
class(mci_sampler_t), allocatable :: sampler
write (u, "(A)") "* Test output: mci_midpoint_1"
write (u, "(A)") "* Purpose: integrate function in one dimension"
write (u, "(A)")
write (u, "(A)") "* Initialize integrator"
write (u, "(A)")
allocate (mci_midpoint_t :: mci)
call mci%set_dimensions (1, 1)
call mci%write (u)
write (u, "(A)")
write (u, "(A)") "* Initialize instance"
write (u, "(A)")
call mci%allocate_instance (mci_instance)
call mci_instance%init (mci)
write (u, "(A)") "* Initialize test sampler"
write (u, "(A)")
allocate (test_sampler_1_t :: sampler)
call sampler%write (u)
write (u, "(A)")
write (u, "(A)") "* Evaluate for x = 0.8"
write (u, "(A)")
call mci_instance%evaluate (sampler, 1, [0.8_default])
call mci_instance%write (u)
write (u, "(A)")
write (u, "(A)") "* Evaluate for x = 0.7"
write (u, "(A)")
call mci_instance%evaluate (sampler, 1, [0.7_default])
call mci_instance%write (u)
write (u, "(A)")
write (u, "(A)") "* Evaluate for x = 0.9"
write (u, "(A)")
call mci_instance%evaluate (sampler, 1, [0.9_default])
call mci_instance%write (u)
write (u, "(A)")
write (u, "(A)") "* Integrate with n_calls = 1000"
write (u, "(A)")
call mci%integrate (mci_instance, sampler, 1, 1000)
call mci%write (u)
call mci_instance%final ()
call mci%final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: mci_midpoint_1"
end subroutine mci_midpoint_1
@ %def mci_midpoint_1
@
\subsubsection{Two-dimensional integration}
Construct an integrator and use it for a two-dimensional sampler.
<<MCI midpoint: execute tests>>=
call test (mci_midpoint_2, "mci_midpoint_2", &
"two-dimensional integral", &
u, results)
<<MCI midpoint: test declarations>>=
public :: mci_midpoint_2
<<MCI midpoint: tests>>=
subroutine mci_midpoint_2 (u)
integer, intent(in) :: u
class(mci_t), allocatable, target :: mci
class(mci_instance_t), pointer :: mci_instance => null ()
class(mci_sampler_t), allocatable :: sampler
write (u, "(A)") "* Test output: mci_midpoint_2"
write (u, "(A)") "* Purpose: integrate function in two dimensions"
write (u, "(A)")
write (u, "(A)") "* Initialize integrator"
write (u, "(A)")
allocate (mci_midpoint_t :: mci)
call mci%set_dimensions (2, 1)
call mci%write (u)
write (u, "(A)")
write (u, "(A)") "* Initialize instance"
write (u, "(A)")
call mci%allocate_instance (mci_instance)
call mci_instance%init (mci)
write (u, "(A)") "* Initialize test sampler"
write (u, "(A)")
allocate (test_sampler_2_t :: sampler)
call sampler%write (u)
write (u, "(A)")
write (u, "(A)") "* Evaluate for x = 0.8, y = 0.2"
write (u, "(A)")
call mci_instance%evaluate (sampler, 1, [0.8_default, 0.2_default])
call mci_instance%write (u)
write (u, "(A)")
write (u, "(A)") "* Integrate with n_calls = 1000"
write (u, "(A)")
call mci%integrate (mci_instance, sampler, 1, 1000)
call mci%write (u)
call mci_instance%final ()
call mci%final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: mci_midpoint_2"
end subroutine mci_midpoint_2
@ %def mci_midpoint_2
@
\subsubsection{Two-dimensional integration with flat dimension}
Construct an integrator and use it for a two-dimensional sampler,
where the function is constant in the second dimension.
<<MCI midpoint: execute tests>>=
call test (mci_midpoint_3, "mci_midpoint_3", &
"two-dimensional integral with flat dimension", &
u, results)
<<MCI midpoint: test declarations>>=
public :: mci_midpoint_3
<<MCI midpoint: tests>>=
subroutine mci_midpoint_3 (u)
integer, intent(in) :: u
class(mci_t), allocatable, target :: mci
class(mci_instance_t), pointer :: mci_instance => null ()
class(mci_sampler_t), allocatable :: sampler
write (u, "(A)") "* Test output: mci_midpoint_3"
write (u, "(A)") "* Purpose: integrate function with one flat dimension"
write (u, "(A)")
write (u, "(A)") "* Initialize integrator"
write (u, "(A)")
allocate (mci_midpoint_t :: mci)
select type (mci)
type is (mci_midpoint_t)
call mci%set_dimensions (2, 1)
call mci%declare_flat_dimensions ([2])
end select
call mci%write (u)
write (u, "(A)")
write (u, "(A)") "* Initialize instance"
write (u, "(A)")
call mci%allocate_instance (mci_instance)
call mci_instance%init (mci)
write (u, "(A)") "* Initialize test sampler"
write (u, "(A)")
allocate (test_sampler_1_t :: sampler)
call sampler%write (u)
write (u, "(A)")
write (u, "(A)") "* Evaluate for x = 0.8, y = 0.2"
write (u, "(A)")
call mci_instance%evaluate (sampler, 1, [0.8_default, 0.2_default])
call mci_instance%write (u)
write (u, "(A)")
write (u, "(A)") "* Integrate with n_calls = 1000"
write (u, "(A)")
call mci%integrate (mci_instance, sampler, 1, 1000)
call mci%write (u)
call mci_instance%final ()
call mci%final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: mci_midpoint_3"
end subroutine mci_midpoint_3
@ %def mci_midpoint_3
@
\subsubsection{Integrand with sign flip}
Construct an integrator and use it for a one-dimensional sampler.
<<MCI midpoint: execute tests>>=
call test (mci_midpoint_4, "mci_midpoint_4", &
"integrand with sign flip", &
u, results)
<<MCI midpoint: test declarations>>=
public :: mci_midpoint_4
<<MCI midpoint: tests>>=
subroutine mci_midpoint_4 (u)
integer, intent(in) :: u
class(mci_t), allocatable, target :: mci
class(mci_instance_t), pointer :: mci_instance => null ()
class(mci_sampler_t), allocatable :: sampler
write (u, "(A)") "* Test output: mci_midpoint_4"
write (u, "(A)") "* Purpose: integrate function with sign flip &
&in one dimension"
write (u, "(A)")
write (u, "(A)") "* Initialize integrator"
write (u, "(A)")
allocate (mci_midpoint_t :: mci)
call mci%set_dimensions (1, 1)
call mci%write (u)
write (u, "(A)")
write (u, "(A)") "* Initialize instance"
write (u, "(A)")
call mci%allocate_instance (mci_instance)
call mci_instance%init (mci)
write (u, "(A)") "* Initialize test sampler"
write (u, "(A)")
allocate (test_sampler_4_t :: sampler)
call sampler%write (u)
write (u, "(A)")
write (u, "(A)") "* Evaluate for x = 0.8"
write (u, "(A)")
call mci_instance%evaluate (sampler, 1, [0.8_default])
call mci_instance%write (u)
write (u, "(A)")
write (u, "(A)") "* Integrate with n_calls = 1000"
write (u, "(A)")
call mci%integrate (mci_instance, sampler, 1, 1000)
call mci%write (u)
call mci_instance%final ()
call mci%final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: mci_midpoint_4"
end subroutine mci_midpoint_4
@ %def mci_midpoint_4
@
\subsubsection{Weighted events}
Generate weighted events. Without rejection, we do not need to know maxima
and minima, so we can start generating events immediately. We have two
dimensions.
<<MCI midpoint: execute tests>>=
call test (mci_midpoint_5, "mci_midpoint_5", &
"weighted events", &
u, results)
<<MCI midpoint: test declarations>>=
public :: mci_midpoint_5
<<MCI midpoint: tests>>=
subroutine mci_midpoint_5 (u)
integer, intent(in) :: u
class(mci_t), allocatable, target :: mci
class(mci_instance_t), pointer :: mci_instance => null ()
class(mci_sampler_t), allocatable :: sampler
class(rng_t), allocatable :: rng
class(mci_state_t), allocatable :: state
write (u, "(A)") "* Test output: mci_midpoint_5"
write (u, "(A)") "* Purpose: generate weighted events"
write (u, "(A)")
write (u, "(A)") "* Initialize integrator"
write (u, "(A)")
allocate (mci_midpoint_t :: mci)
call mci%set_dimensions (2, 1)
call mci%write (u)
write (u, "(A)")
write (u, "(A)") "* Initialize instance"
write (u, "(A)")
call mci%allocate_instance (mci_instance)
call mci_instance%init (mci)
write (u, "(A)") "* Initialize test sampler"
write (u, "(A)")
allocate (test_sampler_2_t :: sampler)
write (u, "(A)") "* Initialize random-number generator"
write (u, "(A)")
allocate (rng_test_t :: rng)
call rng%init ()
call mci%import_rng (rng)
write (u, "(A)") "* Generate weighted event"
write (u, "(A)")
call mci%generate_weighted_event (mci_instance, sampler)
call mci_instance%write (u)
write (u, "(A)")
write (u, "(A)") "* Generate weighted event"
write (u, "(A)")
call mci%generate_weighted_event (mci_instance, sampler)
call mci_instance%write (u)
write (u, "(A)")
write (u, "(A)") "* Store data"
write (u, "(A)")
allocate (state)
call mci_instance%store (state)
call mci_instance%final ()
deallocate (mci_instance)
call state%write (u)
write (u, "(A)")
write (u, "(A)") "* Recall data and rebuild event"
write (u, "(A)")
call mci%allocate_instance (mci_instance)
call mci_instance%init (mci)
call mci%rebuild_event (mci_instance, sampler, state)
call mci_instance%write (u)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call mci_instance%final ()
deallocate (mci_instance)
call mci%final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: mci_midpoint_5"
end subroutine mci_midpoint_5
@ %def mci_midpoint_5
@
\subsubsection{Unweighted events}
Generate unweighted events. The integrand has a sign flip in it.
<<MCI midpoint: execute tests>>=
call test (mci_midpoint_6, "mci_midpoint_6", &
"unweighted events", &
u, results)
<<MCI midpoint: test declarations>>=
public :: mci_midpoint_6
<<MCI midpoint: tests>>=
subroutine mci_midpoint_6 (u)
integer, intent(in) :: u
class(mci_t), allocatable, target :: mci
class(mci_instance_t), pointer :: mci_instance => null ()
class(mci_sampler_t), allocatable :: sampler
class(rng_t), allocatable :: rng
write (u, "(A)") "* Test output: mci_midpoint_6"
write (u, "(A)") "* Purpose: generate unweighted events"
write (u, "(A)")
write (u, "(A)") "* Initialize integrator"
write (u, "(A)")
allocate (mci_midpoint_t :: mci)
call mci%set_dimensions (1, 1)
write (u, "(A)") "* Initialize instance"
write (u, "(A)")
call mci%allocate_instance (mci_instance)
call mci_instance%init (mci)
write (u, "(A)") "* Initialize test sampler"
write (u, "(A)")
allocate (test_sampler_4_t :: sampler)
write (u, "(A)") "* Initialize random-number generator"
write (u, "(A)")
allocate (rng_test_t :: rng)
call rng%init ()
call mci%import_rng (rng)
write (u, "(A)") "* Integrate (determine maximum of integrand"
write (u, "(A)")
call mci%integrate (mci_instance, sampler, 1, 1000)
call mci%write (u)
write (u, "(A)")
write (u, "(A)") "* Generate unweighted event"
write (u, "(A)")
call mci%generate_unweighted_event (mci_instance, sampler)
call mci_instance%write (u)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call mci_instance%final ()
deallocate (mci_instance)
call mci%final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: mci_midpoint_6"
end subroutine mci_midpoint_6
@ %def mci_midpoint_6
@
\subsubsection{Excess weight}
Generate unweighted events. With only 2 points for integration, the
maximum of the integrand is too low, and we produce excess weight.
<<MCI midpoint: execute tests>>=
call test (mci_midpoint_7, "mci_midpoint_7", &
"excess weight", &
u, results)
<<MCI midpoint: test declarations>>=
public :: mci_midpoint_7
<<MCI midpoint: tests>>=
subroutine mci_midpoint_7 (u)
integer, intent(in) :: u
class(mci_t), allocatable, target :: mci
class(mci_instance_t), pointer :: mci_instance => null ()
class(mci_sampler_t), allocatable :: sampler
class(rng_t), allocatable :: rng
write (u, "(A)") "* Test output: mci_midpoint_7"
write (u, "(A)") "* Purpose: generate unweighted event &
&with excess weight"
write (u, "(A)")
write (u, "(A)") "* Initialize integrator"
write (u, "(A)")
allocate (mci_midpoint_t :: mci)
call mci%set_dimensions (1, 1)
write (u, "(A)") "* Initialize instance"
write (u, "(A)")
call mci%allocate_instance (mci_instance)
call mci_instance%init (mci)
write (u, "(A)") "* Initialize test sampler"
write (u, "(A)")
allocate (test_sampler_4_t :: sampler)
write (u, "(A)") "* Initialize random-number generator"
write (u, "(A)")
allocate (rng_test_t :: rng)
call rng%init ()
call mci%import_rng (rng)
write (u, "(A)") "* Integrate (determine maximum of integrand"
write (u, "(A)")
call mci%integrate (mci_instance, sampler, 1, 2)
call mci%write (u)
write (u, "(A)")
write (u, "(A)") "* Generate unweighted event"
write (u, "(A)")
call mci_instance%init_simulation ()
call mci%generate_unweighted_event (mci_instance, sampler)
call mci_instance%write (u)
write (u, "(A)")
write (u, "(A)") "* Use getter methods"
write (u, "(A)")
write (u, "(1x,A,1x,ES19.12)") "weight =", mci_instance%get_event_weight ()
write (u, "(1x,A,1x,ES19.12)") "excess =", mci_instance%get_event_excess ()
write (u, "(A)")
write (u, "(A)") "* Apply safety factor"
write (u, "(A)")
call mci_instance%init_simulation (safety_factor = 2.1_default)
write (u, "(A)") "* Generate unweighted event"
write (u, "(A)")
call mci%generate_unweighted_event (mci_instance, sampler)
call mci_instance%write (u)
write (u, "(A)")
write (u, "(A)") "* Use getter methods"
write (u, "(A)")
write (u, "(1x,A,1x,ES19.12)") "weight =", mci_instance%get_event_weight ()
write (u, "(1x,A,1x,ES19.12)") "excess =", mci_instance%get_event_excess ()
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call mci_instance%final ()
deallocate (mci_instance)
call mci%final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: mci_midpoint_7"
end subroutine mci_midpoint_7
@ %def mci_midpoint_7
@
\clearpage
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{\vamp\ interface}
The standard method for integration is \vamp: the multi-channel
version of the VEGAS algorithm. Each parameterization (channel) of
the hypercube is binned in each dimension. The binning is equally
equidistant, but an iteration of the integration procedure,
the binning is updated for each dimension, according to the variance
distribution of the integrand, summed over all other dimension. In
the next iteration, the binning approximates (hopefully) follows the
integrand more closely, and the accuracy of the result is increased.
Furthermore, the relative weight of the individual channels is also updated
after an iteration.
The bin distribution is denoted as the grid for a channel, which we
can write to file and reuse later.
In our implementation we specify the generic \vamp\ algorithm more
tightly: the number of bins is equal for all dimensions, the initial
weights are all equal. The user controls whether to update bins
and/or weights after each iteration. The integration is organized in
passes, each one consisting of several iterations with a common number
of calls to the integrand. The first passes are intended as warmup,
so the results are displayed but otherwise discarded. In the final
pass, the integration estimates for the individual iterations are
averaged for the final result.
<<[[mci_vamp.f90]]>>=
<<File header>>
module mci_vamp
<<Use kinds>>
<<Use strings>>
use io_units
use constants, only: zero
use format_utils, only: pac_fmt
use format_utils, only: write_separator
use format_defs, only: FMT_12, FMT_14, FMT_17, FMT_19
use diagnostics
use md5
use phs_base
use rng_base
use rng_tao
use vamp !NODEP!
use exceptions !NODEP!
use mci_base
<<Standard module head>>
<<MCI vamp: public>>
<<MCI vamp: types>>
<<MCI vamp: interfaces>>
contains
<<MCI vamp: procedures>>
end module mci_vamp
@ %def mci_vamp
@
\subsection{Grid parameters}
This is a transparent container. It holds the parameters that are
stored in grid files, and are checked when grid files are read.
<<MCI vamp: public>>=
public :: grid_parameters_t
<<MCI vamp: types>>=
type :: grid_parameters_t
integer :: threshold_calls = 0
integer :: min_calls_per_channel = 10
integer :: min_calls_per_bin = 10
integer :: min_bins = 3
integer :: max_bins = 20
logical :: stratified = .true.
logical :: use_vamp_equivalences = .true.
real(default) :: channel_weights_power = 0.25_default
real(default) :: accuracy_goal = 0
real(default) :: error_goal = 0
real(default) :: rel_error_goal = 0
contains
<<MCI vamp: grid parameters: TBP>>
end type grid_parameters_t
@ %def grid_parameters_t
@ I/O:
<<MCI vamp: grid parameters: TBP>>=
procedure :: write => grid_parameters_write
<<MCI vamp: procedures>>=
subroutine grid_parameters_write (object, unit)
class(grid_parameters_t), intent(in) :: object
integer, intent(in), optional :: unit
integer :: u
u = given_output_unit (unit)
write (u, "(3x,A,I0)") "threshold_calls = ", &
object%threshold_calls
write (u, "(3x,A,I0)") "min_calls_per_channel = ", &
object%min_calls_per_channel
write (u, "(3x,A,I0)") "min_calls_per_bin = ", &
object%min_calls_per_bin
write (u, "(3x,A,I0)") "min_bins = ", &
object%min_bins
write (u, "(3x,A,I0)") "max_bins = ", &
object%max_bins
write (u, "(3x,A,L1)") "stratified = ", &
object%stratified
write (u, "(3x,A,L1)") "use_vamp_equivalences = ", &
object%use_vamp_equivalences
write (u, "(3x,A,F10.7)") "channel_weights_power = ", &
object%channel_weights_power
if (object%accuracy_goal > 0) then
write (u, "(3x,A,F10.7)") "accuracy_goal = ", &
object%accuracy_goal
end if
if (object%error_goal > 0) then
write (u, "(3x,A,F10.7)") "error_goal = ", &
object%error_goal
end if
if (object%rel_error_goal > 0) then
write (u, "(3x,A,F10.7)") "rel_error_goal = ", &
object%rel_error_goal
end if
end subroutine grid_parameters_write
@ %def grid_parameters_write
@
\subsection{History parameters}
The history parameters are also stored in a transparent container.
This is not a part of the grid definition, and should not be included
in the MD5 sum.
<<MCI vamp: public>>=
public :: history_parameters_t
<<MCI vamp: types>>=
type :: history_parameters_t
logical :: global = .true.
logical :: global_verbose = .false.
logical :: channel = .false.
logical :: channel_verbose = .false.
contains
<<MCI vamp: history parameters: TBP>>
end type history_parameters_t
@ %def history_parameters_t
@ I/O:
<<MCI vamp: history parameters: TBP>>=
procedure :: write => history_parameters_write
<<MCI vamp: procedures>>=
subroutine history_parameters_write (object, unit)
class(history_parameters_t), intent(in) :: object
integer, intent(in), optional :: unit
integer :: u
u = given_output_unit (unit)
write (u, "(3x,A,L1)") "history(global) = ", object%global
write (u, "(3x,A,L1)") "history(global) verb. = ", object%global_verbose
write (u, "(3x,A,L1)") "history(channels) = ", object%channel
write (u, "(3x,A,L1)") "history(chann.) verb. = ", object%channel_verbose
end subroutine history_parameters_write
@ %def history_parameters_write
@
\subsection{Integration pass}
We store the parameters for each integration pass in a linked list.
<<MCI vamp: types>>=
type :: pass_t
integer :: i_pass = 0
integer :: i_first_it = 0
integer :: n_it = 0
integer :: n_calls = 0
integer :: n_bins = 0
logical :: adapt_grids = .false.
logical :: adapt_weights = .false.
logical :: is_final_pass = .false.
logical :: integral_defined = .false.
integer, dimension(:), allocatable :: calls
integer, dimension(:), allocatable :: calls_valid
real(default), dimension(:), allocatable :: integral
real(default), dimension(:), allocatable :: error
real(default), dimension(:), allocatable :: efficiency
type(vamp_history), dimension(:), allocatable :: v_history
type(vamp_history), dimension(:,:), allocatable :: v_histories
type(pass_t), pointer :: next => null ()
contains
<<MCI vamp: pass: TBP>>
end type pass_t
@ %def pass_t
@ Finalizer. The VAMP histories contain a pointer array.
<<MCI vamp: pass: TBP>>=
procedure :: final => pass_final
<<MCI vamp: procedures>>=
subroutine pass_final (object)
class(pass_t), intent(inout) :: object
if (allocated (object%v_history)) then
call vamp_delete_history (object%v_history)
end if
if (allocated (object%v_histories)) then
call vamp_delete_history (object%v_histories)
end if
end subroutine pass_final
@ %def pass_final
@ Output. Note that the precision of the numerical values should match the
precision for comparing output from file with data.
<<MCI vamp: pass: TBP>>=
procedure :: write => pass_write
<<MCI vamp: procedures>>=
subroutine pass_write (object, unit, pacify)
class(pass_t), intent(in) :: object
integer, intent(in) :: unit
logical, intent(in), optional :: pacify
integer :: u, i
character(len=7) :: fmt
call pac_fmt (fmt, FMT_17, FMT_14, pacify)
u = given_output_unit (unit)
write (u, "(3x,A,I0)") "n_it = ", object%n_it
write (u, "(3x,A,I0)") "n_calls = ", object%n_calls
write (u, "(3x,A,I0)") "n_bins = ", object%n_bins
write (u, "(3x,A,L1)") "adapt grids = ", object%adapt_grids
write (u, "(3x,A,L1)") "adapt weights = ", object%adapt_weights
if (object%integral_defined) then
write (u, "(3x,A)") "Results: [it, calls, valid, integral, error, efficiency]"
do i = 1, object%n_it
write (u, "(5x,I0,2(1x,I0),3(1x," // fmt // "))") &
i, object%calls(i), object%calls_valid(i), object%integral(i), object%error(i), &
object%efficiency(i)
end do
else
write (u, "(3x,A)") "Results: [undefined]"
end if
end subroutine pass_write
@ %def pass_write
@ Read and reconstruct the pass.
<<MCI vamp: pass: TBP>>=
procedure :: read => pass_read
<<MCI vamp: procedures>>=
subroutine pass_read (object, u, n_pass, n_it)
class(pass_t), intent(out) :: object
integer, intent(in) :: u, n_pass, n_it
integer :: i, j
character(80) :: buffer
object%i_pass = n_pass + 1
object%i_first_it = n_it + 1
call read_ival (u, object%n_it)
call read_ival (u, object%n_calls)
call read_ival (u, object%n_bins)
call read_lval (u, object%adapt_grids)
call read_lval (u, object%adapt_weights)
allocate (object%calls (object%n_it), source = 0)
allocate (object%calls_valid (object%n_it), source = 0)
allocate (object%integral (object%n_it), source = 0._default)
allocate (object%error (object%n_it), source = 0._default)
allocate (object%efficiency (object%n_it), source = 0._default)
read (u, "(A)") buffer
select case (trim (adjustl (buffer)))
case ("Results: [it, calls, valid, integral, error, efficiency]")
do i = 1, object%n_it
read (u, *) &
j, object%calls(i), object%calls_valid(i), object%integral(i), object%error(i), &
object%efficiency(i)
end do
object%integral_defined = .true.
case ("Results: [undefined]")
object%integral_defined = .false.
case default
call msg_fatal ("Reading integration pass: corrupted file")
end select
end subroutine pass_read
@ %def pass_read
@ Write the VAMP history for this pass. (The subroutine writes the
whole array at once.)
<<MCI vamp: pass: TBP>>=
procedure :: write_history => pass_write_history
<<MCI vamp: procedures>>=
subroutine pass_write_history (pass, unit)
class(pass_t), intent(in) :: pass
integer, intent(in), optional :: unit
integer :: u
u = given_output_unit (unit)
if (allocated (pass%v_history)) then
call vamp_write_history (u, pass%v_history)
else
write (u, "(1x,A)") "Global history: [undefined]"
end if
if (allocated (pass%v_histories)) then
write (u, "(1x,A)") "Channel histories:"
call vamp_write_history (u, pass%v_histories)
else
write (u, "(1x,A)") "Channel histories: [undefined]"
end if
end subroutine pass_write_history
@ %def pass_write_history
@ Given a number of calls and iterations, compute remaining data.
<<MCI vamp: pass: TBP>>=
procedure :: configure => pass_configure
<<MCI vamp: procedures>>=
subroutine pass_configure (pass, n_it, n_calls, min_calls, &
min_bins, max_bins, min_channel_calls)
class(pass_t), intent(inout) :: pass
integer, intent(in) :: n_it, n_calls, min_channel_calls
integer, intent(in) :: min_calls, min_bins, max_bins
pass%n_it = n_it
if (min_calls /= 0) then
pass%n_bins = max (min_bins, &
min (n_calls / min_calls, max_bins))
else
pass%n_bins = max_bins
end if
pass%n_calls = max (n_calls, max (min_calls, min_channel_calls))
if (pass%n_calls /= n_calls) then
write (msg_buffer, "(A,I0)") "VAMP: too few calls, resetting " &
// "n_calls to ", pass%n_calls
call msg_warning ()
end if
allocate (pass%calls (n_it), source = 0)
allocate (pass%calls_valid (n_it), source = 0)
allocate (pass%integral (n_it), source = 0._default)
allocate (pass%error (n_it), source = 0._default)
allocate (pass%efficiency (n_it), source = 0._default)
end subroutine pass_configure
@ %def pass_configure
@ Allocate the VAMP history and give options. We assume that the
[[configure]] routine above has been executed, so the number of
iterations is known.
<<MCI vamp: pass: TBP>>=
procedure :: configure_history => pass_configure_history
<<MCI vamp: procedures>>=
subroutine pass_configure_history (pass, n_channels, par)
class(pass_t), intent(inout) :: pass
integer, intent(in) :: n_channels
type(history_parameters_t), intent(in) :: par
if (par%global) then
allocate (pass%v_history (pass%n_it))
call vamp_create_history (pass%v_history, &
verbose = par%global_verbose)
end if
if (par%channel) then
allocate (pass%v_histories (pass%n_it, n_channels))
call vamp_create_history (pass%v_histories, &
verbose = par%channel_verbose)
end if
end subroutine pass_configure_history
@ %def pass_configure_history
@ Given two pass objects, compare them. All parameters must match. Where
integrations are done in both (number of calls nonzero), the results must be
equal (up to numerical noise).
The allocated array sizes might be different, but should match up to the
common [[n_it]] value.
<<MCI vamp: interfaces>>=
interface operator (.matches.)
module procedure pass_matches
end interface operator (.matches.)
<<MCI vamp: procedures>>=
function pass_matches (pass, ref) result (ok)
type(pass_t), intent(in) :: pass, ref
integer :: n
logical :: ok
ok = .true.
if (ok) ok = pass%i_pass == ref%i_pass
if (ok) ok = pass%i_first_it == ref%i_first_it
if (ok) ok = pass%n_it == ref%n_it
if (ok) ok = pass%n_calls == ref%n_calls
if (ok) ok = pass%n_bins == ref%n_bins
if (ok) ok = pass%adapt_grids .eqv. ref%adapt_grids
if (ok) ok = pass%adapt_weights .eqv. ref%adapt_weights
if (ok) ok = pass%integral_defined .eqv. ref%integral_defined
if (pass%integral_defined) then
n = pass%n_it
if (ok) ok = all (pass%calls(:n) == ref%calls(:n))
if (ok) ok = all (pass%calls_valid(:n) == ref%calls_valid (:n))
if (ok) ok = all (pass%integral(:n) .matches. ref%integral(:n))
if (ok) ok = all (pass%error(:n) .matches. ref%error(:n))
if (ok) ok = all (pass%efficiency(:n) .matches. ref%efficiency(:n))
end if
end function pass_matches
@ %def pass_matches
@ Update a pass object, given a reference. The parameters must match, except
for the [[n_it]] entry. The number of complete iterations must be less or
equal to the reference, and the number of complete iterations in the reference
must be no larger than [[n_it]]. Where results are present in both passes,
they must match. Where results are present in the reference only, the pass is
updated accordingly.
<<MCI vamp: pass: TBP>>=
procedure :: update => pass_update
<<MCI vamp: procedures>>=
subroutine pass_update (pass, ref, ok)
class(pass_t), intent(inout) :: pass
type(pass_t), intent(in) :: ref
logical, intent(out) :: ok
integer :: n, n_ref
ok = .true.
if (ok) ok = pass%i_pass == ref%i_pass
if (ok) ok = pass%i_first_it == ref%i_first_it
if (ok) ok = pass%n_calls == ref%n_calls
if (ok) ok = pass%n_bins == ref%n_bins
if (ok) ok = pass%adapt_grids .eqv. ref%adapt_grids
if (ok) ok = pass%adapt_weights .eqv. ref%adapt_weights
if (ok) then
if (ref%integral_defined) then
if (.not. allocated (pass%calls)) then
allocate (pass%calls (pass%n_it), source = 0)
allocate (pass%calls_valid (pass%n_it), source = 0)
allocate (pass%integral (pass%n_it), source = 0._default)
allocate (pass%error (pass%n_it), source = 0._default)
allocate (pass%efficiency (pass%n_it), source = 0._default)
end if
n = count (pass%calls /= 0)
n_ref = count (ref%calls /= 0)
ok = n <= n_ref .and. n_ref <= pass%n_it
if (ok) ok = all (pass%calls(:n) == ref%calls(:n))
if (ok) ok = all (pass%calls_valid(:n) == ref%calls_valid(:n))
if (ok) ok = all (pass%integral(:n) .matches. ref%integral(:n))
if (ok) ok = all (pass%error(:n) .matches. ref%error(:n))
if (ok) ok = all (pass%efficiency(:n) .matches. ref%efficiency(:n))
if (ok) then
pass%calls(n+1:n_ref) = ref%calls(n+1:n_ref)
pass%calls_valid(n+1:n_ref) = ref%calls_valid(n+1:n_ref)
pass%integral(n+1:n_ref) = ref%integral(n+1:n_ref)
pass%error(n+1:n_ref) = ref%error(n+1:n_ref)
pass%efficiency(n+1:n_ref) = ref%efficiency(n+1:n_ref)
pass%integral_defined = any (pass%calls /= 0)
end if
end if
end if
end subroutine pass_update
@ %def pass_update
@ Match two real numbers: they are equal up to a tolerance, which is
$10^{-8}$, matching the number of digits that are output by [[pass_write]].
In particular, if one number is exactly zero, the other one must also be zero.
<<MCI vamp: interfaces>>=
interface operator (.matches.)
module procedure real_matches
end interface operator (.matches.)
<<MCI vamp: procedures>>=
elemental function real_matches (x, y) result (ok)
real(default), intent(in) :: x, y
logical :: ok
real(default), parameter :: tolerance = 1.e-8_default
ok = abs (x - y) <= tolerance * max (abs (x), abs (y))
end function real_matches
@ %def real_matches
@ Return the index of the most recent complete integration. If there is none,
return zero.
<<MCI vamp: pass: TBP>>=
procedure :: get_integration_index => pass_get_integration_index
<<MCI vamp: procedures>>=
function pass_get_integration_index (pass) result (n)
class (pass_t), intent(in) :: pass
integer :: n
integer :: i
n = 0
if (allocated (pass%calls)) then
do i = 1, pass%n_it
if (pass%calls(i) == 0) exit
n = i
end do
end if
end function pass_get_integration_index
@ %def pass_get_integration_index
@ Return the most recent integral and error, if available.
<<MCI vamp: pass: TBP>>=
procedure :: get_calls => pass_get_calls
procedure :: get_calls_valid => pass_get_calls_valid
procedure :: get_integral => pass_get_integral
procedure :: get_error => pass_get_error
procedure :: get_efficiency => pass_get_efficiency
<<MCI vamp: procedures>>=
function pass_get_calls (pass) result (calls)
class(pass_t), intent(in) :: pass
integer :: calls
integer :: n
n = pass%get_integration_index ()
if (n /= 0) then
calls = pass%calls(n)
else
calls = 0
end if
end function pass_get_calls
function pass_get_calls_valid (pass) result (calls_valid)
class(pass_t), intent(in) :: pass
integer :: calls_valid
integer :: n
n = pass%get_integration_index ()
if (n /= 0) then
calls_valid = pass%calls_valid(n)
else
calls_valid = 0
end if
end function pass_get_calls_valid
function pass_get_integral (pass) result (integral)
class(pass_t), intent(in) :: pass
real(default) :: integral
integer :: n
n = pass%get_integration_index ()
if (n /= 0) then
integral = pass%integral(n)
else
integral = 0
end if
end function pass_get_integral
function pass_get_error (pass) result (error)
class(pass_t), intent(in) :: pass
real(default) :: error
integer :: n
n = pass%get_integration_index ()
if (n /= 0) then
error = pass%error(n)
else
error = 0
end if
end function pass_get_error
function pass_get_efficiency (pass) result (efficiency)
class(pass_t), intent(in) :: pass
real(default) :: efficiency
integer :: n
n = pass%get_integration_index ()
if (n /= 0) then
efficiency = pass%efficiency(n)
else
efficiency = 0
end if
end function pass_get_efficiency
@ %def pass_get_calls
@ %def pass_get_calls_valid
@ %def pass_get_integral
@ %def pass_get_error
@ %def pass_get_efficiency
@
\subsection{Integrator}
<<MCI vamp: public>>=
public :: mci_vamp_t
<<MCI vamp: types>>=
type, extends (mci_t) :: mci_vamp_t
logical, dimension(:), allocatable :: dim_is_flat
type(grid_parameters_t) :: grid_par
type(history_parameters_t) :: history_par
integer :: min_calls = 0
type(pass_t), pointer :: first_pass => null ()
type(pass_t), pointer :: current_pass => null ()
type(vamp_equivalences_t) :: equivalences
logical :: rebuild = .true.
logical :: check_grid_file = .true.
logical :: grid_filename_set = .false.
logical :: negative_weights = .false.
logical :: verbose = .false.
type(string_t) :: grid_filename
character(32) :: md5sum_adapted = ""
contains
<<MCI vamp: mci vamp: TBP>>
end type mci_vamp_t
@ %def mci_vamp_t
@ Reset: delete integration-pass entries.
<<MCI vamp: mci vamp: TBP>>=
procedure :: reset => mci_vamp_reset
<<MCI vamp: procedures>>=
subroutine mci_vamp_reset (object)
class(mci_vamp_t), intent(inout) :: object
type(pass_t), pointer :: current_pass
do while (associated (object%first_pass))
current_pass => object%first_pass
object%first_pass => current_pass%next
call current_pass%final ()
deallocate (current_pass)
end do
object%current_pass => null ()
end subroutine mci_vamp_reset
@ %def mci_vamp_reset
@ Finalizer: reset and finalize the equivalences list.
<<MCI vamp: mci vamp: TBP>>=
procedure :: final => mci_vamp_final
<<MCI vamp: procedures>>=
subroutine mci_vamp_final (object)
class(mci_vamp_t), intent(inout) :: object
call object%reset ()
call vamp_equivalences_final (object%equivalences)
call object%base_final ()
end subroutine mci_vamp_final
@ %def mci_vamp_final
@ Output. Do not output the grids themselves, this may result in tons
of data.
<<MCI vamp: mci vamp: TBP>>=
procedure :: write => mci_vamp_write
<<MCI vamp: procedures>>=
subroutine mci_vamp_write (object, unit, pacify, md5sum_version)
class(mci_vamp_t), intent(in) :: object
integer, intent(in), optional :: unit
logical, intent(in), optional :: pacify
logical, intent(in), optional :: md5sum_version
type(pass_t), pointer :: current_pass
integer :: u, i
u = given_output_unit (unit)
write (u, "(1x,A)") "VAMP integrator:"
call object%base_write (u, pacify, md5sum_version)
if (allocated (object%dim_is_flat)) then
write (u, "(3x,A,999(1x,I0))") "Flat dimensions =", &
pack ([(i, i = 1, object%n_dim)], object%dim_is_flat)
end if
write (u, "(1x,A)") "Grid parameters:"
call object%grid_par%write (u)
write (u, "(3x,A,I0)") "min_calls = ", object%min_calls
write (u, "(3x,A,L1)") "negative weights = ", &
object%negative_weights
write (u, "(3x,A,L1)") "verbose = ", &
object%verbose
if (object%grid_par%use_vamp_equivalences) then
call vamp_equivalences_write (object%equivalences, u)
end if
current_pass => object%first_pass
do while (associated (current_pass))
write (u, "(1x,A,I0,A)") "Integration pass:"
call current_pass%write (u, pacify)
current_pass => current_pass%next
end do
if (object%md5sum_adapted /= "") then
write (u, "(1x,A,A,A)") "MD5 sum (including results) = '", &
object%md5sum_adapted, "'"
end if
end subroutine mci_vamp_write
@ %def mci_vamp_write
@ Write the history parameters.
<<MCI vamp: mci vamp: TBP>>=
procedure :: write_history_parameters => mci_vamp_write_history_parameters
<<MCI vamp: procedures>>=
subroutine mci_vamp_write_history_parameters (mci, unit)
class(mci_vamp_t), intent(in) :: mci
integer, intent(in), optional :: unit
integer :: u
u = given_output_unit (unit)
write (u, "(1x,A)") "VAMP history parameters:"
call mci%history_par%write (unit)
end subroutine mci_vamp_write_history_parameters
@ %def mci_vamp_write_history_parameters
@ Write the history, iterating over passes. We keep this separate
from the generic [[write]] routine.
<<MCI vamp: mci vamp: TBP>>=
procedure :: write_history => mci_vamp_write_history
<<MCI vamp: procedures>>=
subroutine mci_vamp_write_history (mci, unit)
class(mci_vamp_t), intent(in) :: mci
integer, intent(in), optional :: unit
type(pass_t), pointer :: current_pass
integer :: i_pass
integer :: u
u = given_output_unit (unit)
if (associated (mci%first_pass)) then
write (u, "(1x,A)") "VAMP history (global):"
i_pass = 0
current_pass => mci%first_pass
do while (associated (current_pass))
i_pass = i_pass + 1
write (u, "(1x,A,I0,':')") "Pass #", i_pass
call current_pass%write_history (u)
current_pass => current_pass%next
end do
end if
end subroutine mci_vamp_write_history
@ %def mci_vamp_write_history
@ Compute the MD5 sum, including the configuration MD5 sum and the
printout, which incorporates the current results.
<<MCI vamp: mci vamp: TBP>>=
procedure :: compute_md5sum => mci_vamp_compute_md5sum
<<MCI vamp: procedures>>=
subroutine mci_vamp_compute_md5sum (mci, pacify)
class(mci_vamp_t), intent(inout) :: mci
logical, intent(in), optional :: pacify
integer :: u
mci%md5sum_adapted = ""
u = free_unit ()
open (u, status = "scratch", action = "readwrite")
write (u, "(A)") mci%md5sum
call mci%write (u, pacify, md5sum_version = .true.)
rewind (u)
mci%md5sum_adapted = md5sum (u)
close (u)
end subroutine mci_vamp_compute_md5sum
@ %def mci_vamp_compute_md5sum
@ Return the MD5 sum: If available, return the adapted one.
<<MCI vamp: mci vamp: TBP>>=
procedure :: get_md5sum => mci_vamp_get_md5sum
<<MCI vamp: procedures>>=
pure function mci_vamp_get_md5sum (mci) result (md5sum)
class(mci_vamp_t), intent(in) :: mci
character(32) :: md5sum
if (mci%md5sum_adapted /= "") then
md5sum = mci%md5sum_adapted
else
md5sum = mci%md5sum
end if
end function mci_vamp_get_md5sum
@ %def mci_vamp_get_md5sum
@ Startup message: short version.
<<MCI vamp: mci vamp: TBP>>=
procedure :: startup_message => mci_vamp_startup_message
<<MCI vamp: procedures>>=
subroutine mci_vamp_startup_message (mci, unit, n_calls)
class(mci_vamp_t), intent(in) :: mci
integer, intent(in), optional :: unit, n_calls
integer :: num_calls, n_bins
if (present (n_calls)) then
num_calls = n_calls
else
num_calls = 0
end if
if (mci%min_calls /= 0) then
n_bins = max (mci%grid_par%min_bins, &
min (num_calls / mci%min_calls, &
mci%grid_par%max_bins))
else
n_bins = mci%grid_par%max_bins
end if
call mci%base_startup_message (unit = unit, n_calls = n_calls)
if (mci%grid_par%use_vamp_equivalences) then
write (msg_buffer, "(A,2(1x,I0,1x,A))") &
"Integrator: Using VAMP channel equivalences"
call msg_message (unit = unit)
end if
write (msg_buffer, "(A,2(1x,I0,1x,A),L1)") &
"Integrator:", num_calls, &
"initial calls,", n_bins, &
"bins, stratified = ", &
mci%grid_par%stratified
call msg_message (unit = unit)
write (msg_buffer, "(A,2(1x,I0,1x,A))") &
"Integrator: VAMP"
call msg_message (unit = unit)
end subroutine mci_vamp_startup_message
@ %def mci_vamp_startup_message
@ Log entry: just headline.
<<MCI vamp: mci vamp: TBP>>=
procedure :: write_log_entry => mci_vamp_write_log_entry
<<MCI vamp: procedures>>=
subroutine mci_vamp_write_log_entry (mci, u)
class(mci_vamp_t), intent(in) :: mci
integer, intent(in) :: u
write (u, "(1x,A)") "MC Integrator is VAMP"
call write_separator (u)
call mci%write_history (u)
call write_separator (u)
if (mci%grid_par%use_vamp_equivalences) then
call vamp_equivalences_write (mci%equivalences, u)
else
write (u, "(3x,A)") "No VAMP equivalences have been used"
end if
call write_separator (u)
call mci%write_chain_weights (u)
end subroutine mci_vamp_write_log_entry
@ %def mci_vamp_write_log_entry
@ Set the MCI index (necessary for processes with multiple components).
We append the index to the grid filename, just before the final dotted
suffix.
<<MCI vamp: mci vamp: TBP>>=
procedure :: record_index => mci_vamp_record_index
<<MCI vamp: procedures>>=
subroutine mci_vamp_record_index (mci, i_mci)
class(mci_vamp_t), intent(inout) :: mci
integer, intent(in) :: i_mci
type(string_t) :: basename, suffix
character(32) :: buffer
if (mci%grid_filename_set) then
basename = mci%grid_filename
call split (basename, suffix, ".", back=.true.)
write (buffer, "(I0)") i_mci
if (basename /= "") then
mci%grid_filename = basename // ".m" // trim (buffer) // "." // suffix
else
mci%grid_filename = suffix // ".m" // trim (buffer) // ".vg"
end if
end if
end subroutine mci_vamp_record_index
@ %def mci_vamp_record_index
@ Set the grid parameters.
<<MCI vamp: mci vamp: TBP>>=
procedure :: set_grid_parameters => mci_vamp_set_grid_parameters
<<MCI vamp: procedures>>=
subroutine mci_vamp_set_grid_parameters (mci, grid_par)
class(mci_vamp_t), intent(inout) :: mci
type(grid_parameters_t), intent(in) :: grid_par
mci%grid_par = grid_par
mci%min_calls = grid_par%min_calls_per_bin * mci%n_channel
end subroutine mci_vamp_set_grid_parameters
@ %def mci_vamp_set_grid_parameters
@ Set the history parameters.
<<MCI vamp: mci vamp: TBP>>=
procedure :: set_history_parameters => mci_vamp_set_history_parameters
<<MCI vamp: procedures>>=
subroutine mci_vamp_set_history_parameters (mci, history_par)
class(mci_vamp_t), intent(inout) :: mci
type(history_parameters_t), intent(in) :: history_par
mci%history_par = history_par
end subroutine mci_vamp_set_history_parameters
@ %def mci_vamp_set_history_parameters
@ Set the rebuild flag, also the flag for checking the grid file.
<<MCI vamp: mci vamp: TBP>>=
procedure :: set_rebuild_flag => mci_vamp_set_rebuild_flag
<<MCI vamp: procedures>>=
subroutine mci_vamp_set_rebuild_flag (mci, rebuild, check_grid_file)
class(mci_vamp_t), intent(inout) :: mci
logical, intent(in) :: rebuild
logical, intent(in) :: check_grid_file
mci%rebuild = rebuild
mci%check_grid_file = check_grid_file
end subroutine mci_vamp_set_rebuild_flag
@ %def mci_vamp_set_rebuild_flag
@ Set the filename.
<<MCI vamp: mci vamp: TBP>>=
procedure :: set_grid_filename => mci_vamp_set_grid_filename
<<MCI vamp: procedures>>=
subroutine mci_vamp_set_grid_filename (mci, name, run_id)
class(mci_vamp_t), intent(inout) :: mci
type(string_t), intent(in) :: name
type(string_t), intent(in), optional :: run_id
if (present (run_id)) then
mci%grid_filename = name // "." // run_id // ".vg"
else
mci%grid_filename = name // ".vg"
end if
mci%grid_filename_set = .true.
end subroutine mci_vamp_set_grid_filename
@ %def mci_vamp_set_grid_filename
@ To simplify the interface, we prepend a grid path in a separate subroutine.
<<MCI vamp: mci vamp: TBP>>=
procedure :: prepend_grid_path => mci_vamp_prepend_grid_path
<<MCI vamp: procedures>>=
subroutine mci_vamp_prepend_grid_path (mci, prefix)
class(mci_vamp_t), intent(inout) :: mci
type(string_t), intent(in) :: prefix
if (mci%grid_filename_set) then
mci%grid_filename = prefix // "/" // mci%grid_filename
else
call msg_warning ("Cannot add prefix to invalid grid filename!")
end if
end subroutine mci_vamp_prepend_grid_path
@ %def mci_vamp_prepend_grid_path
@ Declare particular dimensions as flat.
<<MCI vamp: mci vamp: TBP>>=
procedure :: declare_flat_dimensions => mci_vamp_declare_flat_dimensions
<<MCI vamp: procedures>>=
subroutine mci_vamp_declare_flat_dimensions (mci, dim_flat)
class(mci_vamp_t), intent(inout) :: mci
integer, dimension(:), intent(in) :: dim_flat
integer :: d
allocate (mci%dim_is_flat (mci%n_dim), source = .false.)
do d = 1, size (dim_flat)
mci%dim_is_flat(dim_flat(d)) = .true.
end do
end subroutine mci_vamp_declare_flat_dimensions
@ %def mci_vamp_declare_flat_dimensions
@ Declare equivalences. We have an array of channel equivalences,
provided by the phase-space module. Here, we translate this into the
[[vamp_equivalences]] array.
<<MCI vamp: mci vamp: TBP>>=
procedure :: declare_equivalences => mci_vamp_declare_equivalences
<<MCI vamp: procedures>>=
subroutine mci_vamp_declare_equivalences (mci, channel, dim_offset)
class(mci_vamp_t), intent(inout) :: mci
type(phs_channel_t), dimension(:), intent(in) :: channel
integer, intent(in) :: dim_offset
integer, dimension(:), allocatable :: perm, mode
integer :: n_channels, n_dim, n_equivalences
integer :: c, i, j, left, right
+ integer :: n_dim_perm
n_channels = mci%n_channel
n_dim = mci%n_dim
n_equivalences = 0
do c = 1, n_channels
n_equivalences = n_equivalences + size (channel(c)%eq)
end do
call vamp_equivalences_init (mci%equivalences, &
n_equivalences, n_channels, n_dim)
allocate (perm (n_dim))
allocate (mode (n_dim))
- perm(1:dim_offset) = [(i, i = 1, dim_offset)]
- mode(1:dim_offset) = VEQ_IDENTITY
+ perm = [(i, i = 1, n_dim)]
+ mode = VEQ_IDENTITY
c = 1
j = 0
do i = 1, n_equivalences
if (j < size (channel(c)%eq)) then
j = j + 1
else
c = c + 1
j = 1
end if
associate (eq => channel(c)%eq(j))
left = c
right = eq%c
- perm(dim_offset+1:) = eq%perm + dim_offset
- mode(dim_offset+1:) = eq%mode
+ n_dim_perm = size (eq%perm)
+ perm(dim_offset + 1:dim_offset + n_dim_perm) = eq%perm + dim_offset
+ mode(dim_offset + 1:dim_offset + n_dim_perm) = eq%mode
call vamp_equivalence_set (mci%equivalences, &
i, left, right, perm, mode)
end associate
end do
call vamp_equivalences_complete (mci%equivalences)
end subroutine mci_vamp_declare_equivalences
@ %def mci_vamp_declare_equivalences
@ Allocate instance with matching type.
<<MCI vamp: mci vamp: TBP>>=
procedure :: allocate_instance => mci_vamp_allocate_instance
<<MCI vamp: procedures>>=
subroutine mci_vamp_allocate_instance (mci, mci_instance)
class(mci_vamp_t), intent(in) :: mci
class(mci_instance_t), intent(out), pointer :: mci_instance
allocate (mci_vamp_instance_t :: mci_instance)
end subroutine mci_vamp_allocate_instance
@ %def mci_vamp_allocate_instance
@ Allocate a new integration pass. We can preset everything that does not
depend on the number of iterations and calls. This is postponed to
the [[integrate]] method.
In the final pass, we do not check accuracy goal etc., since we can assume
that the user wants to perform and average all iterations in this pass.
<<MCI vamp: mci vamp: TBP>>=
procedure :: add_pass => mci_vamp_add_pass
<<MCI vamp: procedures>>=
subroutine mci_vamp_add_pass (mci, adapt_grids, adapt_weights, final_pass)
class(mci_vamp_t), intent(inout) :: mci
logical, intent(in), optional :: adapt_grids, adapt_weights, final_pass
integer :: i_pass, i_it
type(pass_t), pointer :: new
allocate (new)
if (associated (mci%current_pass)) then
i_pass = mci%current_pass%i_pass + 1
i_it = mci%current_pass%i_first_it + mci%current_pass%n_it
mci%current_pass%next => new
else
i_pass = 1
i_it = 1
mci%first_pass => new
end if
mci%current_pass => new
new%i_pass = i_pass
new%i_first_it = i_it
if (present (adapt_grids)) then
new%adapt_grids = adapt_grids
else
new%adapt_grids = .false.
end if
if (present (adapt_weights)) then
new%adapt_weights = adapt_weights
else
new%adapt_weights = .false.
end if
if (present (final_pass)) then
new%is_final_pass = final_pass
else
new%is_final_pass = .false.
end if
end subroutine mci_vamp_add_pass
@ %def mci_vamp_add_pass
@ Update the list of integration passes. All passes except for the last one
must match exactly. For the last one, integration results are updated. The
reference output may contain extra passes, these are ignored.
<<MCI vamp: mci vamp: TBP>>=
procedure :: update_from_ref => mci_vamp_update_from_ref
<<MCI vamp: procedures>>=
subroutine mci_vamp_update_from_ref (mci, mci_ref, success)
class(mci_vamp_t), intent(inout) :: mci
class(mci_t), intent(in) :: mci_ref
logical, intent(out) :: success
type(pass_t), pointer :: current_pass, ref_pass
select type (mci_ref)
type is (mci_vamp_t)
current_pass => mci%first_pass
ref_pass => mci_ref%first_pass
success = .true.
do while (success .and. associated (current_pass))
if (associated (ref_pass)) then
if (associated (current_pass%next)) then
success = current_pass .matches. ref_pass
else
call current_pass%update (ref_pass, success)
if (current_pass%integral_defined) then
mci%integral = current_pass%get_integral ()
mci%error = current_pass%get_error ()
mci%efficiency = current_pass%get_efficiency ()
mci%integral_known = .true.
mci%error_known = .true.
mci%efficiency_known = .true.
end if
end if
current_pass => current_pass%next
ref_pass => ref_pass%next
else
success = .false.
end if
end do
end select
end subroutine mci_vamp_update_from_ref
@ %def mci_vamp_update
@ Update the MCI record (i.e., the integration passes) by reading from input
stream. The stream should contain a [[write]] output from a previous run. We
first check the MD5 sum of the configuration parameters. If that matches, we
proceed directly to the stored integration passes. If successful, we may
continue to read the file; the position will be after a blank line that
must follow the MCI record.
<<MCI vamp: mci vamp: TBP>>=
procedure :: update => mci_vamp_update
<<MCI vamp: procedures>>=
subroutine mci_vamp_update (mci, u, success)
class(mci_vamp_t), intent(inout) :: mci
integer, intent(in) :: u
logical, intent(out) :: success
character(80) :: buffer
character(32) :: md5sum_file
type(mci_vamp_t) :: mci_file
integer :: n_pass, n_it
call read_sval (u, md5sum_file)
if (mci%check_grid_file) then
success = md5sum_file == mci%md5sum
else
success = .true.
end if
if (success) then
read (u, *)
read (u, "(A)") buffer
if (trim (adjustl (buffer)) == "VAMP integrator:") then
n_pass = 0
n_it = 0
do
read (u, "(A)") buffer
select case (trim (adjustl (buffer)))
case ("")
exit
case ("Integration pass:")
call mci_file%add_pass ()
call mci_file%current_pass%read (u, n_pass, n_it)
n_pass = n_pass + 1
n_it = n_it + mci_file%current_pass%n_it
end select
end do
call mci%update_from_ref (mci_file, success)
call mci_file%final ()
else
call msg_fatal ("VAMP: reading grid file: corrupted data")
end if
end if
end subroutine mci_vamp_update
@ %def mci_vamp_update
@ Read / write grids from / to file.
Bug fix for 2.2.5: after reading grids from file, channel weights
must be copied back to the [[mci_instance]] record.
<<MCI vamp: mci vamp: TBP>>=
procedure :: write_grids => mci_vamp_write_grids
procedure :: read_grids_header => mci_vamp_read_grids_header
procedure :: read_grids_data => mci_vamp_read_grids_data
procedure :: read_grids => mci_vamp_read_grids
<<MCI vamp: procedures>>=
subroutine mci_vamp_write_grids (mci, instance)
class(mci_vamp_t), intent(in) :: mci
class(mci_instance_t), intent(inout) :: instance
integer :: u
select type (instance)
type is (mci_vamp_instance_t)
if (mci%grid_filename_set) then
if (instance%grids_defined) then
u = free_unit ()
open (u, file = char (mci%grid_filename), &
action = "write", status = "replace")
write (u, "(1x,A,A,A)") "MD5sum = '", mci%md5sum, "'"
write (u, *)
call mci%write (u)
write (u, *)
write (u, "(1x,A)") "VAMP grids:"
call vamp_write_grids (instance%grids, u, &
write_integrals = .true.)
close (u)
else
call msg_bug ("VAMP: write grids: grids undefined")
end if
else
call msg_bug ("VAMP: write grids: filename undefined")
end if
end select
end subroutine mci_vamp_write_grids
subroutine mci_vamp_read_grids_header (mci, success)
class(mci_vamp_t), intent(inout) :: mci
logical, intent(out) :: success
logical :: exist
integer :: u
success = .false.
if (mci%grid_filename_set) then
inquire (file = char (mci%grid_filename), exist = exist)
if (exist) then
u = free_unit ()
open (u, file = char (mci%grid_filename), &
action = "read", status = "old")
call mci%update (u, success)
close (u)
if (.not. success) then
write (msg_buffer, "(A,A,A)") &
"VAMP: parameter mismatch, discarding grid file '", &
char (mci%grid_filename), "'"
call msg_message ()
end if
end if
else
call msg_bug ("VAMP: read grids: filename undefined")
end if
end subroutine mci_vamp_read_grids_header
subroutine mci_vamp_read_grids_data (mci, instance, read_integrals)
class(mci_vamp_t), intent(in) :: mci
class(mci_instance_t), intent(inout) :: instance
logical, intent(in), optional :: read_integrals
integer :: u
character(80) :: buffer
select type (instance)
type is (mci_vamp_instance_t)
if (.not. instance%grids_defined) then
u = free_unit ()
open (u, file = char (mci%grid_filename), &
action = "read", status = "old")
do
read (u, "(A)") buffer
if (trim (adjustl (buffer)) == "VAMP grids:") exit
end do
call vamp_read_grids (instance%grids, u, read_integrals)
close (u)
call instance%set_channel_weights (instance%grids%weights)
instance%grids_defined = .true.
else
call msg_bug ("VAMP: read grids: grids already defined")
end if
end select
end subroutine mci_vamp_read_grids_data
subroutine mci_vamp_read_grids (mci, instance, success)
class(mci_vamp_t), intent(inout) :: mci
class(mci_instance_t), intent(inout) :: instance
logical, intent(out) :: success
logical :: exist
integer :: u
character(80) :: buffer
select type (instance)
type is (mci_vamp_instance_t)
success = .false.
if (mci%grid_filename_set) then
if (.not. instance%grids_defined) then
inquire (file = char (mci%grid_filename), exist = exist)
if (exist) then
u = free_unit ()
open (u, file = char (mci%grid_filename), &
action = "read", status = "old")
call mci%update (u, success)
if (success) then
read (u, "(A)") buffer
if (trim (adjustl (buffer)) == "VAMP grids:") then
call vamp_read_grids (instance%grids, u)
else
call msg_fatal ("VAMP: reading grid file: &
&corrupted grid data")
end if
else
write (msg_buffer, "(A,A,A)") &
"VAMP: parameter mismatch, discarding grid file '", &
char (mci%grid_filename), "'"
call msg_message ()
end if
close (u)
instance%grids_defined = success
end if
else
call msg_bug ("VAMP: read grids: grids already defined")
end if
else
call msg_bug ("VAMP: read grids: filename undefined")
end if
end select
end subroutine mci_vamp_read_grids
@ %def mci_vamp_write_grids
@ %def mci_vamp_read_grids_header
@ %def mci_vamp_read_grids_data
@ %def mci_vamp_read_grids
@ Auxiliary: Read real, integer, string value. We search for an equals sign,
the value must follow.
<<MCI vamp: procedures>>=
subroutine read_rval (u, rval)
integer, intent(in) :: u
real(default), intent(out) :: rval
character(80) :: buffer
read (u, "(A)") buffer
buffer = adjustl (buffer(scan (buffer, "=") + 1:))
read (buffer, *) rval
end subroutine read_rval
subroutine read_ival (u, ival)
integer, intent(in) :: u
integer, intent(out) :: ival
character(80) :: buffer
read (u, "(A)") buffer
buffer = adjustl (buffer(scan (buffer, "=") + 1:))
read (buffer, *) ival
end subroutine read_ival
subroutine read_sval (u, sval)
integer, intent(in) :: u
character(*), intent(out) :: sval
character(80) :: buffer
read (u, "(A)") buffer
buffer = adjustl (buffer(scan (buffer, "=") + 1:))
read (buffer, *) sval
end subroutine read_sval
subroutine read_lval (u, lval)
integer, intent(in) :: u
logical, intent(out) :: lval
character(80) :: buffer
read (u, "(A)") buffer
buffer = adjustl (buffer(scan (buffer, "=") + 1:))
read (buffer, *) lval
end subroutine read_lval
@ %def read_rval read_ival read_sval read_lval
@ Integrate. Perform a new integration pass (possibly reusing
previous results), which may consist of several iterations.
Note: we record the integral once per iteration. The integral stored
in the [[mci]] record itself is the last integral of the current
iteration, no averaging done. The [[results]] record may average results.
In case we read the integration from file and we added new iterations to the pass preserving number of calls, we need to reshape the grids in order to incorporate the correct number of calls.
Else the grids would be sampled with the number of calls from the grids file, which does not need to coincide with the number of calls from the pass.
Note: recording the efficiency is not supported yet.
<<MCI vamp: mci vamp: TBP>>=
procedure :: integrate => mci_vamp_integrate
<<MCI vamp: procedures>>=
subroutine mci_vamp_integrate (mci, instance, sampler, &
n_it, n_calls, results, pacify)
class(mci_vamp_t), intent(inout) :: mci
class(mci_instance_t), intent(inout), target :: instance
class(mci_sampler_t), intent(inout), target :: sampler
integer, intent(in) :: n_it
integer, intent(in) :: n_calls
class(mci_results_t), intent(inout), optional :: results
logical, intent(in), optional :: pacify
integer :: it
logical :: reshape, from_file, success
select type (instance)
type is (mci_vamp_instance_t)
if (associated (mci%current_pass)) then
mci%current_pass%integral_defined = .false.
call mci%current_pass%configure (n_it, n_calls, &
mci%min_calls, mci%grid_par%min_bins, &
mci%grid_par%max_bins, &
mci%grid_par%min_calls_per_channel * mci%n_channel)
call mci%current_pass%configure_history &
(mci%n_channel, mci%history_par)
instance%pass_complete = .false.
instance%it_complete = .false.
call instance%new_pass (reshape)
if (.not. instance%grids_defined .or. instance%grids_from_file) then
if (mci%grid_filename_set .and. .not. mci%rebuild) then
call mci%read_grids_header (success)
from_file = success
if (.not. instance%grids_defined .and. success) then
call mci%read_grids_data (instance)
end if
else
from_file = .false.
end if
else
from_file = .false.
end if
if (from_file) then
if (.not. mci%check_grid_file) &
call msg_warning ("Reading grid file: MD5 sum check disabled")
call msg_message ("VAMP: " &
// "using grids and results from file '" &
// char (mci%grid_filename) // "'")
else if (.not. instance%grids_defined) then
call instance%create_grids ()
end if
do it = 1, instance%n_it
if (signal_is_pending ()) return
reshape = reshape .or. &
(instance%grids_from_file .and. n_it > mci%current_pass%get_integration_index ())
instance%grids_from_file = from_file .and. &
it <= mci%current_pass%get_integration_index ()
if (.not. instance%grids_from_file) then
instance%it_complete = .false.
call instance%adapt_grids ()
if (signal_is_pending ()) return
call instance%adapt_weights ()
if (signal_is_pending ()) return
call instance%discard_integrals (reshape)
if (mci%grid_par%use_vamp_equivalences) then
call instance%sample_grids (mci%rng, sampler, &
mci%equivalences)
else
call instance%sample_grids (mci%rng, sampler)
end if
if (signal_is_pending ()) return
instance%it_complete = .true.
if (instance%integral /= 0) then
mci%current_pass%calls(it) = instance%calls
mci%current_pass%calls_valid(it) = instance%calls_valid
mci%current_pass%integral(it) = instance%integral
if (abs (instance%error / instance%integral) &
> epsilon (1._default)) then
mci%current_pass%error(it) = instance%error
end if
mci%current_pass%efficiency(it) = instance%efficiency
end if
mci%current_pass%integral_defined = .true.
end if
if (present (results)) then
if (mci%has_chains ()) then
call mci%collect_chain_weights (instance%w)
call results%record (1, &
n_calls = mci%current_pass%calls(it), &
n_calls_valid = mci%current_pass%calls_valid(it), &
integral = mci%current_pass%integral(it), &
error = mci%current_pass%error(it), &
efficiency = mci%current_pass%efficiency(it), &
! TODO Insert pos. and neg. Efficiency from VAMP.
efficiency_pos = 0._default, &
efficiency_neg = 0._default, &
chain_weights = mci%chain_weights, &
suppress = pacify)
else
call results%record (1, &
n_calls = mci%current_pass%calls(it), &
n_calls_valid = mci%current_pass%calls_valid(it), &
integral = mci%current_pass%integral(it), &
error = mci%current_pass%error(it), &
efficiency = mci%current_pass%efficiency(it), &
! TODO Insert pos. and neg. Efficiency from VAMP.
efficiency_pos = 0._default, &
efficiency_neg = 0._default, &
suppress = pacify)
end if
end if
if (.not. instance%grids_from_file &
.and. mci%grid_filename_set) then
call mci%write_grids (instance)
end if
call instance%allow_adaptation ()
reshape = .false.
if (.not. mci%current_pass%is_final_pass) then
call mci%check_goals (it, success)
if (success) exit
end if
end do
if (signal_is_pending ()) return
instance%pass_complete = .true.
mci%integral = mci%current_pass%get_integral()
mci%error = mci%current_pass%get_error()
mci%efficiency = mci%current_pass%get_efficiency()
mci%integral_known = .true.
mci%error_known = .true.
mci%efficiency_known = .true.
call mci%compute_md5sum (pacify)
else
call msg_bug ("MCI integrate: current_pass object not allocated")
end if
end select
end subroutine mci_vamp_integrate
@ %def mci_vamp_integrate
@ Check whether we are already finished with this pass.
<<MCI vamp: mci vamp: TBP>>=
procedure :: check_goals => mci_vamp_check_goals
<<MCI vamp: procedures>>=
subroutine mci_vamp_check_goals (mci, it, success)
class(mci_vamp_t), intent(inout) :: mci
integer, intent(in) :: it
logical, intent(out) :: success
success = .false.
if (mci%error_reached (it)) then
mci%current_pass%n_it = it
call msg_message ("VAMP: error goal reached; &
&skipping iterations")
success = .true.
return
end if
if (mci%rel_error_reached (it)) then
mci%current_pass%n_it = it
call msg_message ("VAMP: relative error goal reached; &
&skipping iterations")
success = .true.
return
end if
if (mci%accuracy_reached (it)) then
mci%current_pass%n_it = it
call msg_message ("VAMP: accuracy goal reached; &
&skipping iterations")
success = .true.
return
end if
end subroutine mci_vamp_check_goals
@ %def mci_vamp_check_goals
@ Return true if the error, relative error, or accuracy goal has been reached,
if any.
<<MCI vamp: mci vamp: TBP>>=
procedure :: error_reached => mci_vamp_error_reached
procedure :: rel_error_reached => mci_vamp_rel_error_reached
procedure :: accuracy_reached => mci_vamp_accuracy_reached
<<MCI vamp: procedures>>=
function mci_vamp_error_reached (mci, it) result (flag)
class(mci_vamp_t), intent(in) :: mci
integer, intent(in) :: it
logical :: flag
real(default) :: error_goal, error
error_goal = mci%grid_par%error_goal
if (error_goal > 0) then
associate (pass => mci%current_pass)
if (pass%integral_defined) then
error = abs (pass%error(it))
flag = error < error_goal
else
flag = .false.
end if
end associate
else
flag = .false.
end if
end function mci_vamp_error_reached
function mci_vamp_rel_error_reached (mci, it) result (flag)
class(mci_vamp_t), intent(in) :: mci
integer, intent(in) :: it
logical :: flag
real(default) :: rel_error_goal, rel_error
rel_error_goal = mci%grid_par%rel_error_goal
if (rel_error_goal > 0) then
associate (pass => mci%current_pass)
if (pass%integral_defined) then
if (pass%integral(it) /= 0) then
rel_error = abs (pass%error(it) / pass%integral(it))
flag = rel_error < rel_error_goal
else
flag = .true.
end if
else
flag = .false.
end if
end associate
else
flag = .false.
end if
end function mci_vamp_rel_error_reached
function mci_vamp_accuracy_reached (mci, it) result (flag)
class(mci_vamp_t), intent(in) :: mci
integer, intent(in) :: it
logical :: flag
real(default) :: accuracy_goal, accuracy
accuracy_goal = mci%grid_par%accuracy_goal
if (accuracy_goal > 0) then
associate (pass => mci%current_pass)
if (pass%integral_defined) then
if (pass%integral(it) /= 0) then
accuracy = abs (pass%error(it) / pass%integral(it)) &
* sqrt (real (pass%calls(it), default))
flag = accuracy < accuracy_goal
else
flag = .true.
end if
else
flag = .false.
end if
end associate
else
flag = .false.
end if
end function mci_vamp_accuracy_reached
@ %def mci_vamp_error_reached
@ %def mci_vamp_rel_error_reached
@ %def mci_vamp_accuracy_reached
@ Prepare an event generation pass. Should be called before a sequence of
events is generated, then we should call the corresponding finalizer.
The pass-specific data of the previous integration pass are retained,
but we reset the number of iterations and calls to zero. The latter
now counts the number of events (calls to the sampling function, actually).
<<MCI vamp: mci vamp: TBP>>=
procedure :: prepare_simulation => mci_vamp_prepare_simulation
<<MCI vamp: procedures>>=
subroutine mci_vamp_prepare_simulation (mci)
class(mci_vamp_t), intent(inout) :: mci
logical :: success
if (mci%grid_filename_set) then
call mci%read_grids_header (success)
call mci%compute_md5sum ()
if (.not. success) then
call msg_fatal ("Simulate: " &
// "reading integration grids from file '" &
// char (mci%grid_filename) // "' failed")
end if
else
call msg_bug ("VAMP: simulation: no grids, no grid filename")
end if
end subroutine mci_vamp_prepare_simulation
@ %def mci_vamp_prepare_simulation
@ Generate weighted event. Note that the event weight
([[vamp_weight]]) is not just the MCI weight. [[vamp_next_event]]
selects a channel based on the channel weights multiplied by the
(previously recorded) maximum integrand value of the channel. The
MCI weight is renormalized accordingly, to cancel this effect on the
result.
<<MCI vamp: mci vamp: TBP>>=
procedure :: generate_weighted_event => mci_vamp_generate_weighted_event
<<MCI vamp: procedures>>=
subroutine mci_vamp_generate_weighted_event (mci, instance, sampler)
class(mci_vamp_t), intent(inout) :: mci
class(mci_instance_t), intent(inout), target :: instance
class(mci_sampler_t), intent(inout), target :: sampler
class(vamp_data_t), allocatable :: data
type(exception) :: vamp_exception
select type (instance)
type is (mci_vamp_instance_t)
instance%vamp_weight_set = .false.
allocate (mci_workspace_t :: data)
select type (data)
type is (mci_workspace_t)
data%sampler => sampler
data%instance => instance
end select
select type (rng => mci%rng)
type is (rng_tao_t)
if (instance%grids_defined) then
call vamp_next_event ( &
instance%vamp_x, &
rng%state, &
instance%grids, &
vamp_sampling_function, &
data, &
phi = phi_trivial, &
weight = instance%vamp_weight, &
exc = vamp_exception)
call handle_vamp_exception (vamp_exception, mci%verbose)
instance%vamp_excess = 0
instance%vamp_weight_set = .true.
else
call msg_bug ("VAMP: generate event: grids undefined")
end if
class default
call msg_fatal ("VAMP event generation: &
&random-number generator must be TAO")
end select
end select
end subroutine mci_vamp_generate_weighted_event
@ %def mci_vamp_generate_weighted_event
@ Generate unweighted event.
<<MCI vamp: mci vamp: TBP>>=
procedure :: generate_unweighted_event => &
mci_vamp_generate_unweighted_event
<<MCI vamp: procedures>>=
subroutine mci_vamp_generate_unweighted_event (mci, instance, sampler)
class(mci_vamp_t), intent(inout) :: mci
class(mci_instance_t), intent(inout), target :: instance
class(mci_sampler_t), intent(inout), target :: sampler
class(vamp_data_t), allocatable :: data
logical :: positive
type(exception) :: vamp_exception
select type (instance)
type is (mci_vamp_instance_t)
instance%vamp_weight_set = .false.
allocate (mci_workspace_t :: data)
select type (data)
type is (mci_workspace_t)
data%sampler => sampler
data%instance => instance
end select
select type (rng => mci%rng)
type is (rng_tao_t)
if (instance%grids_defined) then
REJECTION: do
call vamp_next_event ( &
instance%vamp_x, &
rng%state, &
instance%grids, &
vamp_sampling_function, &
data, &
phi = phi_trivial, &
excess = instance%vamp_excess, &
positive = positive, &
exc = vamp_exception)
if (signal_is_pending ()) return
if (sampler%is_valid ()) exit REJECTION
end do REJECTION
call handle_vamp_exception (vamp_exception, mci%verbose)
if (positive) then
instance%vamp_weight = 1
else if (instance%negative_weights) then
instance%vamp_weight = -1
else
call msg_fatal ("VAMP: event with negative weight generated")
instance%vamp_weight = 0
end if
instance%vamp_weight_set = .true.
else
call msg_bug ("VAMP: generate event: grids undefined")
end if
class default
call msg_fatal ("VAMP event generation: &
&random-number generator must be TAO")
end select
end select
end subroutine mci_vamp_generate_unweighted_event
@ %def mci_vamp_generate_unweighted_event
@ Rebuild an event, using the [[state]] input.
Note: This feature is currently unused.
<<MCI vamp: mci vamp: TBP>>=
procedure :: rebuild_event => mci_vamp_rebuild_event
<<MCI vamp: procedures>>=
subroutine mci_vamp_rebuild_event (mci, instance, sampler, state)
class(mci_vamp_t), intent(inout) :: mci
class(mci_instance_t), intent(inout) :: instance
class(mci_sampler_t), intent(inout) :: sampler
class(mci_state_t), intent(in) :: state
call msg_bug ("MCI vamp rebuild event not implemented yet")
end subroutine mci_vamp_rebuild_event
@ %def mci_vamp_rebuild_event
@ Pacify: override the default no-op, since VAMP numerics might need
some massage.
<<MCI vamp: mci vamp: TBP>>=
procedure :: pacify => mci_vamp_pacify
<<MCI vamp: procedures>>=
subroutine mci_vamp_pacify (object, efficiency_reset, error_reset)
class(mci_vamp_t), intent(inout) :: object
logical, intent(in), optional :: efficiency_reset, error_reset
logical :: err_reset
type(pass_t), pointer :: current_pass
err_reset = .false.
if (present (error_reset)) err_reset = error_reset
current_pass => object%first_pass
do while (associated (current_pass))
if (allocated (current_pass%error) .and. err_reset) then
current_pass%error = 0
end if
if (allocated (current_pass%efficiency) .and. err_reset) then
current_pass%efficiency = 1
end if
current_pass => current_pass%next
end do
end subroutine mci_vamp_pacify
@ %def mci_vamp_pacify
@
\subsection{Sampler as Workspace}
In the full setup, the sampling function requires the process instance
object as workspace. We implement this by (i) implementing the
process instance as a type extension of the abstract [[sampler_t]]
object used by the MCI implementation and (ii) providing such an
object as an extra argument to the sampling function that VAMP can
call. To minimize cross-package dependencies, we use an abstract type
[[vamp_workspace]] that VAMP declares and extend this by including a
pointer to the [[sampler]] and [[instance]] objects. In the body of
the sampling function, we dereference this pointer and can then work
with the contents.
<<MCI vamp: types>>=
type, extends (vamp_data_t) :: mci_workspace_t
class(mci_sampler_t), pointer :: sampler => null ()
class(mci_vamp_instance_t), pointer :: instance => null ()
end type mci_workspace_t
@ %def mci_workspace_t
@
\subsection{Integrator instance}
The history entries should point to the corresponding history entry in
the [[pass_t]] object. If there is none, we may allocate a local
history, which is then just transient.
<<MCI vamp: public>>=
public :: mci_vamp_instance_t
<<MCI vamp: types>>=
type, extends (mci_instance_t) :: mci_vamp_instance_t
type(mci_vamp_t), pointer :: mci => null ()
logical :: grids_defined = .false.
logical :: grids_from_file = .false.
integer :: n_it = 0
integer :: it = 0
logical :: pass_complete = .false.
integer :: n_calls = 0
integer :: calls = 0
integer :: calls_valid = 0
logical :: it_complete = .false.
logical :: enable_adapt_grids = .false.
logical :: enable_adapt_weights = .false.
logical :: allow_adapt_grids = .false.
logical :: allow_adapt_weights = .false.
integer :: n_adapt_grids = 0
integer :: n_adapt_weights = 0
logical :: generating_events = .false.
real(default) :: safety_factor = 1
type(vamp_grids) :: grids
real(default) :: g = 0
real(default), dimension(:), allocatable :: gi
real(default) :: integral = 0
real(default) :: error = 0
real(default) :: efficiency = 0
real(default), dimension(:), allocatable :: vamp_x
logical :: vamp_weight_set = .false.
real(default) :: vamp_weight = 0
real(default) :: vamp_excess = 0
logical :: allocate_global_history = .false.
type(vamp_history), dimension(:), pointer :: v_history => null ()
logical :: allocate_channel_history = .false.
type(vamp_history), dimension(:,:), pointer :: v_histories => null ()
contains
<<MCI vamp: mci vamp instance: TBP>>
end type mci_vamp_instance_t
@ %def mci_vamp_instance_t
@ Output.
<<MCI vamp: mci vamp instance: TBP>>=
procedure :: write => mci_vamp_instance_write
<<MCI vamp: procedures>>=
subroutine mci_vamp_instance_write (object, unit, pacify)
class(mci_vamp_instance_t), intent(in) :: object
integer, intent(in), optional :: unit
logical, intent(in), optional :: pacify
integer :: u, i
character(len=7) :: fmt
call pac_fmt (fmt, FMT_17, FMT_14, pacify)
u = given_output_unit (unit)
write (u, "(3x,A," // FMT_19 // ")") "Integrand = ", object%integrand
write (u, "(3x,A," // FMT_19 // ")") "Weight = ", object%mci_weight
if (object%vamp_weight_set) then
write (u, "(3x,A," // FMT_19 // ")") "VAMP wgt = ", object%vamp_weight
if (object%vamp_excess /= 0) then
write (u, "(3x,A," // FMT_19 // ")") "VAMP exc = ", &
object%vamp_excess
end if
end if
write (u, "(3x,A,L1)") "adapt grids = ", object%enable_adapt_grids
write (u, "(3x,A,L1)") "adapt weights = ", object%enable_adapt_weights
if (object%grids_defined) then
if (object%grids_from_file) then
write (u, "(3x,A)") "VAMP grids: read from file"
else
write (u, "(3x,A)") "VAMP grids: defined"
end if
else
write (u, "(3x,A)") "VAMP grids: [undefined]"
end if
write (u, "(3x,A,I0)") "n_it = ", object%n_it
write (u, "(3x,A,I0)") "it = ", object%it
write (u, "(3x,A,L1)") "pass complete = ", object%it_complete
write (u, "(3x,A,I0)") "n_calls = ", object%n_calls
write (u, "(3x,A,I0)") "calls = ", object%calls
write (u, "(3x,A,I0)") "calls_valid = ", object%calls_valid
write (u, "(3x,A,L1)") "it complete = ", object%it_complete
write (u, "(3x,A,I0)") "n adapt.(g) = ", object%n_adapt_grids
write (u, "(3x,A,I0)") "n adapt.(w) = ", object%n_adapt_weights
write (u, "(3x,A,L1)") "gen. events = ", object%generating_events
write (u, "(3x,A,L1)") "neg. weights = ", object%negative_weights
if (object%safety_factor /= 1) write &
(u, "(3x,A," // fmt // ")") "safety f = ", object%safety_factor
write (u, "(3x,A," // fmt // ")") "integral = ", object%integral
write (u, "(3x,A," // fmt // ")") "error = ", object%error
write (u, "(3x,A," // fmt // ")") "eff. = ", object%efficiency
write (u, "(3x,A)") "weights:"
do i = 1, size (object%w)
write (u, "(5x,I0,1x," // FMT_12 // ")") i, object%w(i)
end do
end subroutine mci_vamp_instance_write
@ %def mci_vamp_instance_write
@ Write the grids to the specified unit.
<<MCI vamp: mci vamp instance: TBP>>=
procedure :: write_grids => mci_vamp_instance_write_grids
<<MCI vamp: procedures>>=
subroutine mci_vamp_instance_write_grids (object, unit)
class(mci_vamp_instance_t), intent(in) :: object
integer, intent(in), optional :: unit
integer :: u
u = given_output_unit (unit)
if (object%grids_defined) then
call vamp_write_grids (object%grids, u, write_integrals = .true.)
end if
end subroutine mci_vamp_instance_write_grids
@ %def mci_vamp_instance_write_grids
@ Finalizer: the history arrays are pointer arrays and need finalization.
<<MCI vamp: mci vamp instance: TBP>>=
procedure :: final => mci_vamp_instance_final
<<MCI vamp: procedures>>=
subroutine mci_vamp_instance_final (object)
class(mci_vamp_instance_t), intent(inout) :: object
if (object%allocate_global_history) then
if (associated (object%v_history)) then
call vamp_delete_history (object%v_history)
deallocate (object%v_history)
end if
end if
if (object%allocate_channel_history) then
if (associated (object%v_histories)) then
call vamp_delete_history (object%v_histories)
deallocate (object%v_histories)
end if
end if
if (object%grids_defined) then
call vamp_delete_grids (object%grids)
object%grids_defined = .false.
end if
end subroutine mci_vamp_instance_final
@ %def mci_vamp_instance_final
@ Initializer.
<<MCI vamp: mci vamp instance: TBP>>=
procedure :: init => mci_vamp_instance_init
<<MCI vamp: procedures>>=
subroutine mci_vamp_instance_init (mci_instance, mci)
class(mci_vamp_instance_t), intent(out) :: mci_instance
class(mci_t), intent(in), target :: mci
call mci_instance%base_init (mci)
select type (mci)
type is (mci_vamp_t)
mci_instance%mci => mci
allocate (mci_instance%gi (mci%n_channel))
mci_instance%allocate_global_history = .not. mci%history_par%global
mci_instance%allocate_channel_history = .not. mci%history_par%channel
mci_instance%negative_weights = mci%negative_weights
end select
end subroutine mci_vamp_instance_init
@ %def mci_vamp_instance_init
@ Prepare a new integration pass: write the pass-specific settings to
the [[instance]] object. This should be called initially, together
with the [[create_grids]] procedure, and whenever we start a new
integration pass.
Set [[reshape]] if the number of calls is different than previously (unless it
was zero, indicating the first pass).
We link VAMP histories to the allocated histories in the current pass
object, so the recorded results are persistent. However, if there are
no histories present there, we allocate them locally. In that case,
the histories will disappear together with the MCI instance object.
<<MCI vamp: mci vamp instance: TBP>>=
procedure :: new_pass => mci_vamp_instance_new_pass
<<MCI vamp: procedures>>=
subroutine mci_vamp_instance_new_pass (instance, reshape)
class(mci_vamp_instance_t), intent(inout) :: instance
logical, intent(out) :: reshape
type(pass_t), pointer :: current
associate (mci => instance%mci)
current => mci%current_pass
instance%n_it = current%n_it
if (instance%n_calls == 0) then
reshape = .false.
instance%n_calls = current%n_calls
else if (instance%n_calls == current%n_calls) then
reshape = .false.
else
reshape = .true.
instance%n_calls = current%n_calls
end if
instance%it = 0
instance%calls = 0
instance%calls_valid = 0
instance%enable_adapt_grids = current%adapt_grids
instance%enable_adapt_weights = current%adapt_weights
instance%generating_events = .false.
if (instance%allocate_global_history) then
if (associated (instance%v_history)) then
call vamp_delete_history (instance%v_history)
deallocate (instance%v_history)
end if
allocate (instance%v_history (instance%n_it))
call vamp_create_history (instance%v_history, verbose = .false.)
else
instance%v_history => current%v_history
end if
if (instance%allocate_channel_history) then
if (associated (instance%v_histories)) then
call vamp_delete_history (instance%v_histories)
deallocate (instance%v_histories)
end if
allocate (instance%v_histories (instance%n_it, mci%n_channel))
call vamp_create_history (instance%v_histories, verbose = .false.)
else
instance%v_histories => current%v_histories
end if
end associate
end subroutine mci_vamp_instance_new_pass
@ %def mci_vamp_instance_new_pass
@
Create a grid set within the [[instance]] object, using the data of
the current integration pass. Also reset counters that track this
grid set.
<<MCI vamp: mci vamp instance: TBP>>=
procedure :: create_grids => mci_vamp_instance_create_grids
<<MCI vamp: procedures>>=
subroutine mci_vamp_instance_create_grids (instance)
class(mci_vamp_instance_t), intent(inout) :: instance
type (pass_t), pointer :: current
integer, dimension(:), allocatable :: num_div
real(default), dimension(:,:), allocatable :: region
associate (mci => instance%mci)
current => mci%current_pass
allocate (num_div (mci%n_dim))
allocate (region (2, mci%n_dim))
region(1,:) = 0
region(2,:) = 1
num_div = current%n_bins
instance%n_adapt_grids = 0
instance%n_adapt_weights = 0
if (.not. instance%grids_defined) then
call vamp_create_grids (instance%grids, &
region, &
current%n_calls, &
weights = instance%w, &
num_div = num_div, &
stratified = mci%grid_par%stratified)
instance%grids_defined = .true.
else
call msg_bug ("VAMP: create grids: grids already defined")
end if
end associate
end subroutine mci_vamp_instance_create_grids
@ %def mci_vamp_instance_create_grids
@ Reset a grid set, so we can start a fresh integration pass. In
effect, we delete results of previous integrations, but keep the grid
shapes, weights, and variance arrays, so adaptation is still possible.
The grids are prepared for a specific number of calls (per iteration)
and sampling mode (stratified/importance).
The [[vamp_discard_integrals]] implementation will reshape the grids
only if the argument [[num_calls]] is present.
<<MCI vamp: mci vamp instance: TBP>>=
procedure :: discard_integrals => mci_vamp_instance_discard_integrals
<<MCI vamp: procedures>>=
subroutine mci_vamp_instance_discard_integrals (instance, reshape)
class(mci_vamp_instance_t), intent(inout) :: instance
logical, intent(in) :: reshape
instance%calls = 0
instance%calls_valid = 0
instance%integral = 0
instance%error = 0
instance%efficiency = 0
associate (mci => instance%mci)
if (instance%grids_defined) then
if (mci%grid_par%use_vamp_equivalences) then
if (reshape) then
call vamp_discard_integrals (instance%grids, &
num_calls = instance%n_calls, &
stratified = mci%grid_par%stratified, &
eq = mci%equivalences)
else
call vamp_discard_integrals (instance%grids, &
stratified = mci%grid_par%stratified, &
eq = mci%equivalences)
end if
else
if (reshape) then
call vamp_discard_integrals (instance%grids, &
num_calls = instance%n_calls, &
stratified = mci%grid_par%stratified)
else
call vamp_discard_integrals (instance%grids, &
stratified = mci%grid_par%stratified)
end if
end if
else
call msg_bug ("VAMP: discard integrals: grids undefined")
end if
end associate
end subroutine mci_vamp_instance_discard_integrals
@ %def mci_vamp_instance_discard_integrals
@ After grids are created (with equidistant binning and equal weight),
adaptation is redundant. Therefore, we should allow it only after a
complete integration step has been performed, calling this.
<<MCI vamp: mci vamp instance: TBP>>=
procedure :: allow_adaptation => mci_vamp_instance_allow_adaptation
<<MCI vamp: procedures>>=
subroutine mci_vamp_instance_allow_adaptation (instance)
class(mci_vamp_instance_t), intent(inout) :: instance
instance%allow_adapt_grids = .true.
instance%allow_adapt_weights = .true.
end subroutine mci_vamp_instance_allow_adaptation
@ %def mci_vamp_instance_allow_adaptation
@ Adapt grids.
<<MCI vamp: mci vamp instance: TBP>>=
procedure :: adapt_grids => mci_vamp_instance_adapt_grids
<<MCI vamp: procedures>>=
subroutine mci_vamp_instance_adapt_grids (instance)
class(mci_vamp_instance_t), intent(inout) :: instance
if (instance%enable_adapt_grids .and. instance%allow_adapt_grids) then
if (instance%grids_defined) then
call vamp_refine_grids (instance%grids)
instance%n_adapt_grids = instance%n_adapt_grids + 1
else
call msg_bug ("VAMP: adapt grids: grids undefined")
end if
end if
end subroutine mci_vamp_instance_adapt_grids
@ %def mci_vamp_instance_adapt_grids
@ Adapt weights. Use the variance array returned by \vamp\ for
recalculating the weight array. The parameter
[[channel_weights_power]] dampens fluctuations.
If the number of calls in a given channel falls below a user-defined threshold,
the weight is not lowered further but kept at this threshold. The other
channel weights are reduced accordingly.
<<MCI vamp: mci vamp instance: TBP>>=
procedure :: adapt_weights => mci_vamp_instance_adapt_weights
<<MCI vamp: procedures>>=
subroutine mci_vamp_instance_adapt_weights (instance)
class(mci_vamp_instance_t), intent(inout) :: instance
real(default) :: w_sum, w_avg_ch, sum_w_underflow, w_min
real(default), dimension(:), allocatable :: weights
integer :: n_ch, ch, n_underflow
logical, dimension(:), allocatable :: mask, underflow
type(exception) :: vamp_exception
logical :: wsum_non_zero
if (instance%enable_adapt_weights .and. instance%allow_adapt_weights) then
associate (mci => instance%mci)
if (instance%grids_defined) then
allocate (weights (size (instance%grids%weights)))
weights = instance%grids%weights &
* vamp_get_variance (instance%grids%grids) &
** mci%grid_par%channel_weights_power
w_sum = sum (weights)
if (w_sum /= 0) then
weights = weights / w_sum
if (mci%n_chain /= 0) then
allocate (mask (mci%n_channel))
do ch = 1, mci%n_chain
mask = mci%chain == ch
n_ch = count (mask)
if (n_ch /= 0) then
w_avg_ch = sum (weights, mask) / n_ch
where (mask) weights = w_avg_ch
end if
end do
end if
if (mci%grid_par%threshold_calls /= 0) then
w_min = &
real (mci%grid_par%threshold_calls, default) &
/ instance%n_calls
allocate (underflow (mci%n_channel))
underflow = weights /= 0 .and. abs (weights) < w_min
n_underflow = count (underflow)
sum_w_underflow = sum (weights, mask=underflow)
if (sum_w_underflow /= 1) then
where (underflow)
weights = w_min
elsewhere
weights = weights &
* (1 - n_underflow * w_min) / (1 - sum_w_underflow)
end where
end if
end if
end if
call instance%set_channel_weights (weights, wsum_non_zero)
if (wsum_non_zero) call vamp_update_weights &
(instance%grids, weights, exc = vamp_exception)
call handle_vamp_exception (vamp_exception, mci%verbose)
else
call msg_bug ("VAMP: adapt weights: grids undefined")
end if
end associate
instance%n_adapt_weights = instance%n_adapt_weights + 1
end if
end subroutine mci_vamp_instance_adapt_weights
@ %def mci_vamp_instance_adapt_weights
@ Integration: sample the VAMP grids. The number of calls etc. are
already stored inside the grids. We provide the random-number
generator, the sampling function, and a link to the workspace object,
which happens to contain a pointer to the sampler object. The sampler
object thus becomes the workspace of the sampling function.
Note: in the current implementation, the random-number generator must
be the TAO generator. This explicit dependence should be removed from
the VAMP implementation.
<<MCI vamp: mci vamp instance: TBP>>=
procedure :: sample_grids => mci_vamp_instance_sample_grids
<<MCI vamp: procedures>>=
subroutine mci_vamp_instance_sample_grids (instance, rng, sampler, eq)
class(mci_vamp_instance_t), intent(inout), target :: instance
class(rng_t), intent(inout) :: rng
class(mci_sampler_t), intent(inout), target :: sampler
type(vamp_equivalences_t), intent(in), optional :: eq
class(vamp_data_t), allocatable :: data
type(exception) :: vamp_exception
allocate (mci_workspace_t :: data)
select type (data)
type is (mci_workspace_t)
data%sampler => sampler
data%instance => instance
end select
select type (rng)
type is (rng_tao_t)
instance%it = instance%it + 1
instance%calls = 0
if (instance%grids_defined) then
call vamp_sample_grids ( &
rng%state, &
instance%grids, &
vamp_sampling_function, &
data, &
1, &
eq = eq, &
history = instance%v_history(instance%it:), &
histories = instance%v_histories(instance%it:,:), &
integral = instance%integral, &
std_dev = instance%error, &
exc = vamp_exception, &
negative_weights = instance%negative_weights)
call handle_vamp_exception (vamp_exception, instance%mci%verbose)
instance%efficiency = instance%get_efficiency ()
else
call msg_bug ("VAMP: sample grids: grids undefined")
end if
class default
call msg_fatal ("VAMP integration: random-number generator must be TAO")
end select
end subroutine mci_vamp_instance_sample_grids
@ %def mci_vamp_instance_sample_grids
@
Compute the reweighting efficiency for the current grids, suitable
averaged over all active channels.
<<MCI vamp: mci vamp instance: TBP>>=
procedure :: get_efficiency_array => mci_vamp_instance_get_efficiency_array
procedure :: get_efficiency => mci_vamp_instance_get_efficiency
<<MCI vamp: procedures>>=
function mci_vamp_instance_get_efficiency_array (mci) result (efficiency)
class(mci_vamp_instance_t), intent(in) :: mci
real(default), dimension(:), allocatable :: efficiency
allocate (efficiency (mci%mci%n_channel))
if (.not. mci%negative_weights) then
where (mci%grids%grids%f_max /= 0)
efficiency = mci%grids%grids%mu(1) / abs (mci%grids%grids%f_max)
elsewhere
efficiency = 0
end where
else
where (mci%grids%grids%f_max /= 0)
efficiency = &
(mci%grids%grids%mu_plus(1) - mci%grids%grids%mu_minus(1)) &
/ abs (mci%grids%grids%f_max)
elsewhere
efficiency = 0
end where
end if
end function mci_vamp_instance_get_efficiency_array
function mci_vamp_instance_get_efficiency (mci) result (efficiency)
class(mci_vamp_instance_t), intent(in) :: mci
real(default) :: efficiency
real(default), dimension(:), allocatable :: weight
real(default) :: norm
allocate (weight (mci%mci%n_channel))
weight = mci%grids%weights * abs (mci%grids%grids%f_max)
norm = sum (weight)
if (norm /= 0) then
efficiency = dot_product (mci%get_efficiency_array (), weight) / norm
else
efficiency = 1
end if
end function mci_vamp_instance_get_efficiency
@ %def mci_vamp_instance_get_efficiency_array
@ %def mci_vamp_instance_get_efficiency
@ Prepare an event generation pass. Should be called before a sequence of
events is generated, then we should call the corresponding finalizer.
The pass-specific data of the previous integration pass are retained,
but we reset the number of iterations and calls to zero. The latter
now counts the number of events (calls to the sampling function, actually).
<<MCI vamp: mci vamp instance: TBP>>=
procedure :: init_simulation => mci_vamp_instance_init_simulation
<<MCI vamp: procedures>>=
subroutine mci_vamp_instance_init_simulation (instance, safety_factor)
class(mci_vamp_instance_t), intent(inout) :: instance
real(default), intent(in), optional :: safety_factor
associate (mci => instance%mci)
allocate (instance%vamp_x (mci%n_dim))
instance%it = 0
instance%calls = 0
instance%generating_events = .true.
if (present (safety_factor)) instance%safety_factor = safety_factor
if (.not. instance%grids_defined) then
if (mci%grid_filename_set) then
if (.not. mci%check_grid_file) &
call msg_warning ("Reading grid file: MD5 sum check disabled")
call msg_message ("Simulate: " &
// "using integration grids from file '" &
// char (mci%grid_filename) // "'")
call mci%read_grids_data (instance)
if (instance%safety_factor /= 1) then
write (msg_buffer, "(A,ES10.3,A)") "Simulate: &
&applying safety factor", instance%safety_factor, &
" to event rejection"
call msg_message ()
instance%grids%grids%f_max = &
instance%grids%grids%f_max * instance%safety_factor
end if
else
call msg_bug ("VAMP: simulation: no grids, no grid filename")
end if
end if
end associate
end subroutine mci_vamp_instance_init_simulation
@ %def mci_vamp_init_simulation
@ Finalize an event generation pass. Should be called before a sequence of
events is generated, then we should call the corresponding finalizer.
<<MCI vamp: mci vamp instance: TBP>>=
procedure :: final_simulation => mci_vamp_instance_final_simulation
<<MCI vamp: procedures>>=
subroutine mci_vamp_instance_final_simulation (instance)
class(mci_vamp_instance_t), intent(inout) :: instance
if (allocated (instance%vamp_x)) deallocate (instance%vamp_x)
end subroutine mci_vamp_instance_final_simulation
@ %def mci_vamp_instance_final_simulation
@
\subsection{Sampling function}
The VAMP sampling function has a well-defined interface which we have
to implement. The [[data]] argument allows us to pass pointers to the
[[sampler]] and [[instance]] objects, so we can access configuration
data and fill point-dependent contents within these objects.
The [[weights]] and [[channel]] argument must be present in the call.
Note: this is the place where we must look for external signals, i.e.,
interrupt from the OS. We would like to raise a \vamp\ exception which is then
caught by [[vamp_sample_grids]] as the caller, so it dumps its current state
and returns (with the signal still pending). \whizard\ will then terminate
gracefully. Of course, VAMP should be able to resume from the dump.
In the current implementation, we handle the exception in place and terminate
immediately. The incomplete current integration pass is lost.
<<MCI vamp: procedures>>=
function vamp_sampling_function &
(xi, data, weights, channel, grids) result (f)
real(default) :: f
real(default), dimension(:), intent(in) :: xi
class(vamp_data_t), intent(in) :: data
real(default), dimension(:), intent(in), optional :: weights
integer, intent(in), optional :: channel
type(vamp_grid), dimension(:), intent(in), optional :: grids
type(exception) :: exc
logical :: verbose
character(*), parameter :: FN = "WHIZARD sampling function"
class(mci_instance_t), pointer :: instance
select type (data)
type is (mci_workspace_t)
instance => data%instance
select type (instance)
class is (mci_vamp_instance_t)
verbose = instance%mci%verbose
call instance%evaluate (data%sampler, channel, xi)
if (signal_is_pending ()) then
call raise_exception (exc, EXC_FATAL, FN, "signal received")
call handle_vamp_exception (exc, verbose)
call terminate_now_if_signal ()
end if
instance%calls = instance%calls + 1
if (data%sampler%is_valid ()) &
& instance%calls_valid = instance%calls_valid + 1
f = instance%get_value ()
call terminate_now_if_single_event ()
class default
call msg_bug("VAMP: " // FN // ": unknown MCI instance type")
end select
end select
end function vamp_sampling_function
@ %def vamp_sampling_function
@ This is supposed to be the mapping between integration channels.
The VAMP event generating procedures technically require it, but it is
meaningless in our setup where all transformations happen inside the
sampler object. So, this implementation is trivial:
<<MCI vamp: procedures>>=
pure function phi_trivial (xi, channel_dummy) result (x)
real(default), dimension(:), intent(in) :: xi
integer, intent(in) :: channel_dummy
real(default), dimension(size(xi)) :: x
x = xi
end function phi_trivial
@ %def phi_trivial
@
\subsection{Integrator instance: evaluation}
Here, we compute the multi-channel reweighting factor for the current
channel, that accounts for the Jacobians of the transformations
from/to all other channels.
The computation of the VAMP probabilities may consume considerable
time, therefore we enable parallel evaluation. (Collecting the
contributions to [[mci%g]] is a reduction, which we should also
implement via OpenMP.)
<<MCI vamp: mci vamp instance: TBP>>=
procedure :: compute_weight => mci_vamp_instance_compute_weight
<<MCI vamp: procedures>>=
subroutine mci_vamp_instance_compute_weight (mci, c)
class(mci_vamp_instance_t), intent(inout) :: mci
integer, intent(in) :: c
integer :: i
mci%selected_channel = c
!$OMP PARALLEL PRIVATE(i) SHARED(mci)
!$OMP DO
do i = 1, mci%mci%n_channel
if (mci%w(i) /= 0) then
mci%gi(i) = vamp_probability (mci%grids%grids(i), mci%x(:,i))
else
mci%gi(i) = 0
end if
end do
!$OMP END DO
!$OMP END PARALLEL
mci%g = 0
if (mci%gi(c) /= 0) then
do i = 1, mci%mci%n_channel
if (mci%w(i) /= 0 .and. mci%f(i) /= 0) then
mci%g = mci%g + mci%w(i) * mci%gi(i) / mci%f(i)
end if
end do
end if
if (mci%g /= 0) then
mci%mci_weight = mci%gi(c) / mci%g
else
mci%mci_weight = 0
end if
end subroutine mci_vamp_instance_compute_weight
@ %def mci_vamp_instance_compute_weight
@ Record the integrand.
<<MCI vamp: mci vamp instance: TBP>>=
procedure :: record_integrand => mci_vamp_instance_record_integrand
<<MCI vamp: procedures>>=
subroutine mci_vamp_instance_record_integrand (mci, integrand)
class(mci_vamp_instance_t), intent(inout) :: mci
real(default), intent(in) :: integrand
mci%integrand = integrand
end subroutine mci_vamp_instance_record_integrand
@ %def mci_vamp_instance_record_integrand
@ Get the event weight. The default routine returns the same value that
we would use for integration. This is correct if we select the integration
channel according to the channel weight. [[vamp_next_event]] does
differently, so we should rather rely on the weight that VAMP
returns. This is the value stored in [[vamp_weight]]. We override
the default TBP accordingly.
<<MCI vamp: mci vamp instance: TBP>>=
procedure :: get_event_weight => mci_vamp_instance_get_event_weight
procedure :: get_event_excess => mci_vamp_instance_get_event_excess
<<MCI vamp: procedures>>=
function mci_vamp_instance_get_event_weight (mci) result (value)
class(mci_vamp_instance_t), intent(in) :: mci
real(default) :: value
if (mci%vamp_weight_set) then
value = mci%vamp_weight
else
call msg_bug ("VAMP: attempt to read undefined event weight")
end if
end function mci_vamp_instance_get_event_weight
function mci_vamp_instance_get_event_excess (mci) result (value)
class(mci_vamp_instance_t), intent(in) :: mci
real(default) :: value
if (mci%vamp_weight_set) then
value = mci%vamp_excess
else
call msg_bug ("VAMP: attempt to read undefined event excess weight")
end if
end function mci_vamp_instance_get_event_excess
@ %def mci_vamp_instance_get_event_excess
@
\subsection{VAMP exceptions}
A VAMP routine may have raised an exception. Turn this into a WHIZARD
error message.
An external signal could raise a fatal exception, but this should be delayed and
handled by the correct termination routine.
<<MCI vamp: procedures>>=
subroutine handle_vamp_exception (exc, verbose)
type(exception), intent(in) :: exc
logical, intent(in) :: verbose
integer :: exc_level
if (verbose) then
exc_level = EXC_INFO
else
exc_level = EXC_ERROR
end if
if (exc%level >= exc_level) then
write (msg_buffer, "(A,':',1x,A)") trim (exc%origin), trim (exc%message)
select case (exc%level)
case (EXC_INFO); call msg_message ()
case (EXC_WARN); call msg_warning ()
case (EXC_ERROR); call msg_error ()
case (EXC_FATAL)
if (signal_is_pending ()) then
call msg_message ()
else
call msg_fatal ()
end if
end select
end if
end subroutine handle_vamp_exception
@ %def handle_vamp_exception
@
\subsection{Unit tests}
Test module, followed by the corresponding implementation module.
<<[[mci_vamp_ut.f90]]>>=
<<File header>>
module mci_vamp_ut
use unit_tests
use mci_vamp_uti
<<Standard module head>>
<<MCI vamp: public test>>
contains
<<MCI vamp: test driver>>
end module mci_vamp_ut
@ %def mci_vamp_ut
@
<<[[mci_vamp_uti.f90]]>>=
<<File header>>
module mci_vamp_uti
<<Use kinds>>
<<Use strings>>
use io_units
use constants, only: PI, TWOPI
use rng_base
use rng_tao
use phs_base
use mci_base
use vamp, only: vamp_write_grids !NODEP!
use mci_vamp
<<Standard module head>>
<<MCI vamp: test declarations>>
<<MCI vamp: test types>>
contains
<<MCI vamp: tests>>
end module mci_vamp_uti
@ %def mci_vamp_ut
@ API: driver for the unit tests below.
<<MCI vamp: public test>>=
public :: mci_vamp_test
<<MCI vamp: test driver>>=
subroutine mci_vamp_test (u, results)
integer, intent(in) :: u
type(test_results_t), intent(inout) :: results
<<MCI vamp: execute tests>>
end subroutine mci_vamp_test
@ %def mci_vamp_test
@
\subsubsection{Test sampler}
A test sampler object should implement a function with known integral that
we can use to check the integrator.
In mode [[1]], the function is $f(x) = 3 x^2$ with integral $\int_0^1
f(x)\,dx=1$ and maximum $f(1)=3$. If the integration dimension is
greater than one, the function is extended as a constant in the other
dimension(s).
In mode [[2]], the function is $11 x^{10}$, also with integral $1$.
Mode [[4]] includes ranges of zero and negative function value, the
integral is negative. The results should be identical to the results
of [[mci_midpoint_4]], where the same function is evaluated. The
function is $f(x) = (1 - 3 x^2)\,\theta(x-1/2)$ with integral
$\int_0^1 f(x)\,dx=-3/8$, minimum $f(1)=-2$ and maximum $f(1/2)=1/4$.
<<MCI vamp: test types>>=
type, extends (mci_sampler_t) :: test_sampler_1_t
real(default), dimension(:), allocatable :: x
real(default) :: val
integer :: mode = 1
contains
<<MCI vamp: test sampler 1: TBP>>
end type test_sampler_1_t
@ %def test_sampler_1_t
@ Output: There is nothing stored inside, so just print an informative line.
<<MCI vamp: test sampler 1: TBP>>=
procedure :: write => test_sampler_1_write
<<MCI vamp: tests>>=
subroutine test_sampler_1_write (object, unit, testflag)
class(test_sampler_1_t), intent(in) :: object
integer, intent(in), optional :: unit
logical, intent(in), optional :: testflag
integer :: u
u = given_output_unit (unit)
select case (object%mode)
case (1)
write (u, "(1x,A)") "Test sampler: f(x) = 3 x^2"
case (2)
write (u, "(1x,A)") "Test sampler: f(x) = 11 x^10"
case (3)
write (u, "(1x,A)") "Test sampler: f(x) = 11 x^10 * 2 * cos^2 (2 pi y)"
case (4)
write (u, "(1x,A)") "Test sampler: f(x) = (1 - 3 x^2) theta(x - 1/2)"
end select
end subroutine test_sampler_1_write
@ %def test_sampler_1_write
@ Evaluation: compute the function value. The output $x$ parameter
(only one channel) is identical to the input $x$, and the Jacobian is 1.
<<MCI vamp: test sampler 1: TBP>>=
procedure :: evaluate => test_sampler_1_evaluate
<<MCI vamp: tests>>=
subroutine test_sampler_1_evaluate (sampler, c, x_in, val, x, f)
class(test_sampler_1_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
if (allocated (sampler%x)) deallocate (sampler%x)
allocate (sampler%x (size (x_in)))
sampler%x = x_in
select case (sampler%mode)
case (1)
sampler%val = 3 * x_in(1) ** 2
case (2)
sampler%val = 11 * x_in(1) ** 10
case (3)
sampler%val = 11 * x_in(1) ** 10 * 2 * cos (twopi * x_in(2)) ** 2
case (4)
if (x_in(1) >= .5_default) then
sampler%val = 1 - 3 * x_in(1) ** 2
else
sampler%val = 0
end if
end select
call sampler%fetch (val, x, f)
end subroutine test_sampler_1_evaluate
@ %def test_sampler_1_evaluate
@ The point is always valid.
<<MCI vamp: test sampler 1: TBP>>=
procedure :: is_valid => test_sampler_1_is_valid
<<MCI vamp: tests>>=
function test_sampler_1_is_valid (sampler) result (valid)
class(test_sampler_1_t), intent(in) :: sampler
logical :: valid
valid = .true.
end function test_sampler_1_is_valid
@ %def test_sampler_1_is_valid
@ Rebuild: compute all but the function value.
<<MCI vamp: test sampler 1: TBP>>=
procedure :: rebuild => test_sampler_1_rebuild
<<MCI vamp: tests>>=
subroutine test_sampler_1_rebuild (sampler, c, x_in, val, x, f)
class(test_sampler_1_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
if (allocated (sampler%x)) deallocate (sampler%x)
allocate (sampler%x (size (x_in)))
sampler%x = x_in
sampler%val = val
x(:,1) = sampler%x
f = 1
end subroutine test_sampler_1_rebuild
@ %def test_sampler_1_rebuild
@ Extract the results.
<<MCI vamp: test sampler 1: TBP>>=
procedure :: fetch => test_sampler_1_fetch
<<MCI vamp: tests>>=
subroutine test_sampler_1_fetch (sampler, val, x, f)
class(test_sampler_1_t), intent(in) :: sampler
real(default), intent(out) :: val
real(default), dimension(:,:), intent(out) :: x
real(default), dimension(:), intent(out) :: f
val = sampler%val
x(:,1) = sampler%x
f = 1
end subroutine test_sampler_1_fetch
@ %def test_sampler_1_fetch
@
\subsubsection{Two-channel, two dimension test sampler}
This sampler implements the function
\begin{equation}
f(x, y) = 4\sin^2(\pi x)\sin^2(\pi y) + 2\sin^2(\pi v)
\end{equation}
where
\begin{align}
x &= u^v &u &= xy
\\
y &= u^{(1-v)} &v &= \frac12\left(1 + \frac{\log(x/y)}{\log xy}\right)
\end{align}
Each term contributes $1$ to the integral. The first term in the function is
peaked along a cross aligned to the coordinates $x$ and $y$, while the second
term is peaked along the diagonal $x=y$.
The Jacobian is
\begin{equation}
\frac{\partial(x,y)}{\partial(u,v)} = |\log u|
\end{equation}
<<MCI vamp: test types>>=
type, extends (mci_sampler_t) :: test_sampler_2_t
real(default), dimension(:,:), allocatable :: x
real(default), dimension(:), allocatable :: f
real(default) :: val
contains
<<MCI vamp: test sampler 2: TBP>>
end type test_sampler_2_t
@ %def test_sampler_2_t
@ Output: There is nothing stored inside, so just print an informative line.
<<MCI vamp: test sampler 2: TBP>>=
procedure :: write => test_sampler_2_write
<<MCI vamp: tests>>=
subroutine test_sampler_2_write (object, unit, testflag)
class(test_sampler_2_t), intent(in) :: object
integer, intent(in), optional :: unit
logical, intent(in), optional :: testflag
integer :: u
u = given_output_unit (unit)
write (u, "(1x,A)") "Two-channel test sampler 2"
end subroutine test_sampler_2_write
@ %def test_sampler_2_write
@ Kinematics: compute $x$ and Jacobians, given the input parameter array.
<<MCI vamp: test sampler 2: TBP>>=
procedure :: compute => test_sampler_2_compute
<<MCI vamp: tests>>=
subroutine test_sampler_2_compute (sampler, c, x_in)
class(test_sampler_2_t), intent(inout) :: sampler
integer, intent(in) :: c
real(default), dimension(:), intent(in) :: x_in
real(default) :: xx, yy, uu, vv
if (.not. allocated (sampler%x)) &
allocate (sampler%x (size (x_in), 2))
if (.not. allocated (sampler%f)) &
allocate (sampler%f (2))
select case (c)
case (1)
xx = x_in(1)
yy = x_in(2)
uu = xx * yy
vv = (1 + log (xx/yy) / log (xx*yy)) / 2
case (2)
uu = x_in(1)
vv = x_in(2)
xx = uu ** vv
yy = uu ** (1 - vv)
end select
sampler%val = (2 * sin (pi * xx) * sin (pi * yy)) ** 2 &
+ 2 * sin (pi * vv) ** 2
sampler%f(1) = 1
sampler%f(2) = abs (log (uu))
sampler%x(:,1) = [xx, yy]
sampler%x(:,2) = [uu, vv]
end subroutine test_sampler_2_compute
@ %def test_sampler_kinematics
@ Evaluation: compute the function value. The output $x$ parameter
(only one channel) is identical to the input $x$, and the Jacobian is 1.
<<MCI vamp: test sampler 2: TBP>>=
procedure :: evaluate => test_sampler_2_evaluate
<<MCI vamp: tests>>=
subroutine test_sampler_2_evaluate (sampler, c, x_in, val, x, f)
class(test_sampler_2_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%compute (c, x_in)
call sampler%fetch (val, x, f)
end subroutine test_sampler_2_evaluate
@ %def test_sampler_2_evaluate
@ The point is always valid.
<<MCI vamp: test sampler 2: TBP>>=
procedure :: is_valid => test_sampler_2_is_valid
<<MCI vamp: tests>>=
function test_sampler_2_is_valid (sampler) result (valid)
class(test_sampler_2_t), intent(in) :: sampler
logical :: valid
valid = .true.
end function test_sampler_2_is_valid
@ %def test_sampler_2_is_valid
@ Rebuild: compute all but the function value.
<<MCI vamp: test sampler 2: TBP>>=
procedure :: rebuild => test_sampler_2_rebuild
<<MCI vamp: tests>>=
subroutine test_sampler_2_rebuild (sampler, c, x_in, val, x, f)
class(test_sampler_2_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 sampler%compute (c, x_in)
x = sampler%x
f = sampler%f
end subroutine test_sampler_2_rebuild
@ %def test_sampler_2_rebuild
@ Extract the results.
<<MCI vamp: test sampler 2: TBP>>=
procedure :: fetch => test_sampler_2_fetch
<<MCI vamp: tests>>=
subroutine test_sampler_2_fetch (sampler, val, x, f)
class(test_sampler_2_t), intent(in) :: sampler
real(default), intent(out) :: val
real(default), dimension(:,:), intent(out) :: x
real(default), dimension(:), intent(out) :: f
val = sampler%val
x = sampler%x
f = sampler%f
end subroutine test_sampler_2_fetch
@ %def test_sampler_2_fetch
@
\subsubsection{Two-channel, one dimension test sampler}
This sampler implements the function
\begin{equation}
f(x, y) = a * 5 x^4 + b * 5 (1-x)^4
\end{equation}
Each term contributes $1$ to the integral, multiplied by $a$ or $b$,
respectively. The first term is peaked at $x=1$, the second one at $x=0$..
We implement the two mappings
\begin{equation}
x = u^{1/5} \quad\text{and}\quad x = 1 - v^{1/5},
\end{equation}
with Jacobians
\begin{equation}
\frac{\partial(x)}{\partial(u)} = u^{-4/5}/5 \quad\text{and}\quad v^{-4/5}/5,
\end{equation}
respectively. The first mapping concentrates points near $x=1$, the
second one near $x=0$.
<<MCI vamp: test types>>=
type, extends (mci_sampler_t) :: test_sampler_3_t
real(default), dimension(:,:), allocatable :: x
real(default), dimension(:), allocatable :: f
real(default) :: val
real(default) :: a = 1
real(default) :: b = 1
contains
<<MCI vamp: test sampler 3: TBP>>
end type test_sampler_3_t
@ %def test_sampler_3_t
@ Output: display $a$ and $b$
<<MCI vamp: test sampler 3: TBP>>=
procedure :: write => test_sampler_3_write
<<MCI vamp: tests>>=
subroutine test_sampler_3_write (object, unit, testflag)
class(test_sampler_3_t), intent(in) :: object
integer, intent(in), optional :: unit
logical, intent(in), optional :: testflag
integer :: u
u = given_output_unit (unit)
write (u, "(1x,A)") "Two-channel test sampler 3"
write (u, "(3x,A,F5.2)") "a = ", object%a
write (u, "(3x,A,F5.2)") "b = ", object%b
end subroutine test_sampler_3_write
@ %def test_sampler_3_write
@ Kinematics: compute $x$ and Jacobians, given the input parameter array.
<<MCI vamp: test sampler 3: TBP>>=
procedure :: compute => test_sampler_3_compute
<<MCI vamp: tests>>=
subroutine test_sampler_3_compute (sampler, c, x_in)
class(test_sampler_3_t), intent(inout) :: sampler
integer, intent(in) :: c
real(default), dimension(:), intent(in) :: x_in
real(default) :: u, v, xx
if (.not. allocated (sampler%x)) &
allocate (sampler%x (size (x_in), 2))
if (.not. allocated (sampler%f)) &
allocate (sampler%f (2))
select case (c)
case (1)
u = x_in(1)
xx = u ** 0.2_default
v = (1 - xx) ** 5._default
case (2)
v = x_in(1)
xx = 1 - v ** 0.2_default
u = xx ** 5._default
end select
sampler%val = sampler%a * 5 * xx ** 4 + sampler%b * 5 * (1 - xx) ** 4
sampler%f(1) = 0.2_default * u ** (-0.8_default)
sampler%f(2) = 0.2_default * v ** (-0.8_default)
sampler%x(:,1) = [u]
sampler%x(:,2) = [v]
end subroutine test_sampler_3_compute
@ %def test_sampler_kineamtics
@ Evaluation: compute the function value. The output $x$ parameter
(only one channel) is identical to the input $x$, and the Jacobian is 1.
<<MCI vamp: test sampler 3: TBP>>=
procedure :: evaluate => test_sampler_3_evaluate
<<MCI vamp: tests>>=
subroutine test_sampler_3_evaluate (sampler, c, x_in, val, x, f)
class(test_sampler_3_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%compute (c, x_in)
call sampler%fetch (val, x, f)
end subroutine test_sampler_3_evaluate
@ %def test_sampler_3_evaluate
@ The point is always valid.
<<MCI vamp: test sampler 3: TBP>>=
procedure :: is_valid => test_sampler_3_is_valid
<<MCI vamp: tests>>=
function test_sampler_3_is_valid (sampler) result (valid)
class(test_sampler_3_t), intent(in) :: sampler
logical :: valid
valid = .true.
end function test_sampler_3_is_valid
@ %def test_sampler_3_is_valid
@ Rebuild: compute all but the function value.
<<MCI vamp: test sampler 3: TBP>>=
procedure :: rebuild => test_sampler_3_rebuild
<<MCI vamp: tests>>=
subroutine test_sampler_3_rebuild (sampler, c, x_in, val, x, f)
class(test_sampler_3_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 sampler%compute (c, x_in)
x = sampler%x
f = sampler%f
end subroutine test_sampler_3_rebuild
@ %def test_sampler_3_rebuild
@ Extract the results.
<<MCI vamp: test sampler 3: TBP>>=
procedure :: fetch => test_sampler_3_fetch
<<MCI vamp: tests>>=
subroutine test_sampler_3_fetch (sampler, val, x, f)
class(test_sampler_3_t), intent(in) :: sampler
real(default), intent(out) :: val
real(default), dimension(:,:), intent(out) :: x
real(default), dimension(:), intent(out) :: f
val = sampler%val
x = sampler%x
f = sampler%f
end subroutine test_sampler_3_fetch
@ %def test_sampler_3_fetch
@
\subsubsection{One-dimensional integration}
Construct an integrator and use it for a one-dimensional sampler.
Note: We would like to check the precise contents of the grid
allocated during integration, but the output format for reals is very
long (for good reasons), so the last digits in the grid content
display are numerical noise. So, we just check the integration
results.
<<MCI vamp: execute tests>>=
call test (mci_vamp_1, "mci_vamp_1", &
"one-dimensional integral", &
u, results)
<<MCI vamp: test declarations>>=
public :: mci_vamp_1
<<MCI vamp: tests>>=
subroutine mci_vamp_1 (u)
integer, intent(in) :: u
type(grid_parameters_t) :: grid_par
class(mci_t), allocatable, target :: mci
class(mci_instance_t), pointer :: mci_instance => null ()
class(mci_sampler_t), allocatable :: sampler
class(rng_t), allocatable :: rng
write (u, "(A)") "* Test output: mci_vamp_1"
write (u, "(A)") "* Purpose: integrate function in one dimension &
&(single channel)"
write (u, "(A)")
write (u, "(A)") "* Initialize integrator"
write (u, "(A)")
allocate (mci_vamp_t :: mci)
call mci%set_dimensions (1, 1)
select type (mci)
type is (mci_vamp_t)
grid_par%use_vamp_equivalences = .false.
call mci%set_grid_parameters (grid_par)
end select
allocate (rng_tao_t :: rng)
call rng%init ()
call mci%import_rng (rng)
call mci%write (u)
write (u, "(A)")
write (u, "(A)") "* Initialize instance"
write (u, "(A)")
call mci%allocate_instance (mci_instance)
call mci_instance%init (mci)
write (u, "(A)") "* Initialize test sampler"
write (u, "(A)")
allocate (test_sampler_1_t :: sampler)
call sampler%write (u)
write (u, "(A)")
write (u, "(A)") "* Integrate with n_calls = 1000"
write (u, "(A)") " (lower precision to avoid"
write (u, "(A)") " numerical noise)"
write (u, "(A)")
select type (mci)
type is (mci_vamp_t)
call mci%add_pass ()
end select
call mci%integrate (mci_instance, sampler, 1, 1000, pacify = .true.)
call mci%write (u, .true.)
write (u, "(A)")
write (u, "(A)") "* Contents of mci_instance:"
write (u, "(A)")
call mci_instance%write (u, .true.)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call mci_instance%final ()
call mci%final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: mci_vamp_1"
end subroutine mci_vamp_1
@ %def mci_vamp_1
@
\subsubsection{Multiple iterations}
Construct an integrator and use it for a one-dimensional sampler.
Integrate with five iterations without grid adaptation.
<<MCI vamp: execute tests>>=
call test (mci_vamp_2, "mci_vamp_2", &
"multiple iterations", &
u, results)
<<MCI vamp: test declarations>>=
public :: mci_vamp_2
<<MCI vamp: tests>>=
subroutine mci_vamp_2 (u)
integer, intent(in) :: u
type(grid_parameters_t) :: grid_par
class(mci_t), allocatable, target :: mci
class(mci_instance_t), pointer :: mci_instance => null ()
class(mci_sampler_t), allocatable :: sampler
class(rng_t), allocatable :: rng
write (u, "(A)") "* Test output: mci_vamp_2"
write (u, "(A)") "* Purpose: integrate function in one dimension &
&(single channel)"
write (u, "(A)")
write (u, "(A)") "* Initialize integrator, sampler, instance"
write (u, "(A)")
allocate (mci_vamp_t :: mci)
call mci%set_dimensions (1, 1)
select type (mci)
type is (mci_vamp_t)
grid_par%use_vamp_equivalences = .false.
call mci%set_grid_parameters (grid_par)
end select
allocate (rng_tao_t :: rng)
call rng%init ()
call mci%import_rng (rng)
call mci%allocate_instance (mci_instance)
call mci_instance%init (mci)
allocate (test_sampler_1_t :: sampler)
select type (sampler)
type is (test_sampler_1_t)
sampler%mode = 2
end select
call sampler%write (u)
write (u, "(A)")
write (u, "(A)") "* Integrate with n_it = 3 and n_calls = 100"
write (u, "(A)")
select type (mci)
type is (mci_vamp_t)
call mci%add_pass (adapt_grids = .false.)
end select
call mci%integrate (mci_instance, sampler, 3, 100)
call mci%write (u)
write (u, "(A)")
write (u, "(A)") "* Contents of mci_instance:"
write (u, "(A)")
call mci_instance%write (u)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call mci_instance%final ()
call mci%final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: mci_vamp_2"
end subroutine mci_vamp_2
@ %def mci_vamp_2
@
\subsubsection{Grid adaptation}
Construct an integrator and use it for a one-dimensional sampler.
Integrate with three iterations and in-between grid adaptations.
<<MCI vamp: execute tests>>=
call test (mci_vamp_3, "mci_vamp_3", &
"grid adaptation", &
u, results)
<<MCI vamp: test declarations>>=
public :: mci_vamp_3
<<MCI vamp: tests>>=
subroutine mci_vamp_3 (u)
integer, intent(in) :: u
type(grid_parameters_t) :: grid_par
class(mci_t), allocatable, target :: mci
class(mci_instance_t), pointer :: mci_instance => null ()
class(mci_sampler_t), allocatable :: sampler
class(rng_t), allocatable :: rng
write (u, "(A)") "* Test output: mci_vamp_3"
write (u, "(A)") "* Purpose: integrate function in one dimension &
&(single channel)"
write (u, "(A)") "* and adapt grid"
write (u, "(A)")
write (u, "(A)") "* Initialize integrator, sampler, instance"
write (u, "(A)")
allocate (mci_vamp_t :: mci)
call mci%set_dimensions (1, 1)
select type (mci)
type is (mci_vamp_t)
grid_par%use_vamp_equivalences = .false.
call mci%set_grid_parameters (grid_par)
end select
allocate (rng_tao_t :: rng)
call rng%init ()
call mci%import_rng (rng)
call mci%allocate_instance (mci_instance)
call mci_instance%init (mci)
allocate (test_sampler_1_t :: sampler)
select type (sampler)
type is (test_sampler_1_t)
sampler%mode = 2
end select
call sampler%write (u)
write (u, "(A)")
write (u, "(A)") "* Integrate with n_it = 3 and n_calls = 100"
write (u, "(A)")
select type (mci)
type is (mci_vamp_t)
call mci%add_pass (adapt_grids = .true.)
end select
call mci%integrate (mci_instance, sampler, 3, 100)
call mci%write (u)
write (u, "(A)")
write (u, "(A)") "* Contents of mci_instance:"
write (u, "(A)")
call mci_instance%write (u)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call mci_instance%final ()
call mci%final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: mci_vamp_3"
end subroutine mci_vamp_3
@ %def mci_vamp_3
@
\subsubsection{Two-dimensional integral}
Construct an integrator and use it for a two-dimensional sampler.
Integrate with three iterations and in-between grid adaptations.
<<MCI vamp: execute tests>>=
call test (mci_vamp_4, "mci_vamp_4", &
"two-dimensional integration", &
u, results)
<<MCI vamp: test declarations>>=
public :: mci_vamp_4
<<MCI vamp: tests>>=
subroutine mci_vamp_4 (u)
integer, intent(in) :: u
type(grid_parameters_t) :: grid_par
class(mci_t), allocatable, target :: mci
class(mci_instance_t), pointer :: mci_instance => null ()
class(mci_sampler_t), allocatable :: sampler
class(rng_t), allocatable :: rng
write (u, "(A)") "* Test output: mci_vamp_4"
write (u, "(A)") "* Purpose: integrate function in two dimensions &
&(single channel)"
write (u, "(A)") "* and adapt grid"
write (u, "(A)")
write (u, "(A)") "* Initialize integrator, sampler, instance"
write (u, "(A)")
allocate (mci_vamp_t :: mci)
call mci%set_dimensions (2, 1)
select type (mci)
type is (mci_vamp_t)
grid_par%use_vamp_equivalences = .false.
call mci%set_grid_parameters (grid_par)
end select
allocate (rng_tao_t :: rng)
call rng%init ()
call mci%import_rng (rng)
call mci%allocate_instance (mci_instance)
call mci_instance%init (mci)
allocate (test_sampler_1_t :: sampler)
select type (sampler)
type is (test_sampler_1_t)
sampler%mode = 3
end select
call sampler%write (u)
write (u, "(A)")
write (u, "(A)") "* Integrate with n_it = 3 and n_calls = 1000"
write (u, "(A)")
select type (mci)
type is (mci_vamp_t)
call mci%add_pass (adapt_grids = .true.)
end select
call mci%integrate (mci_instance, sampler, 3, 1000)
call mci%write (u)
write (u, "(A)")
write (u, "(A)") "* Contents of mci_instance:"
write (u, "(A)")
call mci_instance%write (u)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call mci_instance%final ()
call mci%final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: mci_vamp_4"
end subroutine mci_vamp_4
@ %def mci_vamp_4
@
\subsubsection{Two-channel integral}
Construct an integrator and use it for a two-dimensional sampler with two
channels.
Integrate with three iterations and in-between grid adaptations.
<<MCI vamp: execute tests>>=
call test (mci_vamp_5, "mci_vamp_5", &
"two-dimensional integration", &
u, results)
<<MCI vamp: test declarations>>=
public :: mci_vamp_5
<<MCI vamp: tests>>=
subroutine mci_vamp_5 (u)
integer, intent(in) :: u
type(grid_parameters_t) :: grid_par
class(mci_t), allocatable, target :: mci
class(mci_instance_t), pointer :: mci_instance => null ()
class(mci_sampler_t), allocatable :: sampler
class(rng_t), allocatable :: rng
write (u, "(A)") "* Test output: mci_vamp_5"
write (u, "(A)") "* Purpose: integrate function in two dimensions &
&(two channels)"
write (u, "(A)") "* and adapt grid"
write (u, "(A)")
write (u, "(A)") "* Initialize integrator, sampler, instance"
write (u, "(A)")
allocate (mci_vamp_t :: mci)
call mci%set_dimensions (2, 2)
select type (mci)
type is (mci_vamp_t)
grid_par%stratified = .false.
grid_par%use_vamp_equivalences = .false.
call mci%set_grid_parameters (grid_par)
end select
allocate (rng_tao_t :: rng)
call rng%init ()
call mci%import_rng (rng)
call mci%allocate_instance (mci_instance)
call mci_instance%init (mci)
allocate (test_sampler_2_t :: sampler)
call sampler%write (u)
write (u, "(A)")
write (u, "(A)") "* Integrate with n_it = 3 and n_calls = 1000"
write (u, "(A)")
select type (mci)
type is (mci_vamp_t)
call mci%add_pass (adapt_grids = .true.)
end select
call mci%integrate (mci_instance, sampler, 3, 1000)
call mci%write (u)
write (u, "(A)")
write (u, "(A)") "* Contents of mci_instance:"
write (u, "(A)")
call mci_instance%write (u)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call mci_instance%final ()
call mci%final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: mci_vamp_5"
end subroutine mci_vamp_5
@ %def mci_vamp_5
@
\subsubsection{Weight adaptation}
Construct an integrator and use it for a one-dimensional sampler with two
channels.
Integrate with three iterations and in-between weight adaptations.
<<MCI vamp: execute tests>>=
call test (mci_vamp_6, "mci_vamp_6", &
"weight adaptation", &
u, results)
<<MCI vamp: test declarations>>=
public :: mci_vamp_6
<<MCI vamp: tests>>=
subroutine mci_vamp_6 (u)
integer, intent(in) :: u
type(grid_parameters_t) :: grid_par
class(mci_t), allocatable, target :: mci
class(mci_instance_t), pointer :: mci_instance => null ()
class(mci_sampler_t), allocatable :: sampler
class(rng_t), allocatable :: rng
write (u, "(A)") "* Test output: mci_vamp_6"
write (u, "(A)") "* Purpose: integrate function in one dimension &
&(two channels)"
write (u, "(A)") "* and adapt weights"
write (u, "(A)")
write (u, "(A)") "* Initialize integrator, sampler, instance"
write (u, "(A)")
allocate (mci_vamp_t :: mci)
call mci%set_dimensions (1, 2)
select type (mci)
type is (mci_vamp_t)
grid_par%stratified = .false.
grid_par%use_vamp_equivalences = .false.
call mci%set_grid_parameters (grid_par)
end select
allocate (rng_tao_t :: rng)
call rng%init ()
call mci%import_rng (rng)
call mci%allocate_instance (mci_instance)
call mci_instance%init (mci)
allocate (test_sampler_3_t :: sampler)
select type (sampler)
type is (test_sampler_3_t)
sampler%a = 0.9_default
sampler%b = 0.1_default
end select
call sampler%write (u)
write (u, "(A)")
write (u, "(A)") "* Integrate with n_it = 3 and n_calls = 1000"
write (u, "(A)")
select type (mci)
type is (mci_vamp_t)
call mci%add_pass (adapt_weights = .true.)
end select
call mci%integrate (mci_instance, sampler, 3, 1000)
call mci%write (u)
write (u, "(A)")
write (u, "(A)") "* Contents of mci_instance:"
write (u, "(A)")
call mci_instance%write (u)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call mci_instance%final ()
call mci%final ()
deallocate (mci_instance)
deallocate (mci)
write (u, "(A)")
write (u, "(A)") "* Re-initialize with chained channels"
write (u, "(A)")
allocate (mci_vamp_t :: mci)
call mci%set_dimensions (1, 2)
call mci%declare_chains ([1,1])
select type (mci)
type is (mci_vamp_t)
grid_par%stratified = .false.
grid_par%use_vamp_equivalences = .false.
call mci%set_grid_parameters (grid_par)
end select
allocate (rng_tao_t :: rng)
call rng%init ()
call mci%import_rng (rng)
call mci%allocate_instance (mci_instance)
call mci_instance%init (mci)
write (u, "(A)") "* Integrate with n_it = 3 and n_calls = 1000"
write (u, "(A)")
select type (mci)
type is (mci_vamp_t)
call mci%add_pass (adapt_weights = .true.)
end select
call mci%integrate (mci_instance, sampler, 3, 1000)
call mci%write (u)
write (u, "(A)")
write (u, "(A)") "* Contents of mci_instance:"
write (u, "(A)")
call mci_instance%write (u)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call mci_instance%final ()
call mci%final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: mci_vamp_6"
end subroutine mci_vamp_6
@ %def mci_vamp_6
@
\subsubsection{Equivalences}
Construct an integrator and use it for a one-dimensional sampler with two
channels.
Integrate with three iterations and in-between grid adaptations.
Apply an equivalence between the two channels, so the binning of the
two channels is forced to coincide. Compare this with the behavior
without equivalences.
<<MCI vamp: execute tests>>=
call test (mci_vamp_7, "mci_vamp_7", &
"use channel equivalences", &
u, results)
<<MCI vamp: test declarations>>=
public :: mci_vamp_7
<<MCI vamp: tests>>=
subroutine mci_vamp_7 (u)
integer, intent(in) :: u
type(grid_parameters_t) :: grid_par
class(mci_t), allocatable, target :: mci
class(mci_instance_t), pointer :: mci_instance => null ()
class(mci_sampler_t), allocatable :: sampler
type(phs_channel_t), dimension(:), allocatable :: channel
class(rng_t), allocatable :: rng
real(default), dimension(:,:), allocatable :: x
integer :: u_grid, iostat, i, div, ch
character(16) :: buffer
write (u, "(A)") "* Test output: mci_vamp_7"
write (u, "(A)") "* Purpose: check effect of channel equivalences"
write (u, "(A)")
write (u, "(A)") "* Initialize integrator, sampler, instance"
write (u, "(A)")
allocate (mci_vamp_t :: mci)
call mci%set_dimensions (1, 2)
select type (mci)
type is (mci_vamp_t)
grid_par%stratified = .false.
grid_par%use_vamp_equivalences = .false.
call mci%set_grid_parameters (grid_par)
end select
allocate (rng_tao_t :: rng)
call rng%init ()
call mci%import_rng (rng)
call mci%allocate_instance (mci_instance)
call mci_instance%init (mci)
allocate (test_sampler_3_t :: sampler)
select type (sampler)
type is (test_sampler_3_t)
sampler%a = 0.7_default
sampler%b = 0.3_default
end select
call sampler%write (u)
write (u, "(A)")
write (u, "(A)") "* Integrate with n_it = 2 and n_calls = 1000, &
&adapt grids"
write (u, "(A)")
select type (mci)
type is (mci_vamp_t)
call mci%add_pass (adapt_grids = .true.)
end select
call mci%integrate (mci_instance, sampler, 2, 1000)
call mci%write (u)
write (u, "(A)")
write (u, "(A)") "* Write grids and extract binning"
write (u, "(A)")
u_grid = free_unit ()
open (u_grid, status = "scratch", action = "readwrite")
select type (mci_instance)
type is (mci_vamp_instance_t)
call vamp_write_grids (mci_instance%grids, u_grid)
end select
rewind (u_grid)
allocate (x (0:20, 2))
do div = 1, 2
FIND_BINS1: do
read (u_grid, "(A)") buffer
if (trim (adjustl (buffer)) == "begin d%x") then
do
read (u_grid, *, iostat = iostat) i, x(i,div)
if (iostat /= 0) exit FIND_BINS1
end do
end if
end do FIND_BINS1
end do
close (u_grid)
write (u, "(1x,A,L1)") "Equal binning in both channels = ", &
all (x(:,1) == x(:,2))
deallocate (x)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call mci_instance%final ()
call mci%final ()
deallocate (mci_instance)
deallocate (mci)
write (u, "(A)")
write (u, "(A)") "* Re-initialize integrator, instance"
write (u, "(A)")
allocate (mci_vamp_t :: mci)
call mci%set_dimensions (1, 2)
select type (mci)
type is (mci_vamp_t)
grid_par%stratified = .false.
grid_par%use_vamp_equivalences = .true.
call mci%set_grid_parameters (grid_par)
end select
write (u, "(A)") "* Define equivalences"
write (u, "(A)")
allocate (channel (2))
do ch = 1, 2
allocate (channel(ch)%eq (2))
do i = 1, 2
associate (eq => channel(ch)%eq(i))
call eq%init (1)
eq%c = i
eq%perm = [1]
eq%mode = [0]
end associate
end do
write (u, "(1x,I0,':')", advance = "no") ch
call channel(ch)%write (u)
end do
call mci%declare_equivalences (channel, dim_offset = 0)
allocate (rng_tao_t :: rng)
call rng%init ()
call mci%import_rng (rng)
call mci%allocate_instance (mci_instance)
call mci_instance%init (mci)
write (u, "(A)")
write (u, "(A)") "* Integrate with n_it = 2 and n_calls = 1000, &
&adapt grids"
write (u, "(A)")
select type (mci)
type is (mci_vamp_t)
call mci%add_pass (adapt_grids = .true.)
end select
call mci%integrate (mci_instance, sampler, 2, 1000)
call mci%write (u)
write (u, "(A)")
write (u, "(A)") "* Write grids and extract binning"
write (u, "(A)")
u_grid = free_unit ()
open (u_grid, status = "scratch", action = "readwrite")
select type (mci_instance)
type is (mci_vamp_instance_t)
call vamp_write_grids (mci_instance%grids, u_grid)
end select
rewind (u_grid)
allocate (x (0:20, 2))
do div = 1, 2
FIND_BINS2: do
read (u_grid, "(A)") buffer
if (trim (adjustl (buffer)) == "begin d%x") then
do
read (u_grid, *, iostat = iostat) i, x(i,div)
if (iostat /= 0) exit FIND_BINS2
end do
end if
end do FIND_BINS2
end do
close (u_grid)
write (u, "(1x,A,L1)") "Equal binning in both channels = ", &
all (x(:,1) == x(:,2))
deallocate (x)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call mci_instance%final ()
call mci%final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: mci_vamp_7"
end subroutine mci_vamp_7
@ %def mci_vamp_7
@
\subsubsection{Multiple passes}
Integrate with three passes and different settings for weight and grid
adaptation.
<<MCI vamp: execute tests>>=
call test (mci_vamp_8, "mci_vamp_8", &
"integration passes", &
u, results)
<<MCI vamp: test declarations>>=
public :: mci_vamp_8
<<MCI vamp: tests>>=
subroutine mci_vamp_8 (u)
integer, intent(in) :: u
type(grid_parameters_t) :: grid_par
class(mci_t), allocatable, target :: mci
class(mci_instance_t), pointer :: mci_instance => null ()
class(mci_sampler_t), allocatable :: sampler
class(rng_t), allocatable :: rng
write (u, "(A)") "* Test output: mci_vamp_8"
write (u, "(A)") "* Purpose: integrate function in one dimension &
&(two channels)"
write (u, "(A)") "* in three passes"
write (u, "(A)")
write (u, "(A)") "* Initialize integrator, sampler, instance"
write (u, "(A)")
allocate (mci_vamp_t :: mci)
call mci%set_dimensions (1, 2)
select type (mci)
type is (mci_vamp_t)
grid_par%stratified = .false.
grid_par%use_vamp_equivalences = .false.
call mci%set_grid_parameters (grid_par)
end select
allocate (rng_tao_t :: rng)
call rng%init ()
call mci%import_rng (rng)
call mci%allocate_instance (mci_instance)
call mci_instance%init (mci)
allocate (test_sampler_3_t :: sampler)
select type (sampler)
type is (test_sampler_3_t)
sampler%a = 0.9_default
sampler%b = 0.1_default
end select
call sampler%write (u)
write (u, "(A)")
write (u, "(A)") "* Integrate with grid and weight adaptation"
write (u, "(A)")
select type (mci)
type is (mci_vamp_t)
call mci%add_pass (adapt_grids = .true., adapt_weights = .true.)
end select
call mci%integrate (mci_instance, sampler, 3, 1000)
call mci%write (u)
write (u, "(A)")
write (u, "(A)") "* Contents of mci_instance:"
write (u, "(A)")
call mci_instance%write (u)
write (u, "(A)")
write (u, "(A)") "* Integrate with grid adaptation"
write (u, "(A)")
select type (mci)
type is (mci_vamp_t)
call mci%add_pass (adapt_grids = .true.)
end select
call mci%integrate (mci_instance, sampler, 3, 1000)
call mci%write (u)
write (u, "(A)")
write (u, "(A)") "* Contents of mci_instance:"
write (u, "(A)")
call mci_instance%write (u)
write (u, "(A)")
write (u, "(A)") "* Integrate without adaptation"
write (u, "(A)")
select type (mci)
type is (mci_vamp_t)
call mci%add_pass ()
end select
call mci%integrate (mci_instance, sampler, 3, 1000)
call mci%write (u)
write (u, "(A)")
write (u, "(A)") "* Contents of mci_instance:"
write (u, "(A)")
call mci_instance%write (u)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call mci_instance%final ()
call mci%final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: mci_vamp_8"
end subroutine mci_vamp_8
@ %def mci_vamp_8
@
\subsubsection{Weighted events}
Construct an integrator and use it for a two-dimensional sampler with two
channels. Integrate and generate a weighted event.
<<MCI vamp: execute tests>>=
call test (mci_vamp_9, "mci_vamp_9", &
"weighted event", &
u, results)
<<MCI vamp: test declarations>>=
public :: mci_vamp_9
<<MCI vamp: tests>>=
subroutine mci_vamp_9 (u)
integer, intent(in) :: u
type(grid_parameters_t) :: grid_par
class(mci_t), allocatable, target :: mci
class(mci_instance_t), pointer :: mci_instance => null ()
class(mci_sampler_t), allocatable :: sampler
class(rng_t), allocatable :: rng
write (u, "(A)") "* Test output: mci_vamp_9"
write (u, "(A)") "* Purpose: integrate function in two dimensions &
&(two channels)"
write (u, "(A)") "* and generate a weighted event"
write (u, "(A)")
write (u, "(A)") "* Initialize integrator, sampler, instance"
write (u, "(A)")
allocate (mci_vamp_t :: mci)
call mci%set_dimensions (2, 2)
select type (mci)
type is (mci_vamp_t)
grid_par%stratified = .false.
grid_par%use_vamp_equivalences = .false.
call mci%set_grid_parameters (grid_par)
end select
allocate (rng_tao_t :: rng)
call rng%init ()
call mci%import_rng (rng)
call mci%allocate_instance (mci_instance)
call mci_instance%init (mci)
allocate (test_sampler_2_t :: sampler)
call sampler%write (u)
write (u, "(A)")
write (u, "(A)") "* Integrate with n_it = 3 and n_calls = 1000"
write (u, "(A)")
call mci%add_pass ()
call mci%integrate (mci_instance, sampler, 1, 1000)
call mci%write (u)
write (u, "(A)")
write (u, "(A)") "* Generate a weighted event"
write (u, "(A)")
call mci_instance%init_simulation ()
call mci%generate_weighted_event (mci_instance, sampler)
write (u, "(1x,A)") "MCI instance:"
call mci_instance%write (u)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call mci_instance%final_simulation ()
call mci_instance%final ()
call mci%final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: mci_vamp_9"
end subroutine mci_vamp_9
@ %def mci_vamp_9
@
\subsubsection{Grids I/O}
Construct an integrator and allocate grids. Write grids to file, read
them in again and compare.
<<MCI vamp: execute tests>>=
call test (mci_vamp_10, "mci_vamp_10", &
"grids I/O", &
u, results)
<<MCI vamp: test declarations>>=
public :: mci_vamp_10
<<MCI vamp: tests>>=
subroutine mci_vamp_10 (u)
integer, intent(in) :: u
type(grid_parameters_t) :: grid_par
class(mci_t), allocatable, target :: mci
class(mci_instance_t), pointer :: mci_instance => null ()
class(mci_sampler_t), allocatable :: sampler
class(rng_t), allocatable :: rng
type(string_t) :: file1, file2
character(80) :: buffer1, buffer2
integer :: u1, u2, iostat1, iostat2
logical :: equal, success
write (u, "(A)") "* Test output: mci_vamp_10"
write (u, "(A)") "* Purpose: write and read VAMP grids"
write (u, "(A)")
write (u, "(A)") "* Initialize integrator, sampler, instance"
write (u, "(A)")
allocate (mci_vamp_t :: mci)
call mci%set_dimensions (2, 2)
select type (mci)
type is (mci_vamp_t)
grid_par%stratified = .false.
grid_par%use_vamp_equivalences = .false.
call mci%set_grid_parameters (grid_par)
end select
allocate (rng_tao_t :: rng)
call rng%init ()
call mci%import_rng (rng)
mci%md5sum = "1234567890abcdef1234567890abcdef"
call mci%allocate_instance (mci_instance)
call mci_instance%init (mci)
allocate (test_sampler_2_t :: sampler)
call sampler%write (u)
write (u, "(A)")
write (u, "(A)") "* Integrate with n_it = 3 and n_calls = 1000"
write (u, "(A)")
call mci%add_pass ()
call mci%integrate (mci_instance, sampler, 1, 1000)
write (u, "(A)") "* Write grids to file"
write (u, "(A)")
file1 = "mci_vamp_10.1"
select type (mci)
type is (mci_vamp_t)
call mci%set_grid_filename (file1)
call mci%write_grids (mci_instance)
end select
call mci_instance%final ()
call mci%final ()
deallocate (mci)
write (u, "(A)") "* Read grids from file"
write (u, "(A)")
allocate (mci_vamp_t :: mci)
call mci%set_dimensions (2, 2)
select type (mci)
type is (mci_vamp_t)
call mci%set_grid_parameters (grid_par)
end select
allocate (rng_tao_t :: rng)
call rng%init ()
call mci%import_rng (rng)
mci%md5sum = "1234567890abcdef1234567890abcdef"
call mci%allocate_instance (mci_instance)
call mci_instance%init (mci)
select type (mci)
type is (mci_vamp_t)
call mci%set_grid_filename (file1)
call mci%add_pass ()
call mci%current_pass%configure (1, 1000, &
mci%min_calls, &
mci%grid_par%min_bins, mci%grid_par%max_bins, &
mci%grid_par%min_calls_per_channel * mci%n_channel)
call mci%read_grids_header (success)
call mci%compute_md5sum ()
call mci%read_grids_data (mci_instance, read_integrals = .true.)
end select
write (u, "(1x,A,L1)") "success = ", success
write (u, "(A)")
write (u, "(A)") "* Write grids again"
write (u, "(A)")
file2 = "mci_vamp_10.2"
select type (mci)
type is (mci_vamp_t)
call mci%set_grid_filename (file2)
call mci%write_grids (mci_instance)
end select
u1 = free_unit ()
open (u1, file = char (file1) // ".vg", action = "read", status = "old")
u2 = free_unit ()
open (u2, file = char (file2) // ".vg", action = "read", status = "old")
equal = .true.
iostat1 = 0
iostat2 = 0
do while (equal .and. iostat1 == 0 .and. iostat2 == 0)
read (u1, "(A)", iostat = iostat1) buffer1
read (u2, "(A)", iostat = iostat2) buffer2
equal = buffer1 == buffer2 .and. iostat1 == iostat2
end do
close (u1)
close (u2)
if (equal) then
write (u, "(1x,A)") "Success: grid files are identical"
else
write (u, "(1x,A)") "Failure: grid files differ"
end if
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call mci_instance%final ()
call mci%final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: mci_vamp_10"
end subroutine mci_vamp_10
@ %def mci_vamp_10
@
\subsubsection{Weighted events with grid I/O}
Construct an integrator and use it for a two-dimensional sampler with two
channels. Integrate, write grids, and generate a weighted event using
the grids from file.
<<MCI vamp: execute tests>>=
call test (mci_vamp_11, "mci_vamp_11", &
"weighted events with grid I/O", &
u, results)
<<MCI vamp: test declarations>>=
public :: mci_vamp_11
<<MCI vamp: tests>>=
subroutine mci_vamp_11 (u)
integer, intent(in) :: u
type(grid_parameters_t) :: grid_par
class(mci_t), allocatable, target :: mci
class(mci_instance_t), pointer :: mci_instance => null ()
class(mci_sampler_t), allocatable :: sampler
class(rng_t), allocatable :: rng
write (u, "(A)") "* Test output: mci_vamp_11"
write (u, "(A)") "* Purpose: integrate function in two dimensions &
&(two channels)"
write (u, "(A)") "* and generate a weighted event"
write (u, "(A)")
write (u, "(A)") "* Initialize integrator, sampler, instance"
write (u, "(A)")
allocate (mci_vamp_t :: mci)
call mci%set_dimensions (2, 2)
select type (mci)
type is (mci_vamp_t)
grid_par%stratified = .false.
grid_par%use_vamp_equivalences = .false.
call mci%set_grid_parameters (grid_par)
call mci%set_grid_filename (var_str ("mci_vamp_11"))
end select
allocate (rng_tao_t :: rng)
call rng%init ()
call mci%import_rng (rng)
call mci%allocate_instance (mci_instance)
call mci_instance%init (mci)
allocate (test_sampler_2_t :: sampler)
write (u, "(A)") "* Integrate with n_it = 3 and n_calls = 1000"
write (u, "(A)")
call mci%add_pass ()
call mci%integrate (mci_instance, sampler, 1, 1000)
write (u, "(A)") "* Reset instance"
write (u, "(A)")
call mci_instance%final ()
call mci%allocate_instance (mci_instance)
call mci_instance%init (mci)
write (u, "(A)") "* Generate a weighted event"
write (u, "(A)")
call mci_instance%init_simulation ()
call mci%generate_weighted_event (mci_instance, sampler)
write (u, "(A)") "* Cleanup"
call mci_instance%final_simulation ()
call mci_instance%final ()
call mci%final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: mci_vamp_11"
end subroutine mci_vamp_11
@ %def mci_vamp_11
@
\subsubsection{Unweighted events with grid I/O}
Construct an integrator and use it for a two-dimensional sampler with two
channels.
<<MCI vamp: execute tests>>=
call test (mci_vamp_12, "mci_vamp_12", &
"unweighted events with grid I/O", &
u, results)
<<MCI vamp: test declarations>>=
public :: mci_vamp_12
<<MCI vamp: tests>>=
subroutine mci_vamp_12 (u)
integer, intent(in) :: u
type(grid_parameters_t) :: grid_par
class(mci_t), allocatable, target :: mci
class(mci_instance_t), pointer :: mci_instance => null ()
class(mci_sampler_t), allocatable :: sampler
class(rng_t), allocatable :: rng
write (u, "(A)") "* Test output: mci_vamp_12"
write (u, "(A)") "* Purpose: integrate function in two dimensions &
&(two channels)"
write (u, "(A)") "* and generate an unweighted event"
write (u, "(A)")
write (u, "(A)") "* Initialize integrator, sampler, instance"
write (u, "(A)")
allocate (mci_vamp_t :: mci)
call mci%set_dimensions (2, 2)
select type (mci)
type is (mci_vamp_t)
grid_par%stratified = .false.
grid_par%use_vamp_equivalences = .false.
call mci%set_grid_parameters (grid_par)
call mci%set_grid_filename (var_str ("mci_vamp_12"))
end select
allocate (rng_tao_t :: rng)
call rng%init ()
call mci%import_rng (rng)
call mci%allocate_instance (mci_instance)
call mci_instance%init (mci)
allocate (test_sampler_2_t :: sampler)
write (u, "(A)") "* Integrate with n_it = 3 and n_calls = 1000"
write (u, "(A)")
call mci%add_pass ()
call mci%integrate (mci_instance, sampler, 1, 1000)
write (u, "(A)") "* Reset instance"
write (u, "(A)")
call mci_instance%final ()
call mci%allocate_instance (mci_instance)
call mci_instance%init (mci)
write (u, "(A)") "* Generate an unweighted event"
write (u, "(A)")
call mci_instance%init_simulation ()
call mci%generate_unweighted_event (mci_instance, sampler)
write (u, "(1x,A)") "MCI instance:"
call mci_instance%write (u)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call mci_instance%final_simulation ()
call mci_instance%final ()
call mci%final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: mci_vamp_12"
end subroutine mci_vamp_12
@ %def mci_vamp_12
@
\subsubsection{Update integration results}
Compare two [[mci]] objects; match the two and update the first if
successful.
<<MCI vamp: execute tests>>=
call test (mci_vamp_13, "mci_vamp_13", &
"updating integration results", &
u, results)
<<MCI vamp: test declarations>>=
public :: mci_vamp_13
<<MCI vamp: tests>>=
subroutine mci_vamp_13 (u)
integer, intent(in) :: u
type(grid_parameters_t) :: grid_par
class(mci_t), allocatable, target :: mci, mci_ref
logical :: success
write (u, "(A)") "* Test output: mci_vamp_13"
write (u, "(A)") "* Purpose: match and update integrators"
write (u, "(A)")
write (u, "(A)") "* Initialize integrator with no passes"
write (u, "(A)")
allocate (mci_vamp_t :: mci)
call mci%set_dimensions (2, 2)
select type (mci)
type is (mci_vamp_t)
grid_par%stratified = .false.
grid_par%use_vamp_equivalences = .false.
call mci%set_grid_parameters (grid_par)
end select
call mci%write (u)
write (u, "(A)")
write (u, "(A)") "* Initialize reference"
write (u, "(A)")
allocate (mci_vamp_t :: mci_ref)
call mci_ref%set_dimensions (2, 2)
select type (mci_ref)
type is (mci_vamp_t)
call mci_ref%set_grid_parameters (grid_par)
end select
select type (mci_ref)
type is (mci_vamp_t)
call mci_ref%add_pass (adapt_grids = .true.)
call mci_ref%current_pass%configure (2, 1000, 0, 1, 5, 0)
mci_ref%current_pass%calls = [77, 77]
mci_ref%current_pass%integral = [1.23_default, 3.45_default]
mci_ref%current_pass%error = [0.23_default, 0.45_default]
mci_ref%current_pass%efficiency = [0.1_default, 0.6_default]
mci_ref%current_pass%integral_defined = .true.
call mci_ref%add_pass ()
call mci_ref%current_pass%configure (2, 2000, 0, 1, 7, 0)
mci_ref%current_pass%calls = [99, 0]
mci_ref%current_pass%integral = [7.89_default, 0._default]
mci_ref%current_pass%error = [0.89_default, 0._default]
mci_ref%current_pass%efficiency = [0.86_default, 0._default]
mci_ref%current_pass%integral_defined = .true.
end select
call mci_ref%write (u)
write (u, "(A)")
write (u, "(A)") "* Update integrator (no-op, should succeed)"
write (u, "(A)")
select type (mci)
type is (mci_vamp_t)
call mci%update_from_ref (mci_ref, success)
end select
write (u, "(1x,A,L1)") "success = ", success
write (u, "(A)")
call mci%write (u)
write (u, "(A)")
write (u, "(A)") "* Add pass to integrator"
write (u, "(A)")
select type (mci)
type is (mci_vamp_t)
call mci%add_pass (adapt_grids = .true.)
call mci%current_pass%configure (2, 1000, 0, 1, 5, 0)
mci%current_pass%calls = [77, 77]
mci%current_pass%integral = [1.23_default, 3.45_default]
mci%current_pass%error = [0.23_default, 0.45_default]
mci%current_pass%efficiency = [0.1_default, 0.6_default]
mci%current_pass%integral_defined = .true.
end select
write (u, "(A)") "* Update integrator (no-op, should succeed)"
write (u, "(A)")
select type (mci)
type is (mci_vamp_t)
call mci%update_from_ref (mci_ref, success)
end select
write (u, "(1x,A,L1)") "success = ", success
write (u, "(A)")
call mci%write (u)
write (u, "(A)")
write (u, "(A)") "* Add pass to integrator, wrong parameters"
write (u, "(A)")
select type (mci)
type is (mci_vamp_t)
call mci%add_pass ()
call mci%current_pass%configure (2, 1000, 0, 1, 7, 0)
end select
write (u, "(A)") "* Update integrator (should fail)"
write (u, "(A)")
select type (mci)
type is (mci_vamp_t)
call mci%update_from_ref (mci_ref, success)
end select
write (u, "(1x,A,L1)") "success = ", success
write (u, "(A)")
call mci%write (u)
write (u, "(A)")
write (u, "(A)") "* Reset and add passes to integrator"
write (u, "(A)")
select type (mci)
type is (mci_vamp_t)
call mci%reset ()
call mci%add_pass (adapt_grids = .true.)
call mci%current_pass%configure (2, 1000, 0, 1, 5, 0)
mci%current_pass%calls = [77, 77]
mci%current_pass%integral = [1.23_default, 3.45_default]
mci%current_pass%error = [0.23_default, 0.45_default]
mci%current_pass%efficiency = [0.1_default, 0.6_default]
mci%current_pass%integral_defined = .true.
call mci%add_pass ()
call mci%current_pass%configure (2, 2000, 0, 1, 7, 0)
end select
write (u, "(A)") "* Update integrator (should succeed)"
write (u, "(A)")
select type (mci)
type is (mci_vamp_t)
call mci%update_from_ref (mci_ref, success)
end select
write (u, "(1x,A,L1)") "success = ", success
write (u, "(A)")
call mci%write (u)
write (u, "(A)")
write (u, "(A)") "* Update again (no-op, should succeed)"
write (u, "(A)")
select type (mci)
type is (mci_vamp_t)
call mci%update_from_ref (mci_ref, success)
end select
write (u, "(1x,A,L1)") "success = ", success
write (u, "(A)")
call mci%write (u)
write (u, "(A)")
write (u, "(A)") "* Add extra result to integrator"
write (u, "(A)")
select type (mci)
type is (mci_vamp_t)
mci%current_pass%calls(2) = 1234
end select
write (u, "(A)") "* Update integrator (should fail)"
write (u, "(A)")
select type (mci)
type is (mci_vamp_t)
call mci%update_from_ref (mci_ref, success)
end select
write (u, "(1x,A,L1)") "success = ", success
write (u, "(A)")
call mci%write (u)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call mci%final ()
call mci_ref%final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: mci_vamp_13"
end subroutine mci_vamp_13
@ %def mci_vamp_13
@
\subsubsection{Accuracy Goal}
Integrate with multiple iterations. Skip iterations once an accuracy goal has
been reached.
<<MCI vamp: execute tests>>=
call test (mci_vamp_14, "mci_vamp_14", &
"accuracy goal", &
u, results)
<<MCI vamp: test declarations>>=
public :: mci_vamp_14
<<MCI vamp: tests>>=
subroutine mci_vamp_14 (u)
integer, intent(in) :: u
type(grid_parameters_t) :: grid_par
class(mci_t), allocatable, target :: mci
class(mci_instance_t), pointer :: mci_instance => null ()
class(mci_sampler_t), allocatable :: sampler
class(rng_t), allocatable :: rng
write (u, "(A)") "* Test output: mci_vamp_14"
write (u, "(A)") "* Purpose: integrate function in one dimension &
&(single channel)"
write (u, "(A)") "* and check accuracy goal"
write (u, "(A)")
write (u, "(A)") "* Initialize integrator, sampler, instance"
write (u, "(A)")
allocate (mci_vamp_t :: mci)
call mci%set_dimensions (1, 1)
select type (mci)
type is (mci_vamp_t)
grid_par%use_vamp_equivalences = .false.
grid_par%accuracy_goal = 5E-2_default
call mci%set_grid_parameters (grid_par)
end select
allocate (rng_tao_t :: rng)
call rng%init ()
call mci%import_rng (rng)
call mci%allocate_instance (mci_instance)
call mci_instance%init (mci)
allocate (test_sampler_1_t :: sampler)
select type (sampler)
type is (test_sampler_1_t)
sampler%mode = 2
end select
call sampler%write (u)
write (u, "(A)")
write (u, "(A)") "* Integrate with n_it = 5 and n_calls = 100"
write (u, "(A)")
select type (mci)
type is (mci_vamp_t)
call mci%add_pass (adapt_grids = .true.)
end select
call mci%integrate (mci_instance, sampler, 5, 100)
call mci%write (u)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call mci_instance%final ()
call mci%final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: mci_vamp_14"
end subroutine mci_vamp_14
@ %def mci_vamp_14
@
\subsubsection{VAMP history}
Integrate with three passes and different settings for weight and grid
adaptation. Then show the VAMP history.
<<MCI vamp: execute tests>>=
call test (mci_vamp_15, "mci_vamp_15", &
"VAMP history", &
u, results)
<<MCI vamp: test declarations>>=
public :: mci_vamp_15
<<MCI vamp: tests>>=
subroutine mci_vamp_15 (u)
integer, intent(in) :: u
type(grid_parameters_t) :: grid_par
type(history_parameters_t) :: history_par
class(mci_t), allocatable, target :: mci
class(mci_instance_t), pointer :: mci_instance => null ()
class(mci_sampler_t), allocatable :: sampler
class(rng_t), allocatable :: rng
write (u, "(A)") "* Test output: mci_vamp_15"
write (u, "(A)") "* Purpose: integrate function in one dimension &
&(two channels)"
write (u, "(A)") "* in three passes, show history"
write (u, "(A)")
write (u, "(A)") "* Initialize integrator, sampler, instance"
write (u, "(A)")
history_par%channel = .true.
allocate (mci_vamp_t :: mci)
call mci%set_dimensions (1, 2)
select type (mci)
type is (mci_vamp_t)
grid_par%stratified = .false.
grid_par%use_vamp_equivalences = .false.
call mci%set_grid_parameters (grid_par)
call mci%set_history_parameters (history_par)
end select
allocate (rng_tao_t :: rng)
call rng%init ()
call mci%import_rng (rng)
call mci%allocate_instance (mci_instance)
call mci_instance%init (mci)
allocate (test_sampler_3_t :: sampler)
select type (sampler)
type is (test_sampler_3_t)
sampler%a = 0.9_default
sampler%b = 0.1_default
end select
call sampler%write (u)
write (u, "(A)")
write (u, "(A)") "* Pass 1: grid and weight adaptation"
select type (mci)
type is (mci_vamp_t)
call mci%add_pass (adapt_grids = .true., adapt_weights = .true.)
end select
call mci%integrate (mci_instance, sampler, 3, 1000)
write (u, "(A)")
write (u, "(A)") "* Pass 2: grid adaptation"
select type (mci)
type is (mci_vamp_t)
call mci%add_pass (adapt_grids = .true.)
end select
call mci%integrate (mci_instance, sampler, 3, 1000)
write (u, "(A)")
write (u, "(A)") "* Pass 3: without adaptation"
select type (mci)
type is (mci_vamp_t)
call mci%add_pass ()
end select
call mci%integrate (mci_instance, sampler, 3, 1000)
write (u, "(A)")
write (u, "(A)") "* Contents of MCI record, with history"
write (u, "(A)")
call mci%write (u)
select type (mci)
type is (mci_vamp_t)
call mci%write_history (u)
end select
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call mci_instance%final ()
call mci%final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: mci_vamp_15"
end subroutine mci_vamp_15
@ %def mci_vamp_15
@
\subsubsection{One-dimensional integration with sign change}
Construct an integrator and use it for a one-dimensional sampler.
<<MCI vamp: execute tests>>=
call test (mci_vamp_16, "mci_vamp_16", &
"1-D integral with sign change", &
u, results)
<<MCI vamp: test declarations>>=
public :: mci_vamp_16
<<MCI vamp: tests>>=
subroutine mci_vamp_16 (u)
integer, intent(in) :: u
type(grid_parameters_t) :: grid_par
class(mci_t), allocatable, target :: mci
class(mci_instance_t), pointer :: mci_instance => null ()
class(mci_sampler_t), allocatable :: sampler
class(rng_t), allocatable :: rng
write (u, "(A)") "* Test output: mci_vamp_16"
write (u, "(A)") "* Purpose: integrate function in one dimension &
&(single channel)"
write (u, "(A)")
write (u, "(A)") "* Initialize integrator"
write (u, "(A)")
allocate (mci_vamp_t :: mci)
call mci%set_dimensions (1, 1)
select type (mci)
type is (mci_vamp_t)
grid_par%use_vamp_equivalences = .false.
call mci%set_grid_parameters (grid_par)
mci%negative_weights = .true.
end select
allocate (rng_tao_t :: rng)
call rng%init ()
call mci%import_rng (rng)
call mci%write (u)
write (u, "(A)")
write (u, "(A)") "* Initialize instance"
write (u, "(A)")
call mci%allocate_instance (mci_instance)
call mci_instance%init (mci)
write (u, "(A)") "* Initialize test sampler"
write (u, "(A)")
allocate (test_sampler_1_t :: sampler)
select type (sampler)
type is (test_sampler_1_t)
sampler%mode = 4
end select
call sampler%write (u)
write (u, "(A)")
write (u, "(A)") "* Integrate with n_calls = 1000"
write (u, "(A)") " (lower precision to avoid"
write (u, "(A)") " numerical noise)"
write (u, "(A)")
select type (mci)
type is (mci_vamp_t)
call mci%add_pass ()
end select
call mci%integrate (mci_instance, sampler, 1, 1000, pacify = .true.)
call mci%write (u, .true.)
write (u, "(A)")
write (u, "(A)") "* Contents of mci_instance:"
write (u, "(A)")
call mci_instance%write (u, .true.)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call mci_instance%final ()
call mci%final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: mci_vamp_16"
end subroutine mci_vamp_16
@ %def mci_vamp_16
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{Multi-channel integration with VAMP2}
\label{sec:vegas-integration}
The multi-channel integration uses VEGAS as backbone integrator.
The base interface for the multi-channel integration is given by [[mci_base]] module.
We interface the VAMP2 interface given by [[vamp2]] module.
<<[[mci_vamp2.f90]]>>=
<<File header>>
module mci_vamp2
<<Use kinds>>
<<Use strings>>
use io_units
use format_utils, only: pac_fmt
use format_utils, only: write_separator, write_indent
use format_defs, only: FMT_12, FMT_14, FMT_17, FMT_19
use constants, only: tiny_13
use diagnostics
use md5
use phs_base
use rng_base
use os_interface, only: mpi_get_comm_id
use rng_stream, only: rng_stream_t
use mci_base
use vegas, only: VEGAS_MODE_IMPORTANCE, VEGAS_MODE_IMPORTANCE_ONLY
use vamp2
<<MCI vamp2: modules>>
<<Standard module head>>
<<MCI vamp2: public>>
<<MCI vamp2: types>>
<<MCI vamp2: interfaces>>
contains
<<MCI vamp2: procedures>>
end module mci_vamp2
@ %def mci_vamp2
<<MCI vamp2: modules>>=
@
<<MPI: MCI vamp2: modules>>=
use mpi_f08 !NODEP!
@ %def mpi_f08
@
\subsection{Type: mci\_vamp2\_func\_t}
\label{sec:mci-vamp2-func}
<<MCI vamp2: types>>=
type, extends (vamp2_func_t) :: mci_vamp2_func_t
private
real(default) :: integrand = 0.
class(mci_sampler_t), pointer :: sampler => null ()
class(mci_vamp2_instance_t), pointer :: instance => null ()
contains
<<MCI vamp2: mci vamp2 func: TBP>>
end type mci_vamp2_func_t
@ %def mci_vamp2_func_t
@ Set instance and sampler aka workspace. Also, reset number of [[n_calls]].
<<MCI vamp2: mci vamp2 func: TBP>>=
procedure, public :: set_workspace => mci_vamp2_func_set_workspace
<<MCI vamp2: procedures>>=
subroutine mci_vamp2_func_set_workspace (self, instance, sampler)
class(mci_vamp2_func_t), intent(inout) :: self
class(mci_vamp2_instance_t), intent(inout), target :: instance
class(mci_sampler_t), intent(inout), target :: sampler
self%instance => instance
self%sampler => sampler
end subroutine mci_vamp2_func_set_workspace
@ %def mci_vamp2_func_set_workspace
@ Get the different channel probabilities.
<<MCI vamp2: mci vamp2 func: TBP>>=
procedure, public :: get_probabilities => mci_vamp2_func_get_probabilities
<<MCI vamp2: procedures>>=
function mci_vamp2_func_get_probabilities (self) result (gi)
class(mci_vamp2_func_t), intent(inout) :: self
real(default), dimension(self%n_channel) :: gi
gi = self%gi
end function mci_vamp2_func_get_probabilities
@ %def mci_vamp2_func_get_probabilities
@ Get multi-channel weight.
<<MCI vamp2: mci vamp2 func: TBP>>=
procedure, public :: get_weight => mci_vamp2_func_get_weight
<<MCI vamp2: procedures>>=
real(default) function mci_vamp2_func_get_weight (self) result (g)
class(mci_vamp2_func_t), intent(in) :: self
g = self%g
end function mci_vamp2_func_get_weight
@ %def mci_vamp2_func_get_weight
@ Set integrand.
<<MCI vamp2: mci vamp2 func: TBP>>=
procedure, public :: set_integrand => mci_vamp2_func_set_integrand
<<MCI vamp2: procedures>>=
subroutine mci_vamp2_func_set_integrand (self, integrand)
class(mci_vamp2_func_t), intent(inout) :: self
real(default), intent(in) :: integrand
self%integrand = integrand
end subroutine mci_vamp2_func_set_integrand
@ %def mci_vamp2_func_set_integrand
@ Evaluate the mappings.
<<MCI vamp2: mci vamp2 func: TBP>>=
procedure, public :: evaluate_maps => mci_vamp2_func_evaluate_maps
<<MCI vamp2: procedures>>=
subroutine mci_vamp2_func_evaluate_maps (self, x)
class(mci_vamp2_func_t), intent(inout) :: self
real(default), dimension(:), intent(in) :: x
select type (self)
type is (mci_vamp2_func_t)
call self%instance%evaluate (self%sampler, self%current_channel, x)
end select
self%valid_x = self%instance%valid
self%xi = self%instance%x
self%det = self%instance%f
end subroutine mci_vamp2_func_evaluate_maps
@ %def mci_vamp2_func_evaluate_maps
@ Evaluate the function, more or less.
<<MCI vamp2: mci vamp2 func: TBP>>=
procedure, public :: evaluate_func => mci_vamp2_func_evaluate_func
<<MCI vamp2: procedures>>=
real(default) function mci_vamp2_func_evaluate_func (self, x) result (f)
class(mci_vamp2_func_t), intent(in) :: self
real(default), dimension(:), intent(in) :: x
f = self%integrand
if (signal_is_pending ()) then
call msg_message ("MCI VAMP2: function evaluate_func: signal received")
call terminate_now_if_signal ()
end if
call terminate_now_if_single_event ()
end function mci_vamp2_func_evaluate_func
@ %def mci_vamp2_func_evaluate_func
@
\subsection{Type: mci\_vamp2\_config\_t}
We extend [[vamp2_config_t]].
<<MCI vamp2: public>>=
public :: mci_vamp2_config_t
<<MCI vamp2: types>>=
type, extends (vamp2_config_t) :: mci_vamp2_config_t
!
end type mci_vamp2_config_t
@ %def mci_vamp2_config_t
@
\subsection{Integration pass}
The list of passes is organized in a separate container. We store the parameters
and results for each integration pass in [[pass_t]] and the linked list is
stored in [[list_pass_t]].
<<MCI vamp2: types>>=
type :: list_pass_t
type(pass_t), pointer :: first => null ()
type(pass_t), pointer :: current => null ()
contains
<<MCI vamp2: list pass: TBP>>
end type list_pass_t
@ %def list_pass_t
@ Finalizer. Deallocate each element of the list beginning by the first.
<<MCI vamp2: list pass: TBP>>=
procedure :: final => list_pass_final
<<MCI vamp2: procedures>>=
subroutine list_pass_final (self)
class(list_pass_t), intent(inout) :: self
type(pass_t), pointer :: current
current => self%first
do while (associated (current))
self%first => current%next
deallocate (current)
current => self%first
end do
end subroutine list_pass_final
@ %def pass_final
@ Add a new pass.
<<MCI vamp2: list pass: TBP>>=
procedure :: add => list_pass_add
<<MCI vamp2: procedures>>=
subroutine list_pass_add (self, adapt_grids, adapt_weights, final_pass)
class(list_pass_t), intent(inout) :: self
logical, intent(in), optional :: adapt_grids, adapt_weights, final_pass
type(pass_t), pointer :: new_pass
allocate (new_pass)
new_pass%i_pass = 1
new_pass%i_first_it = 1
new_pass%adapt_grids = .false.; if (present (adapt_grids)) &
& new_pass%adapt_grids = adapt_grids
new_pass%adapt_weights = .false.; if (present (adapt_weights)) &
& new_pass%adapt_weights = adapt_weights
new_pass%is_final_pass = .false.; if (present (final_pass)) &
& new_pass%is_final_pass = final_pass
if (.not. associated (self%first)) then
self%first => new_pass
else
new_pass%i_pass = new_pass%i_pass + self%current%i_pass
new_pass%i_first_it = self%current%i_first_it + self%current%n_it
self%current%next => new_pass
end if
self%current => new_pass
end subroutine list_pass_add
@ %def list_pass_add
@ Update list from a reference. All passes except for the last one must match
exactly. For the last one, integration results are updated. The reference output
may contain extra passes, these are ignored.
<<MCI vamp2: list pass: TBP>>=
procedure :: update_from_ref => list_pass_update_from_ref
<<MCI vamp2: procedures>>=
subroutine list_pass_update_from_ref (self, ref, success)
class(list_pass_t), intent(inout) :: self
type(list_pass_t), intent(in) :: ref
logical, intent(out) :: success
type(pass_t), pointer :: current, ref_current
current => self%first
ref_current => ref%first
success = .true.
do while (success .and. associated (current))
if (associated (ref_current)) then
if (associated (current%next)) then
success = current .matches. ref_current
else
call current%update (ref_current, success)
end if
current => current%next
ref_current => ref_current%next
else
success = .false.
end if
end do
end subroutine list_pass_update_from_ref
@ %def list_pass_update_from_ref
@ Output. Write the complete linked list to the specified unit.
<<MCI vamp2: list pass: TBP>>=
procedure :: write => list_pass_write
<<MCI vamp2: procedures>>=
subroutine list_pass_write (self, unit, pacify)
class(list_pass_t), intent(in) :: self
integer, intent(in) :: unit
logical, intent(in), optional :: pacify
type(pass_t), pointer :: current
current => self%first
do while (associated (current))
write (unit, "(1X,A)") "Integration pass:"
call current%write (unit, pacify)
current => current%next
end do
end subroutine list_pass_write
@ %def list_pass_write
@ The parameters and results are stored in the nodes [[pass_t]] of the linked
list.
<<MCI vamp2: types>>=
type :: pass_t
integer :: i_pass = 0
integer :: i_first_it = 0
integer :: n_it = 0
integer :: n_calls = 0
logical :: adapt_grids = .false.
logical :: adapt_weights = .false.
logical :: is_final_pass = .false.
logical :: integral_defined = .false.
integer, dimension(:), allocatable :: calls
integer, dimension(:), allocatable :: calls_valid
real(default), dimension(:), allocatable :: integral
real(default), dimension(:), allocatable :: error
real(default), dimension(:), allocatable :: efficiency
type(pass_t), pointer :: next => null ()
contains
<<MCI vamp2: pass: TBP>>
end type pass_t
@ %def pass_t
@ Output. Note that the precision of the numerical values should match the
precision for comparing output from file with data.
<<MCI vamp2: pass: TBP>>=
procedure :: write => pass_write
<<MCI vamp2: procedures>>=
subroutine pass_write (self, unit, pacify)
class(pass_t), intent(in) :: self
integer, intent(in) :: unit
logical, intent(in), optional :: pacify
integer :: u, i
real(default) :: pac_error
character(len=7) :: fmt
call pac_fmt (fmt, FMT_17, FMT_14, pacify)
u = given_output_unit (unit)
write (u, "(3X,A,I0)") "n_it = ", self%n_it
write (u, "(3X,A,I0)") "n_calls = ", self%n_calls
write (u, "(3X,A,L1)") "adapt grids = ", self%adapt_grids
write (u, "(3X,A,L1)") "adapt weights = ", self%adapt_weights
if (self%integral_defined) then
write (u, "(3X,A)") "Results: [it, calls, valid, integral, error, efficiency]"
do i = 1, self%n_it
if (abs (self%error(i)) > tiny_13) then
pac_error = self%error(i)
else
pac_error = 0
end if
write (u, "(5x,I0,2(1x,I0),3(1x," // fmt // "))") &
i, self%calls(i), self%calls_valid(i), self%integral(i), &
pac_error, self%efficiency(i)
end do
else
write (u, "(3x,A)") "Results: [undefined]"
end if
end subroutine pass_write
@ %def pass_write
@ Read and reconstruct the pass.
<<MCI vamp2: pass: TBP>>=
procedure :: read => pass_read
<<MCI vamp2: procedures>>=
subroutine pass_read (self, u, n_pass, n_it)
class(pass_t), intent(out) :: self
integer, intent(in) :: u, n_pass, n_it
integer :: i, j
character(80) :: buffer
self%i_pass = n_pass + 1
self%i_first_it = n_it + 1
call read_ival (u, self%n_it)
call read_ival (u, self%n_calls)
call read_lval (u, self%adapt_grids)
call read_lval (u, self%adapt_weights)
allocate (self%calls (self%n_it), source = 0)
allocate (self%calls_valid (self%n_it), source = 0)
allocate (self%integral (self%n_it), source = 0._default)
allocate (self%error (self%n_it), source = 0._default)
allocate (self%efficiency (self%n_it), source = 0._default)
read (u, "(A)") buffer
select case (trim (adjustl (buffer)))
case ("Results: [it, calls, valid, integral, error, efficiency]")
do i = 1, self%n_it
read (u, *) &
j, self%calls(i), self%calls_valid(i), self%integral(i), self%error(i), &
self%efficiency(i)
end do
self%integral_defined = .true.
case ("Results: [undefined]")
self%integral_defined = .false.
case default
call msg_fatal ("Reading integration pass: corrupted file")
end select
end subroutine pass_read
@ %def pass_read
@ Auxiliary: Read real, integer, string value. We search for an equals sign,
the value must follow.
<<MCI vamp2: procedures>>=
subroutine read_rval (u, rval)
integer, intent(in) :: u
real(default), intent(out) :: rval
character(80) :: buffer
read (u, "(A)") buffer
buffer = adjustl (buffer(scan (buffer, "=") + 1:))
read (buffer, *) rval
end subroutine read_rval
subroutine read_ival (u, ival)
integer, intent(in) :: u
integer, intent(out) :: ival
character(80) :: buffer
read (u, "(A)") buffer
buffer = adjustl (buffer(scan (buffer, "=") + 1:))
read (buffer, *) ival
end subroutine read_ival
subroutine read_sval (u, sval)
integer, intent(in) :: u
character(*), intent(out) :: sval
character(80) :: buffer
read (u, "(A)") buffer
buffer = adjustl (buffer(scan (buffer, "=") + 1:))
read (buffer, *) sval
end subroutine read_sval
subroutine read_lval (u, lval)
integer, intent(in) :: u
logical, intent(out) :: lval
character(80) :: buffer
read (u, "(A)") buffer
buffer = adjustl (buffer(scan (buffer, "=") + 1:))
read (buffer, *) lval
end subroutine read_lval
@ %def read_rval read_ival read_sval read_lval
@ Configure. We adjust the number of [[n_calls]], if it is lower than
[[n_calls_min_per_channel]] times [[b_channel]], and print a warning message.
<<MCI vamp2: pass: TBP>>=
procedure :: configure => pass_configure
<<MCI vamp2: procedures>>=
subroutine pass_configure (pass, n_it, n_calls, n_calls_min)
class(pass_t), intent(inout) :: pass
integer, intent(in) :: n_it
integer, intent(in) :: n_calls
integer, intent(in) :: n_calls_min
pass%n_it = n_it
pass%n_calls = max (n_calls, n_calls_min)
if (pass%n_calls /= n_calls) then
write (msg_buffer, "(A,I0)") "VAMP2: too few calls, resetting " &
// "n_calls to ", pass%n_calls
call msg_warning ()
end if
allocate (pass%calls (n_it), source = 0)
allocate (pass%calls_valid (n_it), source = 0)
allocate (pass%integral (n_it), source = 0._default)
allocate (pass%error (n_it), source = 0._default)
allocate (pass%efficiency (n_it), source = 0._default)
end subroutine pass_configure
@ %def pass_configure
@ Given two pass objects, compare them. All parameters must match. Where
integrations are done in both (number of calls nonzero), the results must be
equal (up to numerical noise).
The allocated array sizes might be different, but should match up to the
common [[n_it]] value.
<<MCI vamp2: interfaces>>=
interface operator (.matches.)
module procedure pass_matches
end interface operator (.matches.)
<<MCI vamp2: procedures>>=
function pass_matches (pass, ref) result (ok)
type(pass_t), intent(in) :: pass, ref
integer :: n
logical :: ok
ok = .true.
if (ok) ok = pass%i_pass == ref%i_pass
if (ok) ok = pass%i_first_it == ref%i_first_it
if (ok) ok = pass%n_it == ref%n_it
if (ok) ok = pass%n_calls == ref%n_calls
if (ok) ok = pass%adapt_grids .eqv. ref%adapt_grids
if (ok) ok = pass%adapt_weights .eqv. ref%adapt_weights
if (ok) ok = pass%integral_defined .eqv. ref%integral_defined
if (pass%integral_defined) then
n = pass%n_it
if (ok) ok = all (pass%calls(:n) == ref%calls(:n))
if (ok) ok = all (pass%calls_valid(:n) == ref%calls_valid(:n))
if (ok) ok = all (pass%integral(:n) .matches. ref%integral(:n))
if (ok) ok = all (pass%error(:n) .matches. ref%error(:n))
if (ok) ok = all (pass%efficiency(:n) .matches. ref%efficiency(:n))
end if
end function pass_matches
@ %def pass_matches
@ Update a pass object, given a reference. The parameters must match, except
for the [[n_it]] entry. The number of complete iterations must be less or
equal to the reference, and the number of complete iterations in the reference
must be no larger than [[n_it]]. Where results are present in both passes,
they must match. Where results are present in the reference only, the pass is
updated accordingly.
<<MCI vamp2: pass: TBP>>=
procedure :: update => pass_update
<<MCI vamp2: procedures>>=
subroutine pass_update (pass, ref, ok)
class(pass_t), intent(inout) :: pass
type(pass_t), intent(in) :: ref
logical, intent(out) :: ok
integer :: n, n_ref
ok = .true.
if (ok) ok = pass%i_pass == ref%i_pass
if (ok) ok = pass%i_first_it == ref%i_first_it
if (ok) ok = pass%n_calls == ref%n_calls
if (ok) ok = pass%adapt_grids .eqv. ref%adapt_grids
if (ok) ok = pass%adapt_weights .eqv. ref%adapt_weights
if (ok) then
if (ref%integral_defined) then
if (.not. allocated (pass%calls)) then
allocate (pass%calls (pass%n_it), source = 0)
allocate (pass%calls_valid (pass%n_it), source = 0)
allocate (pass%integral (pass%n_it), source = 0._default)
allocate (pass%error (pass%n_it), source = 0._default)
allocate (pass%efficiency (pass%n_it), source = 0._default)
end if
n = count (pass%calls /= 0)
n_ref = count (ref%calls /= 0)
ok = n <= n_ref .and. n_ref <= pass%n_it
if (ok) ok = all (pass%calls(:n) == ref%calls(:n))
if (ok) ok = all (pass%calls_valid(:n) == ref%calls_valid(:n))
if (ok) ok = all (pass%integral(:n) .matches. ref%integral(:n))
if (ok) ok = all (pass%error(:n) .matches. ref%error(:n))
if (ok) ok = all (pass%efficiency(:n) .matches. ref%efficiency(:n))
if (ok) then
pass%calls(n+1:n_ref) = ref%calls(n+1:n_ref)
pass%calls_valid(n+1:n_ref) = ref%calls_valid(n+1:n_ref)
pass%integral(n+1:n_ref) = ref%integral(n+1:n_ref)
pass%error(n+1:n_ref) = ref%error(n+1:n_ref)
pass%efficiency(n+1:n_ref) = ref%efficiency(n+1:n_ref)
pass%integral_defined = any (pass%calls /= 0)
end if
end if
end if
end subroutine pass_update
@ %def pass_update
@ Match two real numbers: they are equal up to a tolerance, which is
$10^{-8}$, matching the number of digits that are output by [[pass_write]].
In particular, if one number is exactly zero, the other one must also be zero.
<<MCI vamp2: interfaces>>=
interface operator (.matches.)
module procedure real_matches
end interface operator (.matches.)
<<MCI vamp2: procedures>>=
elemental function real_matches (x, y) result (ok)
real(default), intent(in) :: x, y
logical :: ok
real(default), parameter :: tolerance = 1.e-8_default
ok = abs (x - y) <= tolerance * max (abs (x), abs (y))
end function real_matches
@ %def real_matches
@ Return the index of the most recent complete integration. If there is none,
return zero.
<<MCI vamp2: pass: TBP>>=
procedure :: get_integration_index => pass_get_integration_index
<<MCI vamp2: procedures>>=
function pass_get_integration_index (pass) result (n)
class (pass_t), intent(in) :: pass
integer :: n
integer :: i
n = 0
if (allocated (pass%calls)) then
do i = 1, pass%n_it
if (pass%calls(i) == 0) exit
n = i
end do
end if
end function pass_get_integration_index
@ %def pass_get_integration_index
@ Return the most recent integral and error, if available.
<<MCI vamp2: pass: TBP>>=
procedure :: get_calls => pass_get_calls
procedure :: get_calls_valid => pass_get_calls_valid
procedure :: get_integral => pass_get_integral
procedure :: get_error => pass_get_error
procedure :: get_efficiency => pass_get_efficiency
<<MCI vamp2: procedures>>=
function pass_get_calls (pass) result (calls)
class(pass_t), intent(in) :: pass
integer :: calls
integer :: n
n = pass%get_integration_index ()
calls = 0
if (n /= 0) then
calls = pass%calls(n)
end if
end function pass_get_calls
function pass_get_calls_valid (pass) result (valid)
class(pass_t), intent(in) :: pass
integer :: valid
integer :: n
n = pass%get_integration_index ()
valid = 0
if (n /= 0) then
valid = pass%calls_valid(n)
end if
end function pass_get_calls_valid
function pass_get_integral (pass) result (integral)
class(pass_t), intent(in) :: pass
real(default) :: integral
integer :: n
n = pass%get_integration_index ()
integral = 0
if (n /= 0) then
integral = pass%integral(n)
end if
end function pass_get_integral
function pass_get_error (pass) result (error)
class(pass_t), intent(in) :: pass
real(default) :: error
integer :: n
n = pass%get_integration_index ()
error = 0
if (n /= 0) then
error = pass%error(n)
end if
end function pass_get_error
function pass_get_efficiency (pass) result (efficiency)
class(pass_t), intent(in) :: pass
real(default) :: efficiency
integer :: n
n = pass%get_integration_index ()
efficiency = 0
if (n /= 0) then
efficiency = pass%efficiency(n)
end if
end function pass_get_efficiency
@ %def pass_get_calls
@ %def pass_get_calls_valid
@ %def pass_get_integral
@ %def pass_get_error
@ %def pass_get_efficiency
@
\subsection{Integrator}
\label{sec:integrator}
We store the different passes of integration, adaptation and actual sampling, in
a linked list.
We store the total number of calls [[n_calls]] and the minimal number of calls
[[n_calls_min]]. The latter is calculated based on [[n_channel]] and
[[min_calls_per_channel]]. If [[n_calls]] is smaller than [[n_calls_min]], then
we replace [[n_calls]] with [[n_min_calls]].
<<MCI vamp2: public>>=
public :: mci_vamp2_t
<<MCI vamp2: types>>=
type, extends(mci_t) :: mci_vamp2_t
type(mci_vamp2_config_t) :: config
type(vamp2_t) :: integrator
type(vamp2_equivalences_t) :: equivalences
logical :: integrator_defined = .false.
logical :: integrator_from_file = .false.
logical :: adapt_grids = .false.
logical :: adapt_weights = .false.
integer :: n_adapt_grids = 0
integer :: n_adapt_weights = 0
integer :: n_calls = 0
type(list_pass_t) :: list_pass
logical :: rebuild = .true.
logical :: check_grid_file = .true.
logical :: grid_filename_set = .false.
logical :: negative_weights = .false.
logical :: verbose = .false.
logical :: pass_complete = .false.
logical :: it_complete = .false.
type(string_t) :: grid_filename
logical :: binary_grid_format = .false.
character(32) :: md5sum_adapted = ""
contains
<<MCI vamp2: mci vamp2: TBP>>
end type mci_vamp2_t
@ %def mci_vamp2_t
@ Finalizer: call to base and list finalizer.
<<MCI vamp2: mci vamp2: TBP>>=
procedure, public :: final => mci_vamp2_final
<<MCI vamp2: procedures>>=
subroutine mci_vamp2_final (object)
class(mci_vamp2_t), intent(inout) :: object
call object%list_pass%final ()
call object%base_final ()
end subroutine mci_vamp2_final
@ %def mci_vamp2_final
@ Output. Do not output the grids themselves, this may result in tons of data.
<<MCI vamp2: mci vamp2: TBP>>=
procedure, public :: write => mci_vamp2_write
<<MCI vamp2: procedures>>=
subroutine mci_vamp2_write (object, unit, pacify, md5sum_version)
class(mci_vamp2_t), intent(in) :: object
integer, intent(in), optional :: unit
logical, intent(in), optional :: pacify
logical, intent(in), optional :: md5sum_version
integer :: u, i
u = given_output_unit (unit)
write (u, "(1X,A)") "VAMP2 integrator:"
call object%base_write (u, pacify, md5sum_version)
write (u, "(1X,A)") "Grid config:"
call object%config%write (u)
write (u, "(3X,A,L1)") "Integrator defined = ", object%integrator_defined
write (u, "(3X,A,L1)") "Integrator from file = ", object%integrator_from_file
write (u, "(3X,A,L1)") "Adapt grids = ", object%adapt_grids
write (u, "(3X,A,L1)") "Adapt weights = ", object%adapt_weights
write (u, "(3X,A,I0)") "No. of adapt grids = ", object%n_adapt_grids
write (u, "(3X,A,I0)") "No. of adapt weights = ", object%n_adapt_weights
write (u, "(3X,A,L1)") "Verbose = ", object%verbose
if (object%config%equivalences) then
call object%equivalences%write (u)
end if
call object%list_pass%write (u, pacify)
if (object%md5sum_adapted /= "") then
write (u, "(1X,A,A,A)") "MD5 sum (including results) = '", &
& object%md5sum_adapted, "'"
end if
end subroutine mci_vamp2_write
@ %def mci_vamp2_write
@ Compute the (adapted) MD5 sum, including the configuration MD5 sum and the
printout, which incorporates the current results.
<<MCI vamp2: mci vamp2: TBP>>=
procedure, public :: compute_md5sum => mci_vamp2_compute_md5sum
<<MCI vamp2: procedures>>=
subroutine mci_vamp2_compute_md5sum (mci, pacify)
class(mci_vamp2_t), intent(inout) :: mci
logical, intent(in), optional :: pacify
integer :: u
mci%md5sum_adapted = ""
u = free_unit ()
open (u, status = "scratch", action = "readwrite")
write (u, "(A)") mci%md5sum
call mci%write (u, pacify, md5sum_version = .true.)
rewind (u)
mci%md5sum_adapted = md5sum (u)
close (u)
end subroutine mci_vamp2_compute_md5sum
@ %def mci_vamp2_compute_md5sum
@ Return the MD5 sum: If available, return the adapted one.
<<MCI vamp2: mci vamp2: TBP>>=
procedure, public :: get_md5sum => mci_vamp2_get_md5sum
<<MCI vamp2: procedures>>=
pure function mci_vamp2_get_md5sum (mci) result (md5sum)
class(mci_vamp2_t), intent(in) :: mci
character(32) :: md5sum
if (mci%md5sum_adapted /= "") then
md5sum = mci%md5sum_adapted
else
md5sum = mci%md5sum
end if
end function mci_vamp2_get_md5sum
@ %def mci_vamp_get_md5sum
@ Startup message: short version. Make a call to the base function and print
additional information about the multi-channel parameters.
<<MCI vamp2: mci vamp2: TBP>>=
procedure, public :: startup_message => mci_vamp2_startup_message
<<MCI vamp2: procedures>>=
subroutine mci_vamp2_startup_message (mci, unit, n_calls)
class(mci_vamp2_t), intent(in) :: mci
integer, intent(in), optional :: unit, n_calls
integer :: num_calls, n_bins
num_calls = 0; if (present (n_calls)) num_calls = n_calls
n_bins = mci%config%n_bins_max
call mci%base_startup_message (unit = unit, n_calls = n_calls)
if (mci%config%equivalences) then
write (msg_buffer, "(A)") &
"Integrator: Using VAMP2 channel equivalences"
call msg_message (unit = unit)
end if
write (msg_buffer, "(A,2(1x,I0,1x,A),L1)") &
"Integrator:", num_calls, &
"initial calls,", n_bins, &
"max. bins, stratified = ", &
mci%config%stratified
call msg_message (unit = unit)
write (msg_buffer, "(A,2(1x,I0,1x,A))") &
"Integrator: VAMP2"
call msg_message (unit = unit)
end subroutine mci_vamp2_startup_message
@ %def mci_vamp2_startup_message
@ Log entry: just headline.
<<MCI vamp2: mci vamp2: TBP>>=
procedure, public :: write_log_entry => mci_vamp2_write_log_entry
<<MCI vamp2: procedures>>=
subroutine mci_vamp2_write_log_entry (mci, u)
class(mci_vamp2_t), intent(in) :: mci
integer, intent(in) :: u
write (u, "(1x,A)") "MC Integrator is VAMP2"
call write_separator (u)
if (mci%config%equivalences) then
call mci%equivalences%write (u)
else
write (u, "(3x,A)") "No channel equivalences have been used."
end if
call write_separator (u)
call mci%write_chain_weights (u)
end subroutine mci_vamp2_write_log_entry
@ %def mci_vamp2_write_log_entry
@ Set the MCI index (necessary for processes with multiple components). We
append the index to the grid filename, just before the final dotted suffix.
<<MCI vamp2: mci vamp2: TBP>>=
procedure, public :: record_index => mci_vamp2_record_index
<<MCI vamp2: procedures>>=
subroutine mci_vamp2_record_index (mci, i_mci)
class(mci_vamp2_t), intent(inout) :: mci
integer, intent(in) :: i_mci
type(string_t) :: basename, suffix
character(32) :: buffer
if (mci%grid_filename_set) then
write (buffer, "(I0)") i_mci
mci%grid_filename = mci%grid_filename // ".m" // trim (buffer)
end if
end subroutine mci_vamp2_record_index
@ %def mci_vamp2_record_index
@ Set the configuration object.
We adjust the maximum number of bins [[n_bins_max]] according to [[n_calls]]
<<MCI vamp2: mci vamp2: TBP>>=
procedure, public :: set_config => mci_vamp2_set_config
<<MCI vamp2: procedures>>=
subroutine mci_vamp2_set_config (mci, config)
class(mci_vamp2_t), intent(inout) :: mci
type(mci_vamp2_config_t), intent(in) :: config
mci%config = config
end subroutine mci_vamp2_set_config
@ %def mci_vamp2_set_config
@ Set the the rebuild flag, also the for checking the grid.
<<MCI vamp2: mci vamp2: TBP>>=
procedure, public :: set_rebuild_flag => mci_vamp2_set_rebuild_flag
<<MCI vamp2: procedures>>=
subroutine mci_vamp2_set_rebuild_flag (mci, rebuild, check_grid_file)
class(mci_vamp2_t), intent(inout) :: mci
logical, intent(in) :: rebuild
logical, intent(in) :: check_grid_file
mci%rebuild = rebuild
mci%check_grid_file = check_grid_file
end subroutine mci_vamp2_set_rebuild_flag
@ %def mci_vegaa_set_rebuild_flag
@ Set the filename.
<<MCI vamp2: mci vamp2: TBP>>=
procedure, public :: set_grid_filename => mci_vamp2_set_grid_filename
procedure, public :: get_grid_filename => mci_vamp2_get_grid_filename
<<MCI vamp2: procedures>>=
subroutine mci_vamp2_set_grid_filename (mci, name, run_id)
class(mci_vamp2_t), intent(inout) :: mci
type(string_t), intent(in) :: name
type(string_t), intent(in), optional :: run_id
mci%grid_filename = name
if (present (run_id)) then
mci%grid_filename = name // "." // run_id
end if
mci%grid_filename_set = .true.
end subroutine mci_vamp2_set_grid_filename
type(string_t) function mci_vamp2_get_grid_filename (mci, binary_grid_format) &
result (filename)
class(mci_vamp2_t), intent(in) :: mci
logical, intent(in), optional :: binary_grid_format
filename = mci%grid_filename // ".vg2"
if (present (binary_grid_format)) then
if (binary_grid_format) then
filename = mci%grid_filename // ".vgx2"
end if
end if
end function mci_vamp2_get_grid_filename
@ %def mci_vamp2_set_grid_filename, mci_vamp2_get_grid_filename
@ To simplify the interface, we prepend a grid path in a separate subroutine.
<<MCI vamp2: mci vamp2: TBP>>=
procedure :: prepend_grid_path => mci_vamp2_prepend_grid_path
<<MCI vamp2: procedures>>=
subroutine mci_vamp2_prepend_grid_path (mci, prefix)
class(mci_vamp2_t), intent(inout) :: mci
type(string_t), intent(in) :: prefix
if (.not. mci%grid_filename_set) then
call msg_warning ("Cannot add prefix to invalid integrator filename!")
end if
mci%grid_filename = prefix // "/" // mci%grid_filename
end subroutine mci_vamp2_prepend_grid_path
@ %def mci_vamp2_prepend_grid_path
@ Not implemented.
<<MCI vamp2: mci vamp2: TBP>>=
procedure, public :: declare_flat_dimensions => mci_vamp2_declare_flat_dimensions
<<MCI vamp2: procedures>>=
subroutine mci_vamp2_declare_flat_dimensions (mci, dim_flat)
class(mci_vamp2_t), intent(inout) :: mci
integer, dimension(:), intent(in) :: dim_flat
end subroutine mci_vamp2_declare_flat_dimensions
@ %def mci_vamp2_declare_flat_dimensions
@
<<MCI vamp2: mci vamp2: TBP>>=
procedure, public :: declare_equivalences => mci_vamp2_declare_equivalences
<<MCI vamp2: procedures>>=
subroutine mci_vamp2_declare_equivalences (mci, channel, dim_offset)
class(mci_vamp2_t), intent(inout) :: mci
type(phs_channel_t), dimension(:), intent(in) :: channel
integer, intent(in) :: dim_offset
integer, dimension(:), allocatable :: perm, mode
integer :: n_channels, n_dim, n_equivalences
integer :: c, i, j, dest, src
+ integer :: n_dim_perm
n_channels = mci%n_channel
n_dim = mci%n_dim
n_equivalences = 0
do c = 1, n_channels
n_equivalences = n_equivalences + size (channel(c)%eq)
end do
mci%equivalences = vamp2_equivalences_t (&
n_eqv = n_equivalences, n_channel = n_channels, n_dim = n_dim)
allocate (perm (n_dim))
allocate (mode (n_dim))
- perm(1:dim_offset) = [(i, i = 1, dim_offset)]
- mode(1:dim_offset) = 0
+ perm = [(i, i = 1, n_dim)]
+ mode = 0
c = 1
j = 0
do i = 1, n_equivalences
if (j < size (channel(c)%eq)) then
j = j + 1
else
c = c + 1
j = 1
end if
associate (eq => channel(c)%eq(j))
dest = c
src = eq%c
- perm(dim_offset+1:) = eq%perm + dim_offset
- mode(dim_offset+1:) = eq%mode
+ n_dim_perm = size (eq%perm)
+ perm(dim_offset+1:n_dim_perm) = eq%perm + dim_offset
+ mode(dim_offset+1:n_dim_perm) = eq%mode
call mci%equivalences%set_equivalence &
(i, dest, src, perm, mode)
end associate
end do
call mci%equivalences%freeze ()
end subroutine mci_vamp2_declare_equivalences
@ %def mci_vamp2_declare_quivalences
@ Allocate instance with matching type.
<<MCI vamp2: mci vamp2: TBP>>=
procedure, public :: allocate_instance => mci_vamp2_allocate_instance
<<MCI vamp2: procedures>>=
subroutine mci_vamp2_allocate_instance (mci, mci_instance)
class(mci_vamp2_t), intent(in) :: mci
class(mci_instance_t), intent(out), pointer :: mci_instance
allocate (mci_vamp2_instance_t :: mci_instance)
end subroutine mci_vamp2_allocate_instance
@ %def mci_vamp2_allocate_instance
@ Allocate a new integration pass. We can preset everything that does not depend
on the number of iterations and calls. This is postponed to the integrate
method.
In the final pass, we do not check accuracy goal etc., since we can assume
that the user wants to perform and average all iterations in this pass.
<<MCI vamp2: mci vamp2: TBP>>=
procedure, public :: add_pass => mci_vamp2_add_pass
<<MCI vamp2: procedures>>=
subroutine mci_vamp2_add_pass (mci, adapt_grids, adapt_weights, final_pass)
class(mci_vamp2_t), intent(inout) :: mci
logical, intent(in), optional :: adapt_grids, adapt_weights, final_pass
call mci%list_pass%add (adapt_grids, adapt_weights, final_pass)
end subroutine mci_vamp2_add_pass
@ %def mci_vamp2_add_pass
@ Update the list of integration passes.
<<MCI vamp2: mci vamp2: TBP>>=
procedure, public :: update_from_ref => mci_vamp2_update_from_ref
<<MCI vamp2: procedures>>=
subroutine mci_vamp2_update_from_ref (mci, mci_ref, success)
class(mci_vamp2_t), intent(inout) :: mci
class(mci_t), intent(in) :: mci_ref
logical, intent(out) :: success
select type (mci_ref)
type is (mci_vamp2_t)
call mci%list_pass%update_from_ref (mci_ref%list_pass, success)
if (mci%list_pass%current%integral_defined) then
mci%integral = mci%list_pass%current%get_integral ()
mci%error = mci%list_pass%current%get_error ()
mci%efficiency = mci%list_pass%current%get_efficiency ()
mci%integral_known = .true.
mci%error_known = .true.
mci%efficiency_known = .true.
end if
end select
end subroutine mci_vamp2_update_from_ref
@ %def mci_vamp2_update_from_ref
@ Update the MCI record (i.e., the integration passes) by reading from input
stream. The stream should contain a write output from a previous run. We first
check the MD5 sum of the configuration parameters. If that matches, we proceed
directly to the stored integration passes. If successful, we may continue to
read the file; the position will be after a blank line that must follow the MCI
record.
<<MCI vamp2: mci vamp2: TBP>>=
procedure, public :: update => mci_vamp2_update
<<MCI vamp2: procedures>>=
subroutine mci_vamp2_update (mci, u, success)
class(mci_vamp2_t), intent(inout) :: mci
integer, intent(in) :: u
logical, intent(out) :: success
character(80) :: buffer
character(32) :: md5sum_file
type(mci_vamp2_t) :: mci_file
integer :: n_pass, n_it
call read_sval (u, md5sum_file)
success = .true.; if (mci%check_grid_file) &
& success = (md5sum_file == mci%md5sum)
if (success) then
read (u, *)
read (u, "(A)") buffer
if (trim (adjustl (buffer)) /= "VAMP2 integrator:") then
call msg_fatal ("VAMP2: reading grid file: corrupted data")
end if
n_pass = 0
n_it = 0
do
read (u, "(A)") buffer
select case (trim (adjustl (buffer)))
case ("")
exit
case ("Integration pass:")
call mci_file%list_pass%add ()
call mci_file%list_pass%current%read (u, n_pass, n_it)
n_pass = n_pass + 1
n_it = n_it + mci_file%list_pass%current%n_it
end select
end do
call mci%update_from_ref (mci_file, success)
call mci_file%final ()
end if
end subroutine mci_vamp2_update
@ %def mci_vamp2_update
@ Read / write grids from / to file.
We split the reading process in two parts. First, we check on the header where
we check (and update) all relevant pass data using [[mci_vamp2_update]]. In the
second part we only read the integrator data. We implement [[mci_vamp2_read]]
for completeness.
The writing of the MCI object is split into two parts, a header with the relevant process configuration regarding the integration and the results of the different passes and their iterations.
The other part is the actual grid.
The header will always be written in ASCII format, including a md5 hash, in order to testify against unwilling changes to the setup.
The grid part can be either added to the ASCII file, or to an additional binary file.
<<MCI vamp2: mci vamp2: TBP>>=
procedure :: write_grids => mci_vamp2_write_grids
procedure :: read_header => mci_vamp2_read_header
procedure :: read_data => mci_vamp2_read_data
procedure, private :: advance_to_data => mci_vamp2_advance_to_data
<<MCI vamp2: procedures>>=
subroutine mci_vamp2_write_grids (mci)
class(mci_vamp2_t), intent(in) :: mci
integer :: u
if (.not. mci%grid_filename_set) then
call msg_bug ("VAMP2: write grids: filename undefined")
end if
if (.not. mci%integrator_defined) then
call msg_bug ("VAMP2: write grids: grids undefined")
end if
open (newunit = u, file = char (mci%get_grid_filename ()), &
action = "write", status = "replace")
write (u, "(1X,A,A,A)") "MD5sum = '", mci%md5sum, "'"
write (u, *)
call mci%write (u)
write (u, *)
if (mci%binary_grid_format) then
write (u, "(1X,2A)") "VAMP2 grids: binary file: ", &
char (mci%get_grid_filename (binary_grid_format = .true.))
close (u)
open (newunit = u, &
file = char (mci%get_grid_filename (binary_grid_format = .true.)), &
action = "write", &
access = "stream", &
form = "unformatted", &
status = "replace")
call mci%integrator%write_binary_grids (u)
else
write (u, "(1X,A)") "VAMP2 grids:"
call mci%integrator%write_grids (u)
end if
close (u)
end subroutine mci_vamp2_write_grids
subroutine mci_vamp2_read_header (mci, success)
class(mci_vamp2_t), intent(inout) :: mci
logical, intent(out) :: success
logical :: exist, binary_grid_format, exist_binary
integer :: u
success = .false.
if (.not. mci%grid_filename_set) then
call msg_bug ("VAMP2: read grids: filename undefined")
end if
!! First, check for existence of the (usual) grid file.
inquire (file = char (mci%get_grid_filename ()), exist = exist)
if (.not. exist) return !! success = .false.
open (newunit = u, file = char (mci%get_grid_filename ()), &
action = "read", status = "old")
!! Second, check for existence of a (possible) binary grid file.
call mci%advance_to_data (u, binary_grid_format)
rewind (u) !! Rewind header file, after line search.
if (binary_grid_format) then
inquire (file = char (mci%get_grid_filename (binary_grid_format = .true.)), &
exist = exist)
if (.not. exist) then
write (msg_buffer, "(3A)") &
"VAMP2: header: binary grid file not found, discarding grid file '", &
char (mci%get_grid_filename ()), "'."
call msg_message ()
return !! success = .false.
end if
end if
!! The grid file (ending *.vg) exists and, if binary file is listed, it exists, too.
call mci%update (u, success)
close (u)
if (.not. success) then
write (msg_buffer, "(A,A,A)") &
"VAMP2: header: parameter mismatch, discarding pass from file '", &
char (mci%get_grid_filename ()), "'."
call msg_message ()
end if
end subroutine mci_vamp2_read_header
subroutine mci_vamp2_read_data (mci)
class(mci_vamp2_t), intent(inout) :: mci
integer :: u
logical :: binary_grid_format
if (mci%integrator_defined) then
call msg_bug ("VAMP2: read grids: grids already defined")
end if
open (newunit = u, &
file = char (mci%get_grid_filename ()), &
action = "read", &
status = "old")
call mci%advance_to_data (u, binary_grid_format)
if (binary_grid_format) then
close (u)
write (msg_buffer, "(3A)") &
"VAMP2: Reading from binary grid file '", &
char (mci%get_grid_filename (binary_grid_format = .true.)), "'"
call msg_message ()
open (newunit = u, &
file = char (mci%get_grid_filename (binary_grid_format = .true.)), &
action = "read", &
access = "stream", &
form = "unformatted", &
status = "old")
call mci%integrator%read_binary_grids (u)
else
call mci%integrator%read_grids (u)
end if
mci%integrator_defined = .true.
close (u)
end subroutine mci_vamp2_read_data
subroutine mci_vamp2_advance_to_data (mci, u, binary_grid_format)
class(mci_vamp2_t), intent(in) :: mci
integer, intent(in) :: u
logical, intent(out) :: binary_grid_format
character(80) :: buffer
type(string_t) :: search_string_binary, search_string_ascii
search_string_binary = "VAMP2 grids: binary file: " // &
mci%get_grid_filename (binary_grid_format = .true.)
search_string_ascii = "VAMP2 grids:"
SEARCH: do
read (u, "(A)") buffer
if (trim (adjustl (buffer)) == char (search_string_binary)) then
binary_grid_format = .true.
exit SEARCH
else if (trim (adjustl (buffer)) == char (search_string_ascii)) then
binary_grid_format = .false.
exit SEARCH
end if
end do SEARCH
end subroutine mci_vamp2_advance_to_data
@ %def mci_vamp2_write_grids
@ %def mci_vamp2_read_header
@ %def mci_vamp2_read_data
@
\subsubsection{Interface: VAMP2}
\label{sec:interface-vamp2}
We define the interfacing procedures, as such, initialising the VAMP2 integrator
or resetting the results.
Initialise the VAMP2 integrator which is stored within the [[mci]] object, using
the data of the current integration pass. Furthermore, reset the counters that
track this set of integrator.
<<MCI vamp2: mci vamp2: TBP>>=
procedure, public :: init_integrator => mci_vamp2_init_integrator
<<MCI vamp2: procedures>>=
subroutine mci_vamp2_init_integrator (mci)
class(mci_vamp2_t), intent(inout) :: mci
type (pass_t), pointer :: current
integer :: ch, vegas_mode
current => mci%list_pass%current
vegas_mode = merge (VEGAS_MODE_IMPORTANCE, VEGAS_MODE_IMPORTANCE_ONLY,&
& mci%config%stratified)
mci%n_adapt_grids = 0
mci%n_adapt_weights = 0
if (mci%integrator_defined) then
call msg_bug ("[MCI VAMP2]: init integrator: &
& integrator is already initialised.")
end if
mci%integrator = vamp2_t (mci%n_channel, mci%n_dim, &
& n_bins_max = mci%config%n_bins_max, &
& iterations = 1, &
& mode = vegas_mode)
if (mci%has_chains ()) call mci%integrator%set_chain (mci%n_chain, mci%chain)
call mci%integrator%set_config (mci%config)
mci%integrator_defined = .true.
end subroutine mci_vamp2_init_integrator
@ %def mci_vamp2_init_integrator
@ Reset a grid set. Purge the accumulated results.
<<MCI vamp2: mci vamp2: TBP>>=
procedure, public :: reset_result => mci_vamp2_reset_result
<<MCI vamp2: procedures>>=
subroutine mci_vamp2_reset_result (mci)
class(mci_vamp2_t), intent(inout) :: mci
if (.not. mci%integrator_defined) then
call msg_bug ("[MCI VAMP2] reset results: integrator undefined")
end if
call mci%integrator%reset_result ()
end subroutine mci_vamp2_reset_result
@ %def mci_vamp2_reset_result
@ Set calls per channel. The number of calls to each channel is defined by the
channel weight
\begin{equation}
\alpha_i = \frac{N_i}{\sum N_i}.
\end{equation}
<<MCI vamp2: mci vamp2: TBP>>=
procedure, public :: set_calls => mci_vamp2_set_calls
<<MCI vamp2: procedures>>=
subroutine mci_vamp2_set_calls (mci, n_calls)
class(mci_vamp2_t), intent(inout) :: mci
integer :: n_calls
if (.not. mci%integrator_defined) then
call msg_bug ("[MCI VAMP2] set calls: grids undefined")
end if
call mci%integrator%set_calls (n_calls)
end subroutine mci_vamp2_set_calls
@ %def mci_vamp2_set_calls
\subsubsection{Integration}
Initialize. We prepare the integrator from a previous pass, or from file, or
with new objects.
At the end, we update the number of calls either when we got the integration grids from file
and we added new iterations to the current pass, or we allocated a new integrator.
<<MCI vamp2: mci vamp2: TBP>>=
procedure, private :: init_integration => mci_vamp2_init_integration
<<MCI vamp2: procedures>>=
subroutine mci_vamp2_init_integration (mci, n_it, n_calls, instance)
class(mci_vamp2_t), intent(inout) :: mci
integer, intent(in) :: n_it
integer, intent(in) :: n_calls
class(mci_instance_t), intent(inout) :: instance
logical :: from_file, success
if (.not. associated (mci%list_pass%current)) then
call msg_bug ("MCI integrate: current_pass object not allocated")
end if
associate (current_pass => mci%list_pass%current)
current_pass%integral_defined = .false.
mci%config%n_calls_min = mci%config%n_calls_min_per_channel * mci%config%n_channel
call current_pass%configure (n_it, n_calls, mci%config%n_calls_min)
mci%adapt_grids = current_pass%adapt_grids
mci%adapt_weights = current_pass%adapt_weights
mci%pass_complete = .false.
mci%it_complete = .false.
from_file = .false.
if (.not. mci%integrator_defined .or. mci%integrator_from_file) then
if (mci%grid_filename_set .and. .not. mci%rebuild) then
call mci%read_header (success)
from_file = success
if (.not. mci%integrator_defined .and. success) &
call mci%read_data ()
end if
end if
if (from_file) then
if (.not. mci%check_grid_file) &
& call msg_warning ("Reading grid file: MD5 sum check disabled")
call msg_message ("VAMP2: " &
// "Using grids and results from file ’" &
// char (mci%get_grid_filename ()) // "’.")
else if (.not. mci%integrator_defined) then
call msg_message ("VAMP2: " &
// "Initialize new grids and write to file '" &
// char (mci%get_grid_filename ()) // "'.")
call mci%init_integrator ()
end if
mci%integrator_from_file = from_file
if (.not. mci%integrator_from_file .or. (n_it > current_pass%get_integration_index ())) then
call mci%integrator%set_calls (current_pass%n_calls)
end if
call mci%integrator%set_equivalences (mci%equivalences)
end associate
end subroutine mci_vamp2_init_integration
@ %def mci_vamp2_init
@ Integrate. Perform a new integration pass (possibly reusing previous results),
which may consist of several iterations.
We reinitialise the sampling new each time and set the workspace again.
Note: we record the integral once per iteration. The integral stored in the
mci record itself is the last integral of the current iteration, no averaging done.
The results record may average results.
Note: recording the efficiency is not supported yet.
<<MCI vamp2: mci vamp2: TBP>>=
procedure, public :: integrate => mci_vamp2_integrate
<<MCI vamp2: procedures>>=
subroutine mci_vamp2_integrate (mci, instance, sampler, &
n_it, n_calls, results, pacify)
class(mci_vamp2_t), intent(inout) :: mci
class(mci_instance_t), intent(inout), target :: instance
class(mci_sampler_t), intent(inout), target :: sampler
integer, intent(in) :: n_it
integer, intent(in) :: n_calls
class(mci_results_t), intent(inout), optional :: results
logical, intent(in), optional :: pacify
integer :: it
logical :: from_file, success
<<MCI vamp2: mci vamp2 integrate: variables>>
<<MCI vamp2: mci vamp2 integrate: initialization>>
call mci%init_integration (n_it, n_calls, instance)
from_file = mci%integrator_from_file
select type (instance)
type is (mci_vamp2_instance_t)
call instance%set_workspace (sampler)
end select
associate (current_pass => mci%list_pass%current)
do it = 1, current_pass%n_it
if (signal_is_pending ()) return
mci%integrator_from_file = from_file .and. &
it <= current_pass%get_integration_index ()
if (.not. mci%integrator_from_file) then
mci%it_complete = .false.
select type (instance)
type is (mci_vamp2_instance_t)
call mci%integrator%integrate (instance%func, mci%rng, &
& iterations = 1, &
& opt_reset_result = .true., &
& opt_refine_grid = mci%adapt_grids, &
& opt_adapt_weight = mci%adapt_weights, &
& opt_verbose = mci%verbose)
end select
if (signal_is_pending ()) return
mci%it_complete = .true.
integral = mci%integrator%get_integral ()
calls = mci%integrator%get_n_calls ()
select type (instance)
type is (mci_vamp2_instance_t)
calls_valid = instance%func%get_n_calls ()
call instance%func%reset_n_calls ()
end select
error = sqrt (mci%integrator%get_variance ())
efficiency = mci%integrator%get_efficiency ()
<<MCI vamp2: mci vamp2 integrate: sampling>>
if (integral /= 0) then
current_pass%integral(it) = integral
current_pass%calls(it) = calls
current_pass%calls_valid(it) = calls_valid
current_pass%error(it) = error
current_pass%efficiency(it) = efficiency
end if
current_pass%integral_defined = .true.
end if
if (present (results)) then
if (mci%has_chains ()) then
call mci%collect_chain_weights (instance%w)
call results%record (1, &
n_calls = current_pass%calls(it), &
n_calls_valid = current_pass%calls_valid(it), &
integral = current_pass%integral(it), &
error = current_pass%error(it), &
efficiency = current_pass%efficiency(it), &
efficiency_pos = current_pass%efficiency(it), &
efficiency_neg = 0._default, &
chain_weights = mci%chain_weights, &
suppress = pacify)
else
call results%record (1, &
n_calls = current_pass%calls(it), &
n_calls_valid = current_pass%calls_valid(it), &
integral = current_pass%integral(it), &
error = current_pass%error(it), &
efficiency = current_pass%efficiency(it), &
efficiency_pos = current_pass%efficiency(it), &
efficiency_neg = 0._default, &
suppress = pacify)
end if
end if
if (.not. mci%integrator_from_file &
.and. mci%grid_filename_set) then
<<MCI vamp2: mci vamp2 integrate: post sampling>> call mci%write_grids ()
end if
if (.not. current_pass%is_final_pass) then
call check_goals (it, success)
if (success) exit
end if
end do
if (signal_is_pending ()) return
mci%pass_complete = .true.
mci%integral = current_pass%get_integral()
mci%error = current_pass%get_error()
mci%efficiency = current_pass%get_efficiency()
mci%integral_known = .true.
mci%error_known = .true.
mci%efficiency_known = .true.
call mci%compute_md5sum (pacify)
end associate
contains
<<MCI vamp2: mci vamp2 integrate: procedures>>
end subroutine mci_vamp2_integrate
@ %def mci_vamp2_integrate
<<MCI vamp2: mci vamp2 integrate: variables>>=
real(default) :: integral, error, efficiency
integer :: calls, calls_valid
@
<<MCI vamp2: mci vamp2 integrate: initialization>>=
@
<<MCI vamp2: mci vamp2 integrate: sampling>>=
@
<<MCI vamp2: mci vamp2 integrate: post sampling>>=
@
<<MPI: MCI vamp2: mci vamp2 integrate: variables>>=
integer :: rank, n_size
type(MPI_Request), dimension(6) :: request
@ MPI procedure-specific initialization.
<<MPI: MCI vamp2: mci vamp2 integrate: initialization>>=
call MPI_Comm_size (MPI_COMM_WORLD, n_size)
call MPI_Comm_rank (MPI_COMM_WORLD, rank)
@ We broadcast the current results to all worker, such that they can store them
in to the pass list.
<<MPI: MCI vamp2: mci vamp2 integrate: sampling>>=
call MPI_Ibcast (integral, 1, MPI_DOUBLE_PRECISION, 0, MPI_COMM_WORLD, request(1))
call MPI_Ibcast (calls, 1, MPI_INTEGER, 0, MPI_COMM_WORLD, request(2))
call MPI_Ibcast (calls_valid, 1, MPI_INTEGER, 0, MPI_COMM_WORLD, request(3))
call MPI_Ibcast (error, 1, MPI_DOUBLE_PRECISION, 0, MPI_COMM_WORLD, request(4))
call MPI_Ibcast (efficiency, 1, MPI_DOUBLE_PRECISION, 0, MPI_COMM_WORLD, request(5))
call MPI_Waitall (5, request, MPI_STATUSES_IGNORE)
@ We only allow the master to write the grids to file.
<<MPI: MCI vamp2: mci vamp2 integrate: post sampling>>=
if (rank == 0)
@ Check whether we are already finished with this pass.
<<MCI vamp2: mci vamp2 integrate: procedures>>=
subroutine check_goals (it, success)
integer, intent(in) :: it
logical, intent(out) :: success
success = .false.
associate (current_pass => mci%list_pass%current)
if (error_reached (it)) then
current_pass%n_it = it
call msg_message ("[MCI VAMP2] error goal reached; &
&skipping iterations")
success = .true.
return
end if
if (rel_error_reached (it)) then
current_pass%n_it = it
call msg_message ("[MCI VAMP2] relative error goal reached; &
&skipping iterations")
success = .true.
return
end if
if (accuracy_reached (it)) then
current_pass%n_it = it
call msg_message ("[MCI VAMP2] accuracy goal reached; &
&skipping iterations")
success = .true.
return
end if
end associate
end subroutine check_goals
@ %def mci_vamp2_check_goals
@ Return true if the error, relative error or accurary goals hase been reached,
if any.
<<MCI vamp2: mci vamp2 integrate: procedures>>=
function error_reached (it) result (flag)
integer, intent(in) :: it
logical :: flag
real(default) :: error_goal, error
error_goal = mci%config%error_goal
flag = .false.
associate (current_pass => mci%list_pass%current)
if (error_goal > 0 .and. current_pass%integral_defined) then
error = abs (current_pass%error(it))
flag = error < error_goal
end if
end associate
end function error_reached
function rel_error_reached (it) result (flag)
integer, intent(in) :: it
logical :: flag
real(default) :: rel_error_goal, rel_error
rel_error_goal = mci%config%rel_error_goal
flag = .false.
associate (current_pass => mci%list_pass%current)
if (rel_error_goal > 0 .and. current_pass%integral_defined) then
rel_error = abs (current_pass%error(it) / current_pass%integral(it))
flag = rel_error < rel_error_goal
end if
end associate
end function rel_error_reached
function accuracy_reached (it) result (flag)
integer, intent(in) :: it
logical :: flag
real(default) :: accuracy_goal, accuracy
accuracy_goal = mci%config%accuracy_goal
flag = .false.
associate (current_pass => mci%list_pass%current)
if (accuracy_goal > 0 .and. current_pass%integral_defined) then
if (current_pass%integral(it) /= 0) then
accuracy = abs (current_pass%error(it) / current_pass%integral(it)) &
* sqrt (real (current_pass%calls(it), default))
flag = accuracy < accuracy_goal
else
flag = .true.
end if
end if
end associate
end function accuracy_reached
@ %def error_reached, rel_error_reached, accuracy_reached
@
\subsection{Event generation}
Prepare simulation. We check the grids and reread them from file, if necessary.
<<MCI vamp2: mci vamp2: TBP>>=
procedure, public :: prepare_simulation => mci_vamp2_prepare_simulation
<<MCI vamp2: procedures>>=
subroutine mci_vamp2_prepare_simulation (mci)
class(mci_vamp2_t), intent(inout) :: mci
logical :: success
if (.not. mci%grid_filename_set) then
call msg_bug ("VAMP2: preapre simulation: integrator filename not set.")
end if
call mci%read_header (success)
call mci%compute_md5sum ()
if (.not. success) then
call msg_fatal ("Simulate: " &
// "reading integration grids from file ’" &
// char (mci%get_grid_filename ()) // "’ failed")
end if
if (.not. mci%integrator_defined) then
call mci%read_data ()
end if
call groom_rng (mci%rng)
contains
subroutine groom_rng (rng)
class(rng_t), intent(inout) :: rng
integer :: i, rank, n_size
call mpi_get_comm_id (n_size, rank)
do i = 2, rank + 1
select type (rng)
type is (rng_stream_t)
call rng%next_substream ()
if (i == rank) &
call msg_message ("MCI: Advance RNG for parallel event simulation")
class default
call msg_bug ("Use of any random number generator &
&beside rng_stream for parallel event generation not supported.")
end select
end do
end subroutine groom_rng
end subroutine mci_vamp2_prepare_simulation
@ %def mci_vamp2_prepare_simulation
@ Generate an unweighted event. We only set the workspace again before
generating an event.
<<MCI vamp2: mci vamp2: TBP>>=
procedure, public :: generate_weighted_event => mci_vamp2_generate_weighted_event
<<MCI vamp2: procedures>>=
subroutine mci_vamp2_generate_weighted_event (mci, instance, sampler)
class(mci_vamp2_t), intent(inout) :: mci
class(mci_instance_t), intent(inout), target :: instance
class(mci_sampler_t), intent(inout), target :: sampler
if (.not. mci%integrator_defined) then
call msg_bug ("VAMP2: generate weighted event: undefined integrator")
end if
select type (instance)
type is (mci_vamp2_instance_t)
instance%event_generated = .false.
call instance%set_workspace (sampler)
call mci%integrator%generate_weighted (&
& instance%func, mci%rng, instance%event_x)
instance%event_weight = mci%integrator%get_evt_weight ()
instance%event_excess = 0
instance%n_events = instance%n_events + 1
instance%event_generated = .true.
end select
end subroutine mci_vamp2_generate_weighted_event
@ %def mci_vamp2_generate_weighted_event
@ We apply an additional rescaling factor for [[f_max]] (either for the positive or negative distribution).
<<MCI vamp2: mci vamp2: TBP>>=
procedure, public :: generate_unweighted_event => mci_vamp2_generate_unweighted_event
<<MCI vamp2: procedures>>=
subroutine mci_vamp2_generate_unweighted_event (mci, instance, sampler)
class(mci_vamp2_t), intent(inout) :: mci
class(mci_instance_t), intent(inout), target :: instance
class(mci_sampler_t), intent(inout), target :: sampler
if (.not. mci%integrator_defined) then
call msg_bug ("VAMP2: generate unweighted event: undefined integrator")
end if
select type (instance)
type is (mci_vamp2_instance_t)
instance%event_generated = .false.
call instance%set_workspace (sampler)
generate: do
call mci%integrator%generate_unweighted (&
& instance%func, mci%rng, instance%event_x, &
& opt_event_rescale = instance%event_rescale_f_max)
instance%event_excess = mci%integrator%get_evt_weight_excess ()
if (signal_is_pending ()) return
if (sampler%is_valid ()) exit generate
end do generate
if (mci%integrator%get_evt_weight () < 0.) then
if (.not. mci%negative_weights) then
call msg_fatal ("MCI VAMP2 cannot sample negative weights!")
end if
instance%event_weight = -1._default
else
instance%event_weight = 1._default
end if
instance%n_events = instance%n_events + 1
instance%event_generated = .true.
end select
end subroutine mci_vamp2_generate_unweighted_event
@ %def mci_vamp2_generate_unweighted_event
@
<<MCI vamp2: mci vamp2: TBP>>=
procedure, public :: rebuild_event => mci_vamp2_rebuild_event
<<MCI vamp2: procedures>>=
subroutine mci_vamp2_rebuild_event (mci, instance, sampler, state)
class(mci_vamp2_t), intent(inout) :: mci
class(mci_instance_t), intent(inout) :: instance
class(mci_sampler_t), intent(inout) :: sampler
class(mci_state_t), intent(in) :: state
call msg_bug ("MCI VAMP2 rebuild event not implemented yet.")
end subroutine mci_vamp2_rebuild_event
@ %def mci_vamp2_rebuild_event
@
\subsection{Integrator instance}
\label{sec:nistance}
We store all information relevant for simulation. The event weight is stored, when a
weighted event is generated, and the event excess, when a larger weight occurs
than actual stored max. weight.
We give the possibility to rescale the [[f_max]] within the integrator object
with [[event_rescale_f_max]].
<<MCI vamp2: public>>=
public :: mci_vamp2_instance_t
<<MCI vamp2: types>>=
type, extends (mci_instance_t) :: mci_vamp2_instance_t
class(mci_vamp2_func_t), allocatable :: func
real(default), dimension(:), allocatable :: gi
integer :: n_events = 0
logical :: event_generated = .false.
real(default) :: event_weight = 0.
real(default) :: event_excess = 0.
real(default) :: event_rescale_f_max = 1.
real(default), dimension(:), allocatable :: event_x
contains
<<MCI vamp2: mci vamp2 instance: TBP>>
end type mci_vamp2_instance_t
@ %def mci_vamp2_instance_t
@ Output.
<<MCI vamp2: mci vamp2 instance: TBP>>=
procedure, public :: write => mci_vamp2_instance_write
<<MCI vamp2: procedures>>=
subroutine mci_vamp2_instance_write (object, unit, pacify)
class(mci_vamp2_instance_t), intent(in) :: object
integer, intent(in), optional :: unit
logical, intent(in), optional :: pacify
integer :: u, ch, j
character(len=7) :: fmt
call pac_fmt (fmt, FMT_17, FMT_14, pacify)
u = given_output_unit (unit)
write (u, "(1X,A)") "MCI VAMP2 instance:"
write (u, "(1X,A,I0)") &
& "Selected channel = ", object%selected_channel
write (u, "(1X,A25,1X," // fmt // ")") &
& "Integrand = ", object%integrand
write (u, "(1X,A25,1X," // fmt // ")") &
& "MCI weight = ", object%mci_weight
write (u, "(1X,A,L1)") &
& "Valid = ", object%valid
write (u, "(1X,A)") "MCI a-priori weight:"
do ch = 1, size (object%w)
write (u, "(3X,I25,1X," // fmt // ")") ch, object%w(ch)
end do
write (u, "(1X,A)") "MCI jacobian:"
do ch = 1, size (object%w)
write (u, "(3X,I25,1X," // fmt // ")") ch, object%f(ch)
end do
write (u, "(1X,A)") "MCI mapped x:"
do ch = 1, size (object%w)
do j = 1, size (object%x, 1)
write (u, "(3X,2(1X,I8),1X," // fmt // ")") j, ch, object%x(j, ch)
end do
end do
write (u, "(1X,A)") "MCI channel weight:"
do ch = 1, size (object%w)
write (u, "(3X,I25,1X," // fmt // ")") ch, object%gi(ch)
end do
write (u, "(1X,A,I0)") &
& "Number of event = ", object%n_events
write (u, "(1X,A,L1)") &
& "Event generated = ", object%event_generated
write (u, "(1X,A25,1X," // fmt // ")") &
& "Event weight = ", object%event_weight
write (u, "(1X,A25,1X," // fmt // ")") &
& "Event excess = ", object%event_excess
write (u, "(1X,A25,1X," // fmt // ")") &
& "Event rescale f max = ", object%event_rescale_f_max
write (u, "(1X,A,L1)") &
& "Negative (event) weight = ", object%negative_weights
write (u, "(1X,A)") "MCI event"
do j = 1, size (object%event_x)
write (u, "(3X,I25,1X," // fmt // ")") j, object%event_x(j)
end do
end subroutine mci_vamp2_instance_write
@ %def mci_vamp2_instance_write
@ Finalizer. We are only using allocatable, so there is nothing to do here.
<<MCI vamp2: mci vamp2 instance: TBP>>=
procedure, public :: final => mci_vamp2_instance_final
<<MCI vamp2: procedures>>=
subroutine mci_vamp2_instance_final (object)
class(mci_vamp2_instance_t), intent(inout) :: object
!
end subroutine mci_vamp2_instance_final
@ %def mci_vamp2_instance_final
@ Initializer.
<<MCI vamp2: mci vamp2 instance: TBP>>=
procedure, public :: init => mci_vamp2_instance_init
<<MCI vamp2: procedures>>=
subroutine mci_vamp2_instance_init (mci_instance, mci)
class(mci_vamp2_instance_t), intent(out) :: mci_instance
class(mci_t), intent(in), target :: mci
call mci_instance%base_init (mci)
allocate (mci_instance%gi(mci%n_channel), source=0._default)
allocate (mci_instance%event_x(mci%n_dim), source=0._default)
allocate (mci_vamp2_func_t :: mci_instance%func)
call mci_instance%func%init (n_dim = mci%n_dim, n_channel = mci%n_channel)
end subroutine mci_vamp2_instance_init
@ %def mci_vamp2_instance_init
@ Set workspace for [[mci_vamp2_func_t]].
<<MCI vamp2: mci vamp2 instance: TBP>>=
procedure, public :: set_workspace => mci_vamp2_instance_set_workspace
<<MCI vamp2: procedures>>=
subroutine mci_vamp2_instance_set_workspace (instance, sampler)
class(mci_vamp2_instance_t), intent(inout), target :: instance
class(mci_sampler_t), intent(inout), target :: sampler
call instance%func%set_workspace (instance, sampler)
end subroutine mci_vamp2_instance_set_workspace
@ %def mci_vmp2_instance_set_workspace
@
\subsubsection{Evaluation}
Compute multi-channel weight. The computation of the multi-channel weight is
done by the VAMP2 function. We retrieve the information.
<<MCI vamp2: mci vamp2 instance: TBP>>=
procedure, public :: compute_weight => mci_vamp2_instance_compute_weight
<<MCI vamp2: procedures>>=
subroutine mci_vamp2_instance_compute_weight (mci, c)
class(mci_vamp2_instance_t), intent(inout) :: mci
integer, intent(in) :: c
mci%gi = mci%func%get_probabilities ()
mci%mci_weight = mci%func%get_weight ()
end subroutine mci_vamp2_instance_compute_weight
@ %def mci_vamp2_instance_compute_weight
@ Record the integrand.
<<MCI vamp2: mci vamp2 instance: TBP>>=
procedure, public :: record_integrand => mci_vamp2_instance_record_integrand
<<MCI vamp2: procedures>>=
subroutine mci_vamp2_instance_record_integrand (mci, integrand)
class(mci_vamp2_instance_t), intent(inout) :: mci
real(default), intent(in) :: integrand
mci%integrand = integrand
call mci%func%set_integrand (integrand)
end subroutine mci_vamp2_instance_record_integrand
@ %def mci_vamp2_instance_record_integrand
@ \subsubsection{Event simulation}
In contrast to VAMP, we reset only counters
-and set the safety factor, which will then will be applied each time a event is
+and set the safety factor, which will then will be applied each time an event is
generated. In that way we do not rescale the actual values in the integrator,
but more the current value!
<<MCI vamp2: mci vamp2 instance: TBP>>=
procedure, public :: init_simulation => mci_vamp2_instance_init_simulation
<<MCI vamp2: procedures>>=
subroutine mci_vamp2_instance_init_simulation (instance, safety_factor)
class(mci_vamp2_instance_t), intent(inout) :: instance
real(default), intent(in), optional :: safety_factor
if (present (safety_factor)) instance%event_rescale_f_max = safety_factor
instance%n_events = 0
instance%event_generated = .false.
if (instance%event_rescale_f_max /= 1) then
write (msg_buffer, "(A,ES10.3,A)") "Simulate: &
&applying safety factor ", instance%event_rescale_f_max, &
& " to event rejection."
call msg_message ()
end if
end subroutine mci_vamp2_instance_init_simulation
@ %def mci_vamp2_instance_init_simulation
@
<<MCI vamp2: mci vamp2 instance: TBP>>=
procedure, public :: final_simulation => mci_vamp2_instance_final_simulation
<<MCI vamp2: procedures>>=
subroutine mci_vamp2_instance_final_simulation (instance)
class(mci_vamp2_instance_t), intent(inout) :: instance
!
end subroutine mci_vamp2_instance_final_simulation
@ %def mci_vamp2_instance_final
@
<<MCI vamp2: mci vamp2 instance: TBP>>=
procedure, public :: get_event_weight => mci_vamp2_instance_get_event_weight
<<MCI vamp2: procedures>>=
function mci_vamp2_instance_get_event_weight (mci) result (weight)
class(mci_vamp2_instance_t), intent(in) :: mci
real(default) :: weight
if (.not. mci%event_generated) then
call msg_bug ("MCI VAMP2: get event weight: no event generated")
end if
weight = mci%event_weight
end function mci_vamp2_instance_get_event_weight
@ %def mci_vamp2_instance_get_event_weight
@
<<MCI vamp2: mci vamp2 instance: TBP>>=
procedure, public :: get_event_excess => mci_vamp2_instance_get_event_excess
<<MCI vamp2: procedures>>=
function mci_vamp2_instance_get_event_excess (mci) result (excess)
class(mci_vamp2_instance_t), intent(in) :: mci
real(default) :: excess
if (.not. mci%event_generated) then
call msg_bug ("MCI VAMP2: get event excess: no event generated")
end if
excess = mci%event_excess
end function mci_vamp2_instance_get_event_excess
@ %def mci_vamp2_instance_get_event_excess
@
\clearpage
\subsection{Unit tests}
\label{sec:mic-vamp2-ut}
Test module, followed by the corresponding implementation module.
<<[[mci_vamp2_ut.f90]]>>=
<<File header>>
module mci_vamp2_ut
use unit_tests
use mci_vamp2_uti
<<Standard module head>>
<<MCI vamp2: public test>>
contains
<<MCI vamp2: test driver>>
end module mci_vamp2_ut
@ %def mci_vamp2_ut
@
<<[[mci_vamp2_uti.f90]]>>=
<<File header>>
module mci_vamp2_uti
<<Use kinds>>
<<Use strings>>
use io_units
use constants, only: PI, TWOPI
use rng_base
use rng_tao
use rng_stream
use mci_base
use mci_vamp2
<<Standard module head>>
<<MCI vamp2: test declarations>>
<<MCI vamp2: test types>>
contains
<<MCI vamp2: tests>>
end module mci_vamp2_uti
@ %def mci_vamp2_uti
@ API: driver for the unit tests below.
<<MCI vamp2: public test>>=
public :: mci_vamp2_test
<<MCI vamp2: test driver>>=
subroutine mci_vamp2_test (u, results)
integer, intent(in) :: u
type(test_results_t), intent(inout) :: results
<<MCI vamp2: execute tests>>
end subroutine mci_vamp2_test
@ %def mci_vamp2_test
@
\subsubsection{Test sampler}
\label{sec:mci-vamp2-test-sampler}
A test sampler object should implement a function with known integral that
we can use to check the integrator.
In mode [[1]], the function is $f(x) = 3 x^2$ with integral $\int_0^1
f(x)\,dx=1$ and maximum $f(1)=3$. If the integration dimension is
greater than one, the function is extended as a constant in the other
dimension(s).
In mode [[2]], the function is $11 x^{10}$, also with integral $1$.
Mode [[4]] includes ranges of zero and negative function value, the
integral is negative. The results should be identical to the results
of [[mci_midpoint_4]], where the same function is evaluated. The
function is $f(x) = (1 - 3 x^2)\,\theta(x-1/2)$ with integral
$\int_0^1 f(x)\,dx=-3/8$, minimum $f(1)=-2$ and maximum $f(1/2)=1/4$.
<<MCI vamp2: test types>>=
type, extends (mci_sampler_t) :: test_sampler_1_t
real(default), dimension(:), allocatable :: x
real(default) :: val
integer :: mode = 1
contains
<<MCI vamp2: test sampler 1: TBP>>
end type test_sampler_1_t
@ %def test_sampler_1_t
@ Output: There is nothing stored inside, so just print an informative line.
<<MCI vamp2: test sampler 1: TBP>>=
procedure, public :: write => test_sampler_1_write
<<MCI vamp2: tests>>=
subroutine test_sampler_1_write (object, unit, testflag)
class(test_sampler_1_t), intent(in) :: object
integer, intent(in), optional :: unit
logical, intent(in), optional :: testflag
integer :: u
u = given_output_unit (unit)
select case (object%mode)
case (1)
write (u, "(1x,A)") "Test sampler: f(x) = 3 x^2"
case (2)
write (u, "(1x,A)") "Test sampler: f(x) = 11 x^10"
case (3)
write (u, "(1x,A)") "Test sampler: f(x) = 11 x^10 * 2 * cos^2 (2 pi y)"
case (4)
write (u, "(1x,A)") "Test sampler: f(x) = (1 - 3 x^2) theta(x - 1/2)"
end select
end subroutine test_sampler_1_write
@ %def test_sampler_1_write
@ Evaluation: compute the function value. The output $x$ parameter
(only one channel) is identical to the input $x$, and the Jacobian is 1.
<<MCI vamp2: test sampler 1: TBP>>=
procedure, public :: evaluate => test_sampler_1_evaluate
<<MCI vamp2: tests>>=
subroutine test_sampler_1_evaluate (sampler, c, x_in, val, x, f)
class(test_sampler_1_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
if (allocated (sampler%x)) deallocate (sampler%x)
allocate (sampler%x (size (x_in)))
sampler%x = x_in
select case (sampler%mode)
case (1)
sampler%val = 3 * x_in(1) ** 2
case (2)
sampler%val = 11 * x_in(1) ** 10
case (3)
sampler%val = 11 * x_in(1) ** 10 * 2 * cos (twopi * x_in(2)) ** 2
case (4)
if (x_in(1) >= .5_default) then
sampler%val = 1 - 3 * x_in(1) ** 2
else
sampler%val = 0
end if
end select
call sampler%fetch (val, x, f)
end subroutine test_sampler_1_evaluate
@ %def test_sampler_1_evaluate
@ The point is always valid.
<<MCI vamp2: test sampler 1: TBP>>=
procedure, public :: is_valid => test_sampler_1_is_valid
<<MCI vamp2: tests>>=
function test_sampler_1_is_valid (sampler) result (valid)
class(test_sampler_1_t), intent(in) :: sampler
logical :: valid
valid = .true.
end function test_sampler_1_is_valid
@ %def test_sampler_1_is_valid
@ Rebuild: compute all but the function value.
<<MCI vamp2: test sampler 1: TBP>>=
procedure, public :: rebuild => test_sampler_1_rebuild
<<MCI vamp2: tests>>=
subroutine test_sampler_1_rebuild (sampler, c, x_in, val, x, f)
class(test_sampler_1_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
if (allocated (sampler%x)) deallocate (sampler%x)
allocate (sampler%x (size (x_in)))
sampler%x = x_in
sampler%val = val
x(:,1) = sampler%x
f = 1
end subroutine test_sampler_1_rebuild
@ %def test_sampler_1_rebuild
@ Extract the results.
<<MCI vamp2: test sampler 1: TBP>>=
procedure, public :: fetch => test_sampler_1_fetch
<<MCI vamp2: tests>>=
subroutine test_sampler_1_fetch (sampler, val, x, f)
class(test_sampler_1_t), intent(in) :: sampler
real(default), intent(out) :: val
real(default), dimension(:,:), intent(out) :: x
real(default), dimension(:), intent(out) :: f
val = sampler%val
x(:,1) = sampler%x
f = 1
end subroutine test_sampler_1_fetch
@ %def test_sampler_1_fetch
@
\subsubsection{Two-channel, two dimension test sampler}
This sampler implements the function
\begin{equation}
f(x, y) = 4\sin^2(\pi x)\sin^2(\pi y) + 2\sin^2(\pi v)
\end{equation}
where
\begin{align}
x &= u^v &u &= xy
\\
y &= u^{(1-v)} &v &= \frac12\left(1 + \frac{\log(x/y)}{\log xy}\right)
\end{align}
Each term contributes $1$ to the integral. The first term in the function is
peaked along a cross aligned to the coordinates $x$ and $y$, while the second
term is peaked along the diagonal $x=y$.
The Jacobian is
\begin{equation}
\frac{\partial(x,y)}{\partial(u,v)} = |\log u|
\end{equation}
<<MCI vamp2: test types>>=
type, extends (mci_sampler_t) :: test_sampler_2_t
real(default), dimension(:,:), allocatable :: x
real(default), dimension(:), allocatable :: f
real(default) :: val
contains
<<MCI vamp2: test sampler 2: TBP>>
end type test_sampler_2_t
@ %def test_sampler_2_t
@ Output: There is nothing stored inside, so just print an informative line.
<<MCI vamp2: test sampler 2: TBP>>=
procedure, public :: write => test_sampler_2_write
<<MCI vamp2: tests>>=
subroutine test_sampler_2_write (object, unit, testflag)
class(test_sampler_2_t), intent(in) :: object
integer, intent(in), optional :: unit
logical, intent(in), optional :: testflag
integer :: u
u = given_output_unit (unit)
write (u, "(1x,A)") "Two-channel test sampler 2"
end subroutine test_sampler_2_write
@ %def test_sampler_2_write
@ Kinematics: compute $x$ and Jacobians, given the input parameter array.
<<MCI vamp2: test sampler 2: TBP>>=
procedure, public :: compute => test_sampler_2_compute
<<MCI vamp2: tests>>=
subroutine test_sampler_2_compute (sampler, c, x_in)
class(test_sampler_2_t), intent(inout) :: sampler
integer, intent(in) :: c
real(default), dimension(:), intent(in) :: x_in
real(default) :: xx, yy, uu, vv
if (.not. allocated (sampler%x)) &
allocate (sampler%x (size (x_in), 2))
if (.not. allocated (sampler%f)) &
allocate (sampler%f (2))
select case (c)
case (1)
xx = x_in(1)
yy = x_in(2)
uu = xx * yy
vv = (1 + log (xx/yy) / log (xx*yy)) / 2
case (2)
uu = x_in(1)
vv = x_in(2)
xx = uu ** vv
yy = uu ** (1 - vv)
end select
sampler%val = (2 * sin (pi * xx) * sin (pi * yy)) ** 2 &
+ 2 * sin (pi * vv) ** 2
sampler%f(1) = 1
sampler%f(2) = abs (log (uu))
sampler%x(:,1) = [xx, yy]
sampler%x(:,2) = [uu, vv]
end subroutine test_sampler_2_compute
@ %def test_sampler_kinematics
@ Evaluation: compute the function value. The output $x$ parameter (only one
channel) is identical to the input $x$, and the Jacobian is 1.
<<MCI vamp2: test sampler 2: TBP>>=
procedure, public :: evaluate => test_sampler_2_evaluate
<<MCI vamp2: tests>>=
subroutine test_sampler_2_evaluate (sampler, c, x_in, val, x, f)
class(test_sampler_2_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%compute (c, x_in)
call sampler%fetch (val, x, f)
end subroutine test_sampler_2_evaluate
@ %def test_sampler_2_evaluate
@ The point is always valid.
<<MCI vamp2: test sampler 2: TBP>>=
procedure, public :: is_valid => test_sampler_2_is_valid
<<MCI vamp2: tests>>=
function test_sampler_2_is_valid (sampler) result (valid)
class(test_sampler_2_t), intent(in) :: sampler
logical :: valid
valid = .true.
end function test_sampler_2_is_valid
@ %def test_sampler_2_is_valid
@ Rebuild: compute all but the function value.
<<MCI vamp2: test sampler 2: TBP>>=
procedure, public :: rebuild => test_sampler_2_rebuild
<<MCI vamp2: tests>>=
subroutine test_sampler_2_rebuild (sampler, c, x_in, val, x, f)
class(test_sampler_2_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 sampler%compute (c, x_in)
x = sampler%x
f = sampler%f
end subroutine test_sampler_2_rebuild
@ %def test_sampler_2_rebuild
@ Extract the results.
<<MCI vamp2: test sampler 2: TBP>>=
procedure, public :: fetch => test_sampler_2_fetch
<<MCI vamp2: tests>>=
subroutine test_sampler_2_fetch (sampler, val, x, f)
class(test_sampler_2_t), intent(in) :: sampler
real(default), intent(out) :: val
real(default), dimension(:,:), intent(out) :: x
real(default), dimension(:), intent(out) :: f
val = sampler%val
x = sampler%x
f = sampler%f
end subroutine test_sampler_2_fetch
@ %def test_sampler_2_fetch
@
\subsubsection{One-dimensional integration}
\label{sec:mci-vamp2-one-dim}
Construct an integrator and use it for a one-dimensional sampler.
<<MCI vamp2: execute tests>>=
call test (mci_vamp2_1, "mci_vamp2_1", "one-dimensional integral", u, results)
<<MCI vamp2: test declarations>>=
public :: mci_vamp2_1
<<MCI vamp2: tests>>=
subroutine mci_vamp2_1 (u)
integer, intent(in) :: u
type(mci_vamp2_config_t) :: config
class(mci_t), allocatable, target :: mci
class(mci_instance_t), pointer :: mci_instance => null ()
class(mci_sampler_t), allocatable, target :: mci_sampler
class(rng_t), allocatable :: rng
type(string_t) :: filename
write (u, "(A)") "* Test output: mci_vamp2_1"
write (u, "(A)") "* Purpose: integrate function in one dimension (single channel)"
write (u, "(A)")
write (u, "(A)") "* Initialise integrator"
write (u, "(A)")
allocate (mci_vamp2_t :: mci)
call mci%set_dimensions (1, 1)
filename = "mci_vamp2_1"
select type (mci)
type is (mci_vamp2_t)
call mci%set_config (config)
call mci%set_grid_filename (filename)
end select
allocate (rng_stream_t :: rng)
call rng%init ()
call mci%import_rng (rng)
call mci%write (u, pacify = .true.)
write (u, "(A)")
write (u, "(A)") "* Initialise instance"
write (u, "(A)")
call mci%allocate_instance (mci_instance)
call mci_instance%init (mci)
write (u, "(A)")
write (u, "(A)") "* Initialise test sampler"
write (u, "(A)")
allocate (test_sampler_1_t :: mci_sampler)
call mci_sampler%write (u)
write (u, "(A)")
write (u, "(A)") "* Integrate with n_calls = 1000"
write (u, "(A)") " (lower precision to avoid"
write (u, "(A)") " numerical noise)"
write (u, "(A)")
select type (mci)
type is (mci_vamp2_t)
call mci%add_pass ()
end select
call mci%integrate (mci_instance, mci_sampler, 1, 1000, pacify = .true.)
call mci%write (u, pacify = .true.)
write (u, "(A)")
write (u, "(A)") "* Contents of mci_instance:"
write (u, "(A)")
call mci_instance%write (u, pacify = .true.)
write (u, "(A)")
write (u, "(A)") "* Dump channel weights and grids to file"
write (u, "(A)")
mci%md5sum = "1234567890abcdef1234567890abcdef"
select type (mci)
type is (mci_vamp2_t)
call mci%write_grids ()
end select
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call mci_instance%final ()
call mci%final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: mci_vamp2_1"
end subroutine mci_vamp2_1
@ %def mci_vamp2_test1
@
\subsubsection{Multiple iterations}
Construct an integrator and use it for a one-dimensional sampler.
Integrate with five iterations without grid adaptation.
<<MCI vamp2: execute tests>>=
call test (mci_vamp2_2, "mci_vamp2_2", &
"multiple iterations", &
u, results)
<<MCI vamp2: test declarations>>=
public :: mci_vamp2_2
<<MCI vamp2: tests>>=
subroutine mci_vamp2_2 (u)
type(mci_vamp2_config_t) :: config
integer, intent(in) :: u
class(mci_t), allocatable, target :: mci
class(mci_instance_t), pointer :: mci_instance => null ()
class(mci_sampler_t), allocatable :: sampler
class(rng_t), allocatable :: rng
type(string_t) :: filename
write (u, "(A)") "* Test output: mci_vamp2_2"
write (u, "(A)") "* Purpose: integrate function in one dimension &
&(single channel), but multiple iterations."
write (u, "(A)")
write (u, "(A)") "* Initialize integrator, sampler, instance"
write (u, "(A)")
allocate (mci_vamp2_t :: mci)
call mci%set_dimensions (1, 1)
filename = "mci_vamp2_2"
select type (mci)
type is (mci_vamp2_t)
call mci%set_config (config)
call mci%set_grid_filename (filename)
end select
allocate (rng_stream_t :: rng)
call rng%init ()
call mci%import_rng (rng)
call mci%allocate_instance (mci_instance)
call mci_instance%init (mci)
allocate (test_sampler_1_t :: sampler)
select type (sampler)
type is (test_sampler_1_t)
sampler%mode = 2
end select
call sampler%write (u)
write (u, "(A)")
write (u, "(A)") "* Integrate with n_it = 3 and n_calls = 100"
write (u, "(A)")
select type (mci)
type is (mci_vamp2_t)
call mci%add_pass (adapt_grids = .false.)
end select
call mci%integrate (mci_instance, sampler, 3, 1000, pacify = .true.)
call mci%write (u, pacify = .true.)
write (u, "(A)")
write (u, "(A)") "* Contents of mci_instance:"
write (u, "(A)")
call mci_instance%write (u, pacify = .true.)
write (u, "(A)")
write (u, "(A)") "* Dump channel weights and grids to file"
write (u, "(A)")
mci%md5sum = "1234567890abcdef1234567890abcdef"
select type (mci)
type is (mci_vamp2_t)
call mci%write_grids ()
end select
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call mci_instance%final ()
call mci%final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: mci_vamp2_2"
end subroutine mci_vamp2_2
@ %def mci_vamp2_2
@
\subsubsection{Grid adaptation}
Construct an integrator and use it for a one-dimensional sampler.
Integrate with three iterations and in-between grid adaptations.
<<MCI vamp2: execute tests>>=
call test (mci_vamp2_3, "mci_vamp2_3", &
"grid adaptation", &
u, results)
<<MCI vamp2: test declarations>>=
public :: mci_vamp2_3
<<MCI vamp2: tests>>=
subroutine mci_vamp2_3 (u)
integer, intent(in) :: u
type(mci_vamp2_config_t) :: config
class(mci_t), allocatable, target :: mci
class(mci_instance_t), pointer :: mci_instance => null ()
class(mci_sampler_t), allocatable :: sampler
class(rng_t), allocatable :: rng
type(string_t) :: filename
write (u, "(A)") "* Test output: mci_vamp2_3"
write (u, "(A)") "* Purpose: integrate function in one dimension &
&(single channel)"
write (u, "(A)") "* and adapt grid"
write (u, "(A)")
write (u, "(A)") "* Initialize integrator, sampler, instance"
write (u, "(A)")
allocate (mci_vamp2_t :: mci)
call mci%set_dimensions (1, 1)
filename = "mci_vamp2_3"
select type (mci)
type is (mci_vamp2_t)
call mci%set_grid_filename (filename)
call mci%set_config (config)
end select
allocate (rng_stream_t :: rng)
call rng%init ()
call mci%import_rng (rng)
call mci%allocate_instance (mci_instance)
call mci_instance%init (mci)
allocate (test_sampler_1_t :: sampler)
select type (sampler)
type is (test_sampler_1_t)
sampler%mode = 2
end select
call sampler%write (u)
write (u, "(A)")
write (u, "(A)") "* Integrate with n_it = 3 and n_calls = 100"
write (u, "(A)")
select type (mci)
type is (mci_vamp2_t)
call mci%add_pass (adapt_grids = .true.)
end select
call mci%integrate (mci_instance, sampler, 3, 1000, pacify = .true.)
call mci%write (u, pacify = .true.)
write (u, "(A)")
write (u, "(A)") "* Contents of mci_instance:"
write (u, "(A)")
call mci_instance%write (u, pacify = .true.)
write (u, "(A)")
write (u, "(A)") "* Dump channel weights and grids to file"
write (u, "(A)")
mci%md5sum = "1234567890abcdef1234567890abcdef"
select type (mci)
type is (mci_vamp2_t)
call mci%write_grids ()
end select
write (u, "(A)")
write (u, "(A)") "* Cleanup"
write (u, "(A)")
call mci_instance%final ()
call mci%final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: mci_vamp2_3"
end subroutine mci_vamp2_3
@ %def mci_vamp2_3
@
\section{Dispatch}
@
<<[[dispatch_mci.f90]]>>=
<<File header>>
module dispatch_mci
<<Use strings>>
use diagnostics
use os_interface
use variables
use mci_base
use mci_none
use mci_midpoint
use mci_vamp
use mci_vamp2
<<Standard module head>>
<<Dispatch mci: public>>
<<Dispatch mci: parameters>>
contains
<<Dispatch mci: procedures>>
end module dispatch_mci
@ %def dispatch_mci
@
Allocate an integrator according to the variable [[$integration_method]].
<<Dispatch mci: public>>=
public :: dispatch_mci_s
<<Dispatch mci: procedures>>=
subroutine dispatch_mci_s (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
type(string_t) :: run_id
type(string_t) :: integration_method
type(grid_parameters_t) :: grid_par
type(history_parameters_t) :: history_par
type(mci_vamp2_config_t) :: mci_vamp2_config
logical :: rebuild_grids, check_grid_file, negative_weights, verbose
logical :: dispatch_nlo, binary_grid_format
type(string_t) :: grid_path
dispatch_nlo = .false.; if (present (is_nlo)) dispatch_nlo = is_nlo
integration_method = &
var_list%get_sval (var_str ("$integration_method"))
select case (char (integration_method))
case ("none")
allocate (mci_none_t :: mci)
case ("midpoint")
allocate (mci_midpoint_t :: mci)
case ("vamp", "default")
call unpack_options_vamp ()
allocate (mci_vamp_t :: mci)
select type (mci)
type is (mci_vamp_t)
call mci%set_grid_parameters (grid_par)
if (run_id /= "") then
call mci%set_grid_filename (process_id, run_id)
else
call mci%set_grid_filename (process_id)
end if
grid_path = var_list%get_sval (var_str ("$integrate_workspace"))
if (grid_path /= "") then
call setup_grid_path (grid_path)
call mci%prepend_grid_path (grid_path)
end if
call mci%set_history_parameters (history_par)
call mci%set_rebuild_flag (rebuild_grids, check_grid_file)
mci%negative_weights = negative_weights
mci%verbose = verbose
end select
case ("vamp2")
call unpack_options_vamp2 ()
allocate (mci_vamp2_t :: mci)
select type (mci)
type is (mci_vamp2_t)
call mci%set_config (mci_vamp2_config)
if (run_id /= "") then
call mci%set_grid_filename (process_id, run_id)
else
call mci%set_grid_filename (process_id)
end if
grid_path = var_list%get_sval (var_str ("$integrate_workspace"))
if (grid_path /= "") then
call setup_grid_path (grid_path)
call mci%prepend_grid_path (grid_path)
end if
call mci%set_rebuild_flag (rebuild_grids, check_grid_file)
mci%negative_weights = negative_weights
mci%verbose = verbose
mci%binary_grid_format = binary_grid_format
end select
case default
call msg_fatal ("Integrator '" &
// char (integration_method) // "' not implemented")
end select
contains
<<Dispatch mci s: procedures>>
end subroutine dispatch_mci_s
@ %def dispatch_mci_s
@
<<Dispatch mci s: procedures>>=
subroutine unpack_options_vamp ()
grid_par%threshold_calls = &
var_list%get_ival (var_str ("threshold_calls"))
grid_par%min_calls_per_channel = &
var_list%get_ival (var_str ("min_calls_per_channel"))
grid_par%min_calls_per_bin = &
var_list%get_ival (var_str ("min_calls_per_bin"))
grid_par%min_bins = &
var_list%get_ival (var_str ("min_bins"))
grid_par%max_bins = &
var_list%get_ival (var_str ("max_bins"))
grid_par%stratified = &
var_list%get_lval (var_str ("?stratified"))
select case (char (var_list%get_sval (var_str ("$phs_method"))))
- case default
- if (.not. dispatch_nlo) then
- grid_par%use_vamp_equivalences = &
- var_list%get_lval (var_str ("?use_vamp_equivalences"))
- else
- grid_par%use_vamp_equivalences = .false.
- end if
case ("rambo")
grid_par%use_vamp_equivalences = .false.
+ case default
+ grid_par%use_vamp_equivalences = &
+ var_list%get_lval (var_str ("?use_vamp_equivalences"))
end select
grid_par%channel_weights_power = &
var_list%get_rval (var_str ("channel_weights_power"))
grid_par%accuracy_goal = &
var_list%get_rval (var_str ("accuracy_goal"))
grid_par%error_goal = &
var_list%get_rval (var_str ("error_goal"))
grid_par%rel_error_goal = &
var_list%get_rval (var_str ("relative_error_goal"))
history_par%global = &
var_list%get_lval (var_str ("?vamp_history_global"))
history_par%global_verbose = &
var_list%get_lval (var_str ("?vamp_history_global_verbose"))
history_par%channel = &
var_list%get_lval (var_str ("?vamp_history_channels"))
history_par%channel_verbose = &
var_list%get_lval (var_str ("?vamp_history_channels_verbose"))
verbose = &
var_list%get_lval (var_str ("?vamp_verbose"))
check_grid_file = &
var_list%get_lval (var_str ("?check_grid_file"))
run_id = &
var_list%get_sval (var_str ("$run_id"))
rebuild_grids = &
var_list%get_lval (var_str ("?rebuild_grids"))
negative_weights = &
var_list%get_lval (var_str ("?negative_weights")) .or. dispatch_nlo
end subroutine unpack_options_vamp
subroutine unpack_options_vamp2 ()
mci_vamp2_config%n_bins_max = &
var_list%get_ival (var_str ("max_bins"))
mci_vamp2_config%n_calls_min_per_channel = &
var_list%get_ival (var_str ("min_calls_per_channel"))
mci_vamp2_config%n_calls_threshold = &
var_list%get_ival (var_str ("threshold_calls"))
mci_vamp2_config%beta = &
var_list%get_rval (var_str ("channel_weights_power"))
mci_vamp2_config%stratified = &
var_list%get_lval (var_str ("?stratified"))
select case (char (var_list%get_sval (var_str ("$phs_method"))))
- case default
- if (.not. dispatch_nlo) then
- mci_vamp2_config%equivalences = &
- var_list%get_lval (var_str ("?use_vamp_equivalences"))
- else
- mci_vamp2_config%equivalences = .false.
- end if
case ("rambo")
mci_vamp2_config%equivalences = .false.
+ case default
+ mci_vamp2_config%equivalences = &
+ var_list%get_lval (var_str ("?use_vamp_equivalences"))
end select
mci_vamp2_config%accuracy_goal = &
var_list%get_rval (var_str ("accuracy_goal"))
mci_vamp2_config%error_goal = &
var_list%get_rval (var_str ("error_goal"))
mci_vamp2_config%rel_error_goal = &
var_list%get_rval (var_str ("relative_error_goal"))
verbose = &
var_list%get_lval (var_str ("?vamp_verbose"))
check_grid_file = &
var_list%get_lval (var_str ("?check_grid_file"))
run_id = &
var_list%get_sval (var_str ("$run_id"))
rebuild_grids = &
var_list%get_lval (var_str ("?rebuild_grids"))
negative_weights = &
var_list%get_lval (var_str ("?negative_weights")) .or. dispatch_nlo
select case (char (var_list%get_sval (var_str ("$vamp_grid_format"))))
case ("binary","Binary","BINARY")
binary_grid_format = .true.
case ("ascii","Ascii","ASCII")
binary_grid_format = .false.
case default
binary_grid_format = .false.
end select
end subroutine unpack_options_vamp2
@
@ Make sure that the VAMP grid subdirectory, if requested, exists before it is
used. Also include a sanity check on the directory name.
<<Dispatch mci: parameters>>=
character(*), parameter :: ALLOWED_IN_DIRNAME = &
"abcdefghijklmnopqrstuvwxyz&
&ABCDEFGHIJKLMNOPQRSTUVWXYZ&
&1234567890&
&.,_-+="
@ %def ALLOWED_IN_DIRNAME
<<Dispatch mci: public>>=
public :: setup_grid_path
<<Dispatch mci: procedures>>=
subroutine setup_grid_path (grid_path)
type(string_t), intent(in) :: grid_path
if (verify (grid_path, ALLOWED_IN_DIRNAME) == 0) then
call msg_message ("Integrator: preparing VAMP grid directory '" &
// char (grid_path) // "'")
call os_system_call ("mkdir -p '" // grid_path // "'")
else
call msg_fatal ("Integrator: VAMP grid_path '" &
// char (grid_path) // "' contains illegal characters")
end if
end subroutine setup_grid_path
@ %def setup_grid_path
@
\subsection{Unit tests}
Test module, followed by the corresponding implementation module.
<<[[dispatch_mci_ut.f90]]>>=
<<File header>>
module dispatch_mci_ut
use unit_tests
use dispatch_mci_uti
<<Standard module head>>
<<Dispatch mci: public test>>
contains
<<Dispatch mci: test driver>>
end module dispatch_mci_ut
@ %def dispatch_mci_ut
@
<<[[dispatch_mci_uti.f90]]>>=
<<File header>>
module dispatch_mci_uti
<<Use kinds>>
<<Use strings>>
use variables
use mci_base
use mci_none
use mci_midpoint
use mci_vamp
use dispatch_mci
<<Standard module head>>
<<Dispatch mci: test declarations>>
contains
<<Dispatch mci: tests>>
end module dispatch_mci_uti
@ %def dispatch_mci_ut
@ API: driver for the unit tests below.
<<Dispatch mci: public test>>=
public ::dispatch_mci_test
<<Dispatch mci: test driver>>=
subroutine dispatch_mci_test (u, results)
integer, intent(in) :: u
type(test_results_t), intent(inout) :: results
<<Dispatch mci: execute tests>>
end subroutine dispatch_mci_test
@ %def dispatch_mci_test
@
\subsubsection{Select type: integrator core}
<<Dispatch mci: execute tests>>=
call test (dispatch_mci_1, "dispatch_mci_1", &
"integration method", &
u, results)
<<Dispatch mci: test declarations>>=
public :: dispatch_mci_1
<<Dispatch mci: tests>>=
subroutine dispatch_mci_1 (u)
integer, intent(in) :: u
type(var_list_t) :: var_list
class(mci_t), allocatable :: mci
type(string_t) :: process_id
write (u, "(A)") "* Test output: dispatch_mci_1"
write (u, "(A)") "* Purpose: select integration method"
write (u, "(A)")
call var_list%init_defaults (0)
process_id = "dispatch_mci_1"
write (u, "(A)") "* Allocate MCI as none_t"
write (u, "(A)")
call var_list%set_string (&
var_str ("$integration_method"), &
var_str ("none"), is_known = .true.)
call dispatch_mci_s (mci, var_list, process_id)
select type (mci)
type is (mci_none_t)
call mci%write (u)
end select
call mci%final ()
deallocate (mci)
write (u, "(A)")
write (u, "(A)") "* Allocate MCI as midpoint_t"
write (u, "(A)")
call var_list%set_string (&
var_str ("$integration_method"), &
var_str ("midpoint"), is_known = .true.)
call dispatch_mci_s (mci, var_list, process_id)
select type (mci)
type is (mci_midpoint_t)
call mci%write (u)
end select
call mci%final ()
deallocate (mci)
write (u, "(A)")
write (u, "(A)") "* Allocate MCI as vamp_t"
write (u, "(A)")
call var_list%set_string (&
var_str ("$integration_method"), &
var_str ("vamp"), is_known = .true.)
call var_list%set_int (var_str ("threshold_calls"), &
1, is_known = .true.)
call var_list%set_int (var_str ("min_calls_per_channel"), &
2, is_known = .true.)
call var_list%set_int (var_str ("min_calls_per_bin"), &
3, is_known = .true.)
call var_list%set_int (var_str ("min_bins"), &
4, is_known = .true.)
call var_list%set_int (var_str ("max_bins"), &
5, is_known = .true.)
call var_list%set_log (var_str ("?stratified"), &
.false., is_known = .true.)
call var_list%set_log (var_str ("?use_vamp_equivalences"),&
.false., is_known = .true.)
call var_list%set_real (var_str ("channel_weights_power"),&
4._default, is_known = .true.)
call var_list%set_log (&
var_str ("?vamp_history_global_verbose"), &
.true., is_known = .true.)
call var_list%set_log (&
var_str ("?vamp_history_channels"), &
.true., is_known = .true.)
call var_list%set_log (&
var_str ("?vamp_history_channels_verbose"), &
.true., is_known = .true.)
call var_list%set_log (var_str ("?stratified"), &
.false., is_known = .true.)
call dispatch_mci_s (mci, var_list, process_id)
select type (mci)
type is (mci_vamp_t)
call mci%write (u)
call mci%write_history_parameters (u)
end select
call mci%final ()
deallocate (mci)
write (u, "(A)")
write (u, "(A)") "* Allocate MCI as vamp_t, allow for negative weights"
write (u, "(A)")
call var_list%set_string (&
var_str ("$integration_method"), &
var_str ("vamp"), is_known = .true.)
call var_list%set_log (var_str ("?negative_weights"), &
.true., is_known = .true.)
call dispatch_mci_s (mci, var_list, process_id)
select type (mci)
type is (mci_vamp_t)
call mci%write (u)
call mci%write_history_parameters (u)
end select
call mci%final ()
deallocate (mci)
call var_list%final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: dispatch_mci_1"
end subroutine dispatch_mci_1
@ %def dispatch_mci_1
Index: trunk/src/phase_space/phase_space.nw
===================================================================
--- trunk/src/phase_space/phase_space.nw (revision 8482)
+++ trunk/src/phase_space/phase_space.nw (revision 8483)
@@ -1,27691 +1,27696 @@
% -*- ess-noweb-default-code-mode: f90-mode; noweb-default-code-mode: f90-mode; -*-
% WHIZARD code as NOWEB source: phase space
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\chapter{Phase Space}
\includemodulegraph{phase_space}
The abstract representation of a type that parameterizes phase space,
with methods for construction and evaluation.
\begin{description}
\item[phs\_base]
Abstract phase-space representation.
\end{description}
A simple implementation:
\begin{description}
\item[phs\_none]
This implements a non-functional dummy module for the phase space.
A process which uses this module cannot be integrated. The purpose
of this module is to provide a placeholder for processes which do
not require phase-space evaluation. They may still allow for evaluating
matrix elements.
\item[phs\_single]
Parameterize the phase space of a single particle, i.e., the solid
angle. This is useful only for very restricted problems, but it
avoids the complexity of a generic approach in those trivial cases.
\end{description}
The standard implementation is called \emph{wood} phase space. It
consists of several auxiliary modules and the actual implementation
module.
\begin{description}
\item[mappings]
Generate invariant masses and decay angles from given
random numbers (or the inverse operation). Each mapping pertains to a
particular node in a phase-space tree. Different mappings account for
uniform distributions, resonances, zero-mass behavior, and so on.
\item[phs\_trees]
Phase space parameterizations for scattering
processes are defined recursively as if there was an initial particle
decaying. This module sets up a representation in terms of abstract
trees, where each node gets a unique binary number. Each tree is
stored as an array of branches, where integers indicate the
connections. This emulates pointers in a transparent way. Real
pointers would also be possible, but seem to be less efficient for
this particular case.
\item[phs\_forests]
The type defined by this module collects the
decay trees corresponding to a given process and the applicable
mappings. To set this up, a file is read which is either written by
the user or by the \textbf{cascades} module functions. The module
also contains the routines that evaluate phase space, i.e., generate
momenta from random numbers and back.
\item[cascades]
This module is a pseudo Feynman diagram generator with the
particular purpose of finding the phase space parameterizations best
suited for a given process. It uses a model file to set up the
possible vertices, generates all possible diagrams, identifies
resonances and singularities, and simplifies the list by merging
equivalent diagrams and dropping irrelevant ones. This process can be
controlled at several points by user-defined parameters. Note that it
depends on the particular values of particle masses, so it cannot be
done before reading the input file.
\item[phs\_wood]
Make the functionality available in form of an implementation of the
abstract phase-space type.
\item[phs\_fks]
Phase-space parameterization with modifications for the FKS scheme.
\end{description}
\clearpage
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{Abstract phase-space module}
In this module we define an abstract base type (and a trivial test
implementation) for multi-channel phase-space parameterizations.
<<[[phs_base.f90]]>>=
<<File header>>
module phs_base
<<Use kinds>>
<<Use strings>>
use io_units
use constants, only: TWOPI, TWOPI4
use string_utils, only: split_string
use format_defs, only: FMT_19
use numeric_utils
use diagnostics
use md5
use physics_defs
use lorentz
use model_data
use flavors
use process_constants
<<Standard module head>>
<<PHS base: public>>
<<PHS base: types>>
<<PHS base: interfaces>>
contains
<<PHS base: procedures>>
end module phs_base
@ %def phs_base
@
\subsection{Phase-space channels}
The kinematics configuration may generate multiple parameterizations of phase
space. Some of those have specific properties, such as a resonance in the s
channel.
\subsubsection{Channel properties}
This is the abstract type for the channel properties. We need them as
a data transfer container, so everything is public and transparent.
<<PHS base: public>>=
public :: channel_prop_t
<<PHS base: types>>=
type, abstract :: channel_prop_t
contains
procedure (channel_prop_to_string), deferred :: to_string
generic :: operator (==) => is_equal
procedure (channel_eq), deferred :: is_equal
end type channel_prop_t
@ %def channel_prop_t
<<PHS base: interfaces>>=
abstract interface
function channel_prop_to_string (object) result (string)
import
class(channel_prop_t), intent(in) :: object
type(string_t) :: string
end function channel_prop_to_string
end interface
@ %def channel_prop_to_string
<<PHS base: interfaces>>=
abstract interface
function channel_eq (prop1, prop2) result (flag)
import
class(channel_prop_t), intent(in) :: prop1, prop2
logical :: flag
end function channel_eq
end interface
@ %def channel_prop_to_string
@
Here is a resonance as a channel property. Mass and width are stored
here in physical units.
<<PHS base: public>>=
public :: resonance_t
<<PHS base: types>>=
type, extends (channel_prop_t) :: resonance_t
real(default) :: mass = 0
real(default) :: width = 0
contains
procedure :: to_string => resonance_to_string
procedure :: is_equal => resonance_is_equal
end type resonance_t
@ %def resonance_t
@ Print mass and width.
<<PHS base: procedures>>=
function resonance_to_string (object) result (string)
class(resonance_t), intent(in) :: object
type(string_t) :: string
character(32) :: buffer
string = "resonant: m ="
write (buffer, "(" // FMT_19 // ")") object%mass
string = string // trim (buffer) // " GeV, w ="
write (buffer, "(" // FMT_19 // ")") object%width
string = string // trim (buffer) // " GeV"
end function resonance_to_string
@ %def resonance_to_string
@ Equality.
<<PHS base: procedures>>=
function resonance_is_equal (prop1, prop2) result (flag)
class(resonance_t), intent(in) :: prop1
class(channel_prop_t), intent(in) :: prop2
logical :: flag
select type (prop2)
type is (resonance_t)
flag = prop1%mass == prop2%mass .and. prop1%width == prop2%width
class default
flag = .false.
end select
end function resonance_is_equal
@ %def resonance_is_equal
@
This is the limiting case of a resonance, namely an on-shell particle.
We just store the mass in physical units.
<<PHS base: public>>=
public :: on_shell_t
<<PHS base: types>>=
type, extends (channel_prop_t) :: on_shell_t
real(default) :: mass = 0
contains
procedure :: to_string => on_shell_to_string
procedure :: is_equal => on_shell_is_equal
end type on_shell_t
@ %def on_shell_t
@ Print mass and width.
<<PHS base: procedures>>=
function on_shell_to_string (object) result (string)
class(on_shell_t), intent(in) :: object
type(string_t) :: string
character(32) :: buffer
string = "on shell: m ="
write (buffer, "(" // FMT_19 // ")") object%mass
string = string // trim (buffer) // " GeV"
end function on_shell_to_string
@ %def on_shell_to_string
@ Equality.
<<PHS base: procedures>>=
function on_shell_is_equal (prop1, prop2) result (flag)
class(on_shell_t), intent(in) :: prop1
class(channel_prop_t), intent(in) :: prop2
logical :: flag
select type (prop2)
type is (on_shell_t)
flag = prop1%mass == prop2%mass
class default
flag = .false.
end select
end function on_shell_is_equal
@ %def on_shell_is_equal
@
\subsubsection{Channel equivalences}
This type describes an equivalence. The current channel is equivalent
to channel [[c]]. The equivalence involves a permutation [[perm]] of
integration dimensions and, within each integration dimension, a
mapping [[mode]].
<<PHS base: types>>=
type :: phs_equivalence_t
integer :: c = 0
integer, dimension(:), allocatable :: perm
integer, dimension(:), allocatable :: mode
contains
<<PHS base: phs equivalence: TBP>>
end type phs_equivalence_t
@ %def phs_equivalence_t
@
The mapping modes are
<<PHS base: types>>=
integer, parameter, public :: &
EQ_IDENTITY = 0, EQ_INVERT = 1, EQ_SYMMETRIC = 2, EQ_INVARIANT = 3
@ %def EQ_IDENTITY EQ_INVERT EQ_SYMMETRIC
@ In particular, if a channel is equivalent to itself in the
[[EQ_SYMMETRIC]] mode, the integrand can be assumed to be symmetric
w.r.t.\ a reflection $x\to 1 - x$ of the correponding integration variable.
These are the associated tags, for output:
<<PHS base: types>>=
character, dimension(0:3), parameter :: TAG = ["+", "-", ":", "x"]
@ %def TAG
@ Write an equivalence.
<<PHS base: phs equivalence: TBP>>=
procedure :: write => phs_equivalence_write
<<PHS base: procedures>>=
subroutine phs_equivalence_write (object, unit)
class(phs_equivalence_t), intent(in) :: object
integer, intent(in), optional :: unit
integer :: u, j
u = given_output_unit (unit)
write (u, "(5x,'=',1x,I0,1x)", advance = "no") object%c
if (allocated (object%perm)) then
write (u, "(A)", advance = "no") "("
do j = 1, size (object%perm)
if (j > 1) write (u, "(1x)", advance = "no")
write (u, "(I0,A1)", advance = "no") &
object%perm(j), TAG(object%mode(j))
end do
write (u, "(A)") ")"
else
write (u, "(A)")
end if
end subroutine phs_equivalence_write
@ %def phs_equivalence_write
@ Initialize an equivalence. This allocates the [[perm]] and [[mode]]
arrays with equal size.
<<PHS base: phs equivalence: TBP>>=
procedure :: init => phs_equivalence_init
<<PHS base: procedures>>=
subroutine phs_equivalence_init (eq, n_dim)
class(phs_equivalence_t), intent(out) :: eq
integer, intent(in) :: n_dim
allocate (eq%perm (n_dim), source = 0)
allocate (eq%mode (n_dim), source = EQ_IDENTITY)
end subroutine phs_equivalence_init
@ %def phs_equivalence_init
@
\subsubsection{Channel objects}
The channel entry holds (optionally) specific properties.
[[sf_channel]] is the structure-function channel that corresponds to this
phase-space channel. The structure-function channel may be set up with a
specific mapping that depends on the phase-space channel properties. (The
default setting is to leave the properties empty.)
<<PHS base: public>>=
public :: phs_channel_t
<<PHS base: types>>=
type :: phs_channel_t
class(channel_prop_t), allocatable :: prop
integer :: sf_channel = 1
type(phs_equivalence_t), dimension(:), allocatable :: eq
contains
<<PHS base: phs channel: TBP>>
end type phs_channel_t
@ %def phs_channel_t
@ Output.
<<PHS base: phs channel: TBP>>=
procedure :: write => phs_channel_write
<<PHS base: procedures>>=
subroutine phs_channel_write (object, unit)
class(phs_channel_t), intent(in) :: object
integer, intent(in), optional :: unit
integer :: u, j
u = given_output_unit (unit)
write (u, "(1x,I0)", advance="no") object%sf_channel
if (allocated (object%prop)) then
write (u, "(1x,A)") char (object%prop%to_string ())
else
write (u, *)
end if
if (allocated (object%eq)) then
do j = 1, size (object%eq)
call object%eq(j)%write (u)
end do
end if
end subroutine phs_channel_write
@ %def phs_channel_write
@ Identify the channel with an s-channel resonance.
<<PHS base: phs channel: TBP>>=
procedure :: set_resonant => channel_set_resonant
<<PHS base: procedures>>=
subroutine channel_set_resonant (channel, mass, width)
class(phs_channel_t), intent(inout) :: channel
real(default), intent(in) :: mass, width
allocate (resonance_t :: channel%prop)
select type (prop => channel%prop)
type is (resonance_t)
prop%mass = mass
prop%width = width
end select
end subroutine channel_set_resonant
@ %def channel_set_resonant
@ Identify the channel with an on-shell particle.
<<PHS base: phs channel: TBP>>=
procedure :: set_on_shell => channel_set_on_shell
<<PHS base: procedures>>=
subroutine channel_set_on_shell (channel, mass)
class(phs_channel_t), intent(inout) :: channel
real(default), intent(in) :: mass
allocate (on_shell_t :: channel%prop)
select type (prop => channel%prop)
type is (on_shell_t)
prop%mass = mass
end select
end subroutine channel_set_on_shell
@ %def channel_set_on_shell
@
\subsection{Property collection}
We can set up a list of all distinct channel properties for a given
set of channels.
<<PHS base: public>>=
public :: phs_channel_collection_t
<<PHS base: types>>=
type :: prop_entry_t
integer :: i = 0
class(channel_prop_t), allocatable :: prop
type(prop_entry_t), pointer :: next => null ()
end type prop_entry_t
type :: phs_channel_collection_t
integer :: n = 0
type(prop_entry_t), pointer :: first => null ()
contains
<<PHS base: phs channel collection: TBP>>
end type phs_channel_collection_t
@ %def prop_entry_t
@ %def phs_channel_collection_t
@ Finalizer for the list.
<<PHS base: phs channel collection: TBP>>=
procedure :: final => phs_channel_collection_final
<<PHS base: procedures>>=
subroutine phs_channel_collection_final (object)
class(phs_channel_collection_t), intent(inout) :: object
type(prop_entry_t), pointer :: entry
do while (associated (object%first))
entry => object%first
object%first => entry%next
deallocate (entry)
end do
end subroutine phs_channel_collection_final
@ %def phs_channel_collection_final
@ Output.
<<PHS base: phs channel collection: TBP>>=
procedure :: write => phs_channel_collection_write
<<PHS base: procedures>>=
subroutine phs_channel_collection_write (object, unit)
class(phs_channel_collection_t), intent(in) :: object
integer, intent(in), optional :: unit
type(prop_entry_t), pointer :: entry
integer :: u
u = given_output_unit (unit)
entry => object%first
do while (associated (entry))
if (allocated (entry%prop)) then
write (u, "(1x,I0,1x,A)") entry%i, char (entry%prop%to_string ())
else
write (u, "(1x,I0)") entry%i
end if
entry => entry%next
end do
end subroutine phs_channel_collection_write
@ %def phs_channel_collection_write
@ Push a new property to the stack if it is not yet included.
Simultaneously, set the [[sf_channel]] entry in the phase-space
channel object to the index of the matching entry, or the new entry if
there was no match.
<<PHS base: phs channel collection: TBP>>=
procedure :: push => phs_channel_collection_push
<<PHS base: procedures>>=
subroutine phs_channel_collection_push (coll, channel)
class(phs_channel_collection_t), intent(inout) :: coll
type(phs_channel_t), intent(inout) :: channel
type(prop_entry_t), pointer :: entry, new
if (associated (coll%first)) then
entry => coll%first
do
if (allocated (entry%prop)) then
if (allocated (channel%prop)) then
if (entry%prop == channel%prop) then
channel%sf_channel = entry%i
return
end if
end if
else if (.not. allocated (channel%prop)) then
channel%sf_channel = entry%i
return
end if
if (associated (entry%next)) then
entry => entry%next
else
exit
end if
end do
allocate (new)
entry%next => new
else
allocate (new)
coll%first => new
end if
coll%n = coll%n + 1
new%i = coll%n
channel%sf_channel = new%i
if (allocated (channel%prop)) then
allocate (new%prop, source = channel%prop)
end if
end subroutine phs_channel_collection_push
@ %def phs_channel_collection_push
@ Return the number of collected distinct channels.
<<PHS base: phs channel collection: TBP>>=
procedure :: get_n => phs_channel_collection_get_n
<<PHS base: procedures>>=
function phs_channel_collection_get_n (coll) result (n)
class(phs_channel_collection_t), intent(in) :: coll
integer :: n
n = coll%n
end function phs_channel_collection_get_n
@ %def phs_channel_collection_get_n
@ Return a specific channel (property object).
<<PHS base: phs channel collection: TBP>>=
procedure :: get_entry => phs_channel_collection_get_entry
<<PHS base: procedures>>=
subroutine phs_channel_collection_get_entry (coll, i, prop)
class(phs_channel_collection_t), intent(in) :: coll
integer, intent(in) :: i
class(channel_prop_t), intent(out), allocatable :: prop
type(prop_entry_t), pointer :: entry
integer :: k
if (i > 0 .and. i <= coll%n) then
entry => coll%first
do k = 2, i
entry => entry%next
end do
if (allocated (entry%prop)) then
if (allocated (prop)) deallocate (prop)
allocate (prop, source = entry%prop)
end if
else
call msg_bug ("PHS channel collection: get entry: illegal index")
end if
end subroutine phs_channel_collection_get_entry
@ %def phs_channel_collection_get_entry
@
\subsection{Kinematics configuration}
Here, we store the universal information that is specifically relevant
for phase-space generation. It is a subset of the process data,
supplemented by basic information on phase-space parameterization
channels.
A concrete implementation will contain more data, that describe the
phase space in detail.
MD5 sums: the phase space setup depends on the process, it depends on
the model parameters (the masses, that is), and on the configuration
parameters. (It does not depend on the QCD setup.)
<<PHS base: public>>=
public :: phs_config_t
<<PHS base: types>>=
type, abstract :: phs_config_t
! private
type(string_t) :: id
integer :: n_in = 0
integer :: n_out = 0
integer :: n_tot = 0
integer :: n_state = 0
integer :: n_par = 0
integer :: n_channel = 0
real(default) :: sqrts = 0
logical :: sqrts_fixed = .true.
logical :: lab_is_cm = .true.
logical :: azimuthal_dependence = .false.
integer, dimension(:), allocatable :: dim_flat
logical :: provides_equivalences = .false.
logical :: provides_chains = .false.
logical :: vis_channels = .false.
integer, dimension(:), allocatable :: chain
class(model_data_t), pointer :: model => null ()
type(flavor_t), dimension(:,:), allocatable :: flv
type(phs_channel_t), dimension(:), allocatable :: channel
character(32) :: md5sum_process = ""
character(32) :: md5sum_model_par = ""
character(32) :: md5sum_phs_config = ""
integer :: nlo_type
contains
<<PHS base: phs config: TBP>>
end type phs_config_t
@ %def phs_config_t
@ Finalizer, deferred.
<<PHS base: phs config: TBP>>=
procedure (phs_config_final), deferred :: final
<<PHS base: interfaces>>=
abstract interface
subroutine phs_config_final (object)
import
class(phs_config_t), intent(inout) :: object
end subroutine phs_config_final
end interface
@ %def phs_config_final
@ Output. We provide an implementation for the output of the base-type
contents and an interface for the actual write method.
<<PHS base: phs config: TBP>>=
procedure (phs_config_write), deferred :: write
procedure :: base_write => phs_config_write
<<PHS base: procedures>>=
subroutine phs_config_write (object, unit, include_id)
class(phs_config_t), intent(in) :: object
integer, intent(in), optional :: unit
logical, intent(in), optional :: include_id
integer :: u, i, j
integer :: n_tot_flv
logical :: use_id
n_tot_flv = object%n_tot
u = given_output_unit (unit)
use_id = .true.; if (present (include_id)) use_id = include_id
if (use_id) write (u, "(3x,A,A,A)") "ID = '", char (object%id), "'"
write (u, "(3x,A,I0)") "n_in = ", object%n_in
write (u, "(3x,A,I0)") "n_out = ", object%n_out
write (u, "(3x,A,I0)") "n_tot = ", object%n_tot
write (u, "(3x,A,I0)") "n_state = ", object%n_state
write (u, "(3x,A,I0)") "n_par = ", object%n_par
write (u, "(3x,A,I0)") "n_channel = ", object%n_channel
write (u, "(3x,A," // FMT_19 // ")") "sqrts = ", object%sqrts
write (u, "(3x,A,L1)") "s_fixed = ", object%sqrts_fixed
write (u, "(3x,A,L1)") "lab_is_cm = ", object%lab_is_cm
write (u, "(3x,A,L1)") "azim.dep. = ", object%azimuthal_dependence
if (allocated (object%dim_flat)) then
write (u, "(3x,A,I0)") "flat dim. = ", object%dim_flat
end if
write (u, "(1x,A)") "Flavor combinations:"
do i = 1, object%n_state
write (u, "(3x,I0,':')", advance="no") i
! do j = 1, object%n_tot
do j = 1, n_tot_flv
write (u, "(1x,A)", advance="no") char (object%flv(j,i)%get_name ())
end do
write (u, "(A)")
end do
if (allocated (object%channel)) then
write (u, "(1x,A)") "Phase-space / structure-function channels:"
do i = 1, object%n_channel
write (u, "(3x,I0,':')", advance="no") i
call object%channel(i)%write (u)
end do
end if
if (object%md5sum_process /= "") then
write (u, "(3x,A,A,A)") "MD5 sum (process) = '", &
object%md5sum_process, "'"
end if
if (object%md5sum_model_par /= "") then
write (u, "(3x,A,A,A)") "MD5 sum (model par) = '", &
object%md5sum_model_par, "'"
end if
if (object%md5sum_phs_config /= "") then
write (u, "(3x,A,A,A)") "MD5 sum (phs config) = '", &
object%md5sum_phs_config, "'"
end if
end subroutine phs_config_write
@ %def phs_config_write
@ Similarly, a basic initializer and an interface. The model pointer is taken
as an argument; we may verify that this has the expected model name.
The intent is [[inout]]. We want to be able to set parameters in advance.
<<PHS base: phs config: TBP>>=
procedure :: init => phs_config_init
<<PHS base: procedures>>=
subroutine phs_config_init (phs_config, data, model)
class(phs_config_t), intent(inout) :: phs_config
type(process_constants_t), intent(in) :: data
class(model_data_t), intent(in), target :: model
integer :: i, j
phs_config%id = data%id
phs_config%n_in = data%n_in
phs_config%n_out = data%n_out
phs_config%n_tot = data%n_in + data%n_out
phs_config%n_state = data%n_flv
if (data%model_name == model%get_name ()) then
phs_config%model => model
else
call msg_bug ("phs_config_init: model name mismatch")
end if
allocate (phs_config%flv (phs_config%n_tot, phs_config%n_state))
do i = 1, phs_config%n_state
do j = 1, phs_config%n_tot
call phs_config%flv(j,i)%init (data%flv_state(j,i), &
phs_config%model)
end do
end do
phs_config%md5sum_process = data%md5sum
end subroutine phs_config_init
@ %def phs_config_init
@
WK 2018-04-05: This procedure appears to be redundant?
<<XXX PHS base: phs config: TBP>>=
procedure :: set_component_index => phs_config_set_component_index
<<XXX PHS base: procedures>>=
subroutine phs_config_set_component_index (phs_config, index)
class(phs_config_t), intent(inout) :: phs_config
integer, intent(in) :: index
type(string_t), dimension(:), allocatable :: id
type(string_t) :: suffix
integer :: i, n
suffix = var_str ('i') // int2string (index)
call split_string (phs_config%id, var_str ('_'), id)
phs_config%id = var_str ('')
n = size (id) - 1
do i = 1, n
phs_config%id = phs_config%id // id(i) // var_str ('_')
end do
phs_config%id = phs_config%id // suffix
end subroutine phs_config_set_component_index
@ %def phs_config_set_component_index
@ This procedure should complete the phase-space configuration. We
need the [[sqrts]] value as overall scale, which is known only after
the beams have been defined. The procedure should determine the number of
channels, their properties (if any), and allocate and fill the [[channel]]
array accordingly.
<<PHS base: phs config: TBP>>=
procedure (phs_config_configure), deferred :: configure
<<PHS base: interfaces>>=
abstract interface
subroutine phs_config_configure (phs_config, sqrts, &
sqrts_fixed, lab_is_cm, azimuthal_dependence, rebuild, ignore_mismatch, &
nlo_type, subdir)
import
class(phs_config_t), intent(inout) :: phs_config
real(default), intent(in) :: sqrts
logical, intent(in), optional :: sqrts_fixed
logical, intent(in), optional :: lab_is_cm
logical, intent(in), optional :: azimuthal_dependence
logical, intent(in), optional :: rebuild
logical, intent(in), optional :: ignore_mismatch
integer, intent(in), optional :: nlo_type
type(string_t), intent(in), optional :: subdir
end subroutine phs_config_configure
end interface
@ %def phs_config_configure
@ Manually assign structure-function channel indices to the phase-space
channel objects. (Used by a test routine.)
<<PHS base: phs config: TBP>>=
procedure :: set_sf_channel => phs_config_set_sf_channel
<<PHS base: procedures>>=
subroutine phs_config_set_sf_channel (phs_config, sf_channel)
class(phs_config_t), intent(inout) :: phs_config
integer, dimension(:), intent(in) :: sf_channel
phs_config%channel%sf_channel = sf_channel
end subroutine phs_config_set_sf_channel
@ %def phs_config_set_sf_channel
@ Collect new channels not yet in the collection from this phase-space
configuration object. At the same time, assign structure-function channels.
<<PHS base: phs config: TBP>>=
procedure :: collect_channels => phs_config_collect_channels
<<PHS base: procedures>>=
subroutine phs_config_collect_channels (phs_config, coll)
class(phs_config_t), intent(inout) :: phs_config
type(phs_channel_collection_t), intent(inout) :: coll
integer :: c
do c = 1, phs_config%n_channel
call coll%push (phs_config%channel(c))
end do
end subroutine phs_config_collect_channels
@ %def phs_config_collect_channels
@ Compute the MD5 sum. We abuse the [[write]] method. In
type implementations, [[write]] should only display information that is
relevant for the MD5 sum. The data include the process MD5 sum which is taken
from the process constants, and the MD5 sum of the model parameters. This may
change, so it is computed here.
<<PHS base: phs config: TBP>>=
procedure :: compute_md5sum => phs_config_compute_md5sum
<<PHS base: procedures>>=
subroutine phs_config_compute_md5sum (phs_config, include_id)
class(phs_config_t), intent(inout) :: phs_config
logical, intent(in), optional :: include_id
integer :: u
phs_config%md5sum_model_par = phs_config%model%get_parameters_md5sum ()
phs_config%md5sum_phs_config = ""
u = free_unit ()
open (u, status = "scratch", action = "readwrite")
call phs_config%write (u, include_id)
rewind (u)
phs_config%md5sum_phs_config = md5sum (u)
close (u)
end subroutine phs_config_compute_md5sum
@ %def phs_config_compute_md5sum
@ Print an informative message after phase-space configuration.
<<PHS base: phs config: TBP>>=
procedure (phs_startup_message), deferred :: startup_message
procedure :: base_startup_message => phs_startup_message
<<PHS base: procedures>>=
subroutine phs_startup_message (phs_config, unit)
class(phs_config_t), intent(in) :: phs_config
integer, intent(in), optional :: unit
write (msg_buffer, "(A,3(1x,I0,1x,A))") &
"Phase space:", &
phs_config%n_channel, "channels,", &
phs_config%n_par, "dimensions"
call msg_message (unit = unit)
end subroutine phs_startup_message
@ %def phs_startup_message
@ This procedure should be implemented such that the phase-space
configuration object allocates a phase-space instance of matching type.
<<PHS base: phs config: TBP>>=
procedure (phs_config_allocate_instance), nopass, deferred :: &
allocate_instance
<<PHS base: interfaces>>=
abstract interface
subroutine phs_config_allocate_instance (phs)
import
class(phs_t), intent(inout), pointer :: phs
end subroutine phs_config_allocate_instance
end interface
@ %def phs_config_allocate_instance
@
\subsection{Extract data}
Return the number of MC input parameters.
<<PHS base: phs config: TBP>>=
procedure :: get_n_par => phs_config_get_n_par
<<PHS base: procedures>>=
function phs_config_get_n_par (phs_config) result (n)
class(phs_config_t), intent(in) :: phs_config
integer :: n
n = phs_config%n_par
end function phs_config_get_n_par
@ %def phs_config_get_n_par
@ Return dimensions (parameter indices) for which the phase-space
dimension is flat, so integration and event generation can be simplified.
<<PHS base: phs config: TBP>>=
procedure :: get_flat_dimensions => phs_config_get_flat_dimensions
<<PHS base: procedures>>=
function phs_config_get_flat_dimensions (phs_config) result (dim_flat)
class(phs_config_t), intent(in) :: phs_config
integer, dimension(:), allocatable :: dim_flat
if (allocated (phs_config%dim_flat)) then
allocate (dim_flat (size (phs_config%dim_flat)))
dim_flat = phs_config%dim_flat
else
allocate (dim_flat (0))
end if
end function phs_config_get_flat_dimensions
@ %def phs_config_get_flat_dimensions
@ Return the number of phase-space channels.
<<PHS base: phs config: TBP>>=
procedure :: get_n_channel => phs_config_get_n_channel
<<PHS base: procedures>>=
function phs_config_get_n_channel (phs_config) result (n)
class(phs_config_t), intent(in) :: phs_config
integer :: n
n = phs_config%n_channel
end function phs_config_get_n_channel
@ %def phs_config_get_n_channel
@ Return the structure-function channel that corresponds to the
phase-space channel [[c]]. If the channel array is not allocated (which
happens if there is no structure function), return zero.
<<PHS base: phs config: TBP>>=
procedure :: get_sf_channel => phs_config_get_sf_channel
<<PHS base: procedures>>=
function phs_config_get_sf_channel (phs_config, c) result (c_sf)
class(phs_config_t), intent(in) :: phs_config
integer, intent(in) :: c
integer :: c_sf
if (allocated (phs_config%channel)) then
c_sf = phs_config%channel(c)%sf_channel
else
c_sf = 0
end if
end function phs_config_get_sf_channel
@ %def phs_config_get_sf_channel
@ Return the mass(es) of the incoming particle(s). We take the first flavor
combination in the array, assuming that masses must be degenerate among
flavors.
<<PHS base: phs config: TBP>>=
procedure :: get_masses_in => phs_config_get_masses_in
<<PHS base: procedures>>=
subroutine phs_config_get_masses_in (phs_config, m)
class(phs_config_t), intent(in) :: phs_config
real(default), dimension(:), intent(out) :: m
integer :: i
do i = 1, phs_config%n_in
m(i) = phs_config%flv(i,1)%get_mass ()
end do
end subroutine phs_config_get_masses_in
@ %def phs_config_get_masses_in
@ Return the MD5 sum of the configuration.
<<PHS base: phs config: TBP>>=
procedure :: get_md5sum => phs_config_get_md5sum
<<PHS base: procedures>>=
function phs_config_get_md5sum (phs_config) result (md5sum)
class(phs_config_t), intent(in) :: phs_config
character(32) :: md5sum
md5sum = phs_config%md5sum_phs_config
end function phs_config_get_md5sum
@ %def phs_config_get_md5sum
@
\subsection{Phase-space point instance}
The [[phs_t]] object holds the workspace for phase-space generation.
In the base object, we have the MC input parameters [[r]] and the
Jacobian factor [[f]], for each channel, and the incoming and outgoing
momenta.
Note: The [[active_channel]] array is not used yet, all elements are
initialized with [[.true.]]. It should be touched by the integrator if it
decides to drop irrelevant channels.
<<PHS base: public>>=
public :: phs_t
<<PHS base: types>>=
type, abstract :: phs_t
class(phs_config_t), pointer :: config => null ()
logical :: r_defined = .false.
integer :: selected_channel = 0
logical, dimension(:), allocatable :: active_channel
real(default), dimension(:,:), allocatable :: r
real(default), dimension(:), allocatable :: f
real(default), dimension(:), allocatable :: m_in
real(default), dimension(:), allocatable :: m_out
real(default) :: flux = 0
real(default) :: volume = 0
type(lorentz_transformation_t) :: lt_cm_to_lab
logical :: p_defined = .false.
real(default) :: sqrts_hat = 0
type(vector4_t), dimension(:), allocatable :: p
logical :: q_defined = .false.
type(vector4_t), dimension(:), allocatable :: q
contains
<<PHS base: phs: TBP>>
end type phs_t
@ %def phs_t
@ Output. Since phase space may get complicated, we include a
[[verbose]] option for the abstract [[write]] procedure.
<<PHS base: phs: TBP>>=
procedure (phs_write), deferred :: write
<<PHS base: interfaces>>=
abstract interface
subroutine phs_write (object, unit, verbose)
import
class(phs_t), intent(in) :: object
integer, intent(in), optional :: unit
logical, intent(in), optional :: verbose
end subroutine phs_write
end interface
@ %def phs_write
@ This procedure can be called to print the contents of the base type.
<<PHS base: phs: TBP>>=
procedure :: base_write => phs_base_write
<<PHS base: procedures>>=
subroutine phs_base_write (object, unit)
class(phs_t), intent(in) :: object
integer, intent(in), optional :: unit
integer :: u, c, i
u = given_output_unit (unit)
write (u, "(1x,A)", advance="no") "Partonic phase space: parameters"
if (object%r_defined) then
write (u, *)
else
write (u, "(1x,A)") "[undefined]"
end if
write (u, "(3x,A,999(1x," // FMT_19 // "))") "m_in =", object%m_in
write (u, "(3x,A,999(1x," // FMT_19 // "))") "m_out =", object%m_out
write (u, "(3x,A," // FMT_19 // ")") "Flux = ", object%flux
write (u, "(3x,A," // FMT_19 // ")") "Volume = ", object%volume
if (allocated (object%f)) then
do c = 1, size (object%r, 2)
write (u, "(1x,A,I0,A)", advance="no") "Channel #", c, ":"
if (c == object%selected_channel) then
write (u, "(1x,A)") "[selected]"
else
write (u, *)
end if
write (u, "(3x,A)", advance="no") "r ="
do i = 1, size (object%r, 1)
write (u, "(1x,F9.7)", advance="no") object%r(i,c)
end do
write (u, *)
write (u, "(3x,A,1x,ES13.7)") "f =", object%f(c)
end do
end if
write (u, "(1x,A)") "Partonic phase space: momenta"
if (object%p_defined) then
write (u, "(3x,A," // FMT_19 // ")") "sqrts = ", object%sqrts_hat
end if
write (u, "(1x,A)", advance="no") "Incoming:"
if (object%p_defined) then
write (u, *)
else
write (u, "(1x,A)") "[undefined]"
end if
if (allocated (object%p)) then
do i = 1, size (object%p)
call vector4_write (object%p(i), u)
end do
end if
write (u, "(1x,A)", advance="no") "Outgoing:"
if (object%q_defined) then
write (u, *)
else
write (u, "(1x,A)") "[undefined]"
end if
if (allocated (object%q)) then
do i = 1, size (object%q)
call vector4_write (object%q(i), u)
end do
end if
if (object%p_defined .and. .not. object%config%lab_is_cm) then
write (u, "(1x,A)") "Transformation c.m -> lab frame"
call lorentz_transformation_write (object%lt_cm_to_lab, u)
end if
end subroutine phs_base_write
@ %def phs_base_write
@ Finalizer. The base type does not need it, but extensions may.
<<PHS base: phs: TBP>>=
procedure (phs_final), deferred :: final
<<PHS base: interfaces>>=
abstract interface
subroutine phs_final (object)
import
class(phs_t), intent(inout) :: object
end subroutine phs_final
end interface
@ %def phs_final
@ Initializer. Everything should be contained in the [[process_data]]
configuration object, so we can require a universal interface.
<<PHS base: phs: TBP>>=
procedure (phs_init), deferred :: init
<<PHS base: interfaces>>=
abstract interface
subroutine phs_init (phs, phs_config)
import
class(phs_t), intent(out) :: phs
class(phs_config_t), intent(in), target :: phs_config
end subroutine phs_init
end interface
@ %def phs_init
@ The base version will just allocate the arrays. It should be called
at the beginning of the implementation of [[phs_init]].
<<PHS base: phs: TBP>>=
procedure :: base_init => phs_base_init
<<PHS base: procedures>>=
subroutine phs_base_init (phs, phs_config)
class(phs_t), intent(out) :: phs
class(phs_config_t), intent(in), target :: phs_config
real(default), dimension(phs_config%n_in) :: m_in
real(default), dimension(phs_config%n_out) :: m_out
phs%config => phs_config
allocate (phs%active_channel (phs%config%n_channel))
phs%active_channel = .true.
allocate (phs%r (phs%config%n_par, phs%config%n_channel)); phs%r = 0
allocate (phs%f (phs%config%n_channel)); phs%f = 0
allocate (phs%p (phs%config%n_in))
!!! !!! !!! Workaround for gfortran 5.0 ICE
m_in = phs_config%flv(:phs_config%n_in, 1)%get_mass ()
m_out = phs_config%flv(phs_config%n_in+1:, 1)%get_mass ()
allocate (phs%m_in (phs%config%n_in), source = m_in)
!!! allocate (phs%m_in (phs%config%n_in), &
!!! source = phs_config%flv(:phs_config%n_in, 1)%get_mass ())
allocate (phs%q (phs%config%n_out))
allocate (phs%m_out (phs%config%n_out), source = m_out)
!!! allocate (phs%m_out (phs%config%n_out), &
!!! source = phs_config%flv(phs_config%n_in+1:, 1)%get_mass ())
call phs%compute_flux ()
end subroutine phs_base_init
@ %def phs_base_init
@ Manually select a channel.
<<PHS base: phs: TBP>>=
procedure :: select_channel => phs_base_select_channel
<<PHS base: procedures>>=
subroutine phs_base_select_channel (phs, channel)
class(phs_t), intent(inout) :: phs
integer, intent(in), optional :: channel
if (present (channel)) then
phs%selected_channel = channel
else
phs%selected_channel = 0
end if
end subroutine phs_base_select_channel
@ %def phs_base_select_channel
@ Set incoming momenta. Assume that array shapes match. If
requested, compute the Lorentz transformation from the c.m.\ to the
lab frame and apply that transformation to the incoming momenta.
In the c.m.\ frame, the sum of three-momenta is zero. In a scattering
process, the $z$ axis is the direction of the first beam, the second
beam is along the negative $z$ axis. The transformation from the
c.m.\ to the lab frame is a rotation from the $z$ axis to the boost
axis followed by a boost, such that the c.m.\ momenta are transformed
into the lab-frame momenta. In a decay process, we just boost along
the flight direction, without rotation.
<<PHS base: phs: TBP>>=
procedure :: set_incoming_momenta => phs_set_incoming_momenta
<<PHS base: procedures>>=
subroutine phs_set_incoming_momenta (phs, p)
class(phs_t), intent(inout) :: phs
type(vector4_t), dimension(:), intent(in) :: p
type(vector4_t) :: p0, p1
type(lorentz_transformation_t) :: lt0
integer :: i
phs%p = p
if (phs%config%lab_is_cm) then
phs%sqrts_hat = phs%config%sqrts
phs%p = p
phs%lt_cm_to_lab = identity
else
p0 = sum (p)
if (phs%config%sqrts_fixed) then
phs%sqrts_hat = phs%config%sqrts
else
phs%sqrts_hat = p0 ** 1
end if
lt0 = boost (p0, phs%sqrts_hat)
select case (phs%config%n_in)
case (1)
phs%lt_cm_to_lab = lt0
case (2)
p1 = inverse (lt0) * p(1)
phs%lt_cm_to_lab = lt0 * rotation_to_2nd (3, space_part (p1))
end select
phs%p = inverse (phs%lt_cm_to_lab) * p
end if
phs%p_defined = .true.
end subroutine phs_set_incoming_momenta
@ %def phs_set_incoming_momenta
@ Set outgoing momenta. Assume that array shapes match. The incoming
momenta must be known, so we can apply the Lorentz transformation from
c.m.\ to lab (inverse) to the momenta.
<<PHS base: phs: TBP>>=
procedure :: set_outgoing_momenta => phs_set_outgoing_momenta
<<PHS base: procedures>>=
subroutine phs_set_outgoing_momenta (phs, q)
class(phs_t), intent(inout) :: phs
type(vector4_t), dimension(:), intent(in) :: q
integer :: i
if (phs%p_defined) then
if (phs%config%lab_is_cm) then
phs%q = q
else
phs%q = inverse (phs%lt_cm_to_lab) * q
end if
phs%q_defined = .true.
end if
end subroutine phs_set_outgoing_momenta
@ %def phs_set_outgoing_momenta
@ Return outgoing momenta. Apply the c.m.\ to lab transformation if
necessary.
<<PHS base: phs: TBP>>=
procedure :: get_outgoing_momenta => phs_get_outgoing_momenta
<<PHS base: procedures>>=
subroutine phs_get_outgoing_momenta (phs, q)
class(phs_t), intent(in) :: phs
type(vector4_t), dimension(:), intent(out) :: q
if (phs%p_defined .and. phs%q_defined) then
if (phs%config%lab_is_cm) then
q = phs%q
else
q = phs%lt_cm_to_lab * phs%q
end if
else
q = vector4_null
end if
end subroutine phs_get_outgoing_momenta
@ %def phs_get_outgoing_momenta
@
<<PHS base: phs: TBP>>=
procedure :: lab_is_cm => phs_lab_is_cm
<<PHS base: procedures>>=
function phs_lab_is_cm (phs) result (lab_is_cm)
logical :: lab_is_cm
class(phs_t), intent(in) :: phs
lab_is_cm = phs%config%lab_is_cm
end function phs_lab_is_cm
@ %def phs_lab_is_cm
@
<<PHS base: phs: TBP>>=
procedure :: get_n_tot => phs_get_n_tot
<<PHS base: procedures>>=
elemental function phs_get_n_tot (phs) result (n_tot)
integer :: n_tot
class(phs_t), intent(in) :: phs
n_tot = phs%config%n_tot
end function phs_get_n_tot
@ %def phs_get_n_tot
@
<<PHS base: phs: TBP>>=
procedure :: set_lorentz_transformation => phs_set_lorentz_transformation
<<PHS base: procedures>>=
subroutine phs_set_lorentz_transformation (phs, lt)
class(phs_t), intent(inout) :: phs
type(lorentz_transformation_t), intent(in) :: lt
phs%lt_cm_to_lab = lt
end subroutine phs_set_lorentz_transformation
@ %def phs_set_lorentz_transformation
@
<<PHS base: phs: TBP>>=
procedure :: get_lorentz_transformation => phs_get_lorentz_transformation
<<PHS base: procedures>>=
function phs_get_lorentz_transformation (phs) result (lt)
type(lorentz_transformation_t) :: lt
class(phs_t), intent(in) :: phs
lt = phs%lt_cm_to_lab
end function phs_get_lorentz_transformation
@ %def phs_get_lorentz_transformation
@ Return the input parameter array for a channel.
<<PHS base: phs: TBP>>=
procedure :: get_mcpar => phs_get_mcpar
<<PHS base: procedures>>=
subroutine phs_get_mcpar (phs, c, r)
class(phs_t), intent(in) :: phs
integer, intent(in) :: c
real(default), dimension(:), intent(out) :: r
if (phs%r_defined) then
r = phs%r(:,c)
else
r = 0
end if
end subroutine phs_get_mcpar
@ %def phs_get_mcpar
@ Return the Jacobian factor for a channel.
<<PHS base: phs: TBP>>=
procedure :: get_f => phs_get_f
<<PHS base: procedures>>=
function phs_get_f (phs, c) result (f)
class(phs_t), intent(in) :: phs
integer, intent(in) :: c
real(default) :: f
if (phs%r_defined) then
f = phs%f(c)
else
f = 0
end if
end function phs_get_f
@ %def phs_get_f
@ Return the overall factor, which is the product of the flux factor for the
incoming partons and the phase-space volume for the outgoing partons.
<<PHS base: phs: TBP>>=
procedure :: get_overall_factor => phs_get_overall_factor
<<PHS base: procedures>>=
function phs_get_overall_factor (phs) result (f)
class(phs_t), intent(in) :: phs
real(default) :: f
f = phs%flux * phs%volume
end function phs_get_overall_factor
@ %def phs_get_overall_factor
@ Compute flux factor. We do this during initialization (when the
incoming momenta [[p]] are undefined), unless [[sqrts]] is variable. We do
this again once for each phase-space point, but then we skip the calculation
if [[sqrts]] is fixed.
There are three different flux factors.
\begin{enumerate}
\item
For a decaying massive particle, the factor is
\begin{equation}
f = (2\pi)^4 / (2M)
\end{equation}
\item
For a $2\to n$ scattering process with $n>1$, the factor is
\begin{equation}
f = (2\pi)^4 / (2\sqrt{\lambda})
\end{equation}
where for massless incoming particles, $\sqrt{\lambda} = s$.
\item For a $2\to 1$ on-shell production process, the factor includes
an extra $1/(2\pi)^3$ factor and a $1/m^2$ factor from the
phase-space delta function $\delta (x_1x_2 - m^2/s)$, which
originate from the one-particle phase space that we integrate out.
\begin{equation}
f = 2\pi / (2s m^2)
\end{equation}
The delta function is handled by the structure-function
parameterization.
\end{enumerate}
<<PHS base: phs: TBP>>=
procedure :: compute_flux => phs_compute_flux
procedure :: compute_base_flux => phs_compute_flux
<<PHS base: procedures>>=
subroutine phs_compute_flux (phs)
class(phs_t), intent(inout) :: phs
real(default) :: s_hat, lda
select case (phs%config%n_in)
case (1)
if (.not. phs%p_defined) then
phs%flux = twopi4 / (2 * phs%m_in(1))
end if
case (2)
if (phs%p_defined) then
if (phs%config%sqrts_fixed) then
return
else
s_hat = sum (phs%p) ** 2
end if
else
if (phs%config%sqrts_fixed) then
s_hat = phs%config%sqrts ** 2
else
return
end if
end if
select case (phs%config%n_out)
case (2:)
lda = lambda (s_hat, phs%m_in(1) ** 2, phs%m_in(2) ** 2)
if (lda > 0) then
phs%flux = conv * twopi4 / (2 * sqrt (lda))
else
phs%flux = 0
end if
case (1)
phs%flux = conv * twopi &
/ (2 * phs%config%sqrts ** 2 * phs%m_out(1) ** 2)
case default
phs%flux = 0
end select
end select
end subroutine phs_compute_flux
@ %def phs_compute_flux
@ Evaluate the phase-space point for a particular channel and compute momenta,
Jacobian, and phase-space volume. This is, of course, deferred to
the implementation.
<<PHS base: phs: TBP>>=
procedure (phs_evaluate_selected_channel), deferred :: &
evaluate_selected_channel
<<PHS base: interfaces>>=
abstract interface
subroutine phs_evaluate_selected_channel (phs, c_in, r_in)
import
class(phs_t), intent(inout) :: phs
integer, intent(in) :: c_in
real(default), dimension(:), intent(in) :: r_in
end subroutine phs_evaluate_selected_channel
end interface
@ %def phs_evaluate_selected_channel
@ Compute the inverse mappings to completely fill the [[r]] and [[f]] arrays,
for the non-selected channels.
<<PHS base: phs: TBP>>=
procedure (phs_evaluate_other_channels), deferred :: &
evaluate_other_channels
<<PHS base: interfaces>>=
abstract interface
subroutine phs_evaluate_other_channels (phs, c_in)
import
class(phs_t), intent(inout) :: phs
integer, intent(in) :: c_in
end subroutine phs_evaluate_other_channels
end interface
@ %def phs_evaluate_other_channels
@ Inverse evaluation. If all momenta are known, we compute the
inverse mappings to fill the [[r]] and [[f]] arrays.
<<PHS base: phs: TBP>>=
procedure (phs_inverse), deferred :: inverse
<<PHS base: interfaces>>=
abstract interface
subroutine phs_inverse (phs)
import
class(phs_t), intent(inout) :: phs
end subroutine phs_inverse
end interface
@ %def phs_inverse
@
<<PHS base: phs: TBP>>=
procedure :: get_sqrts => phs_get_sqrts
<<PHS base: procedures>>=
function phs_get_sqrts (phs) result (sqrts)
real(default) :: sqrts
class(phs_t), intent(in) :: phs
sqrts = phs%config%sqrts
end function phs_get_sqrts
@ %def phs_get_sqrts
@
\subsubsection{Uniform angular distribution}
These procedures implement the uniform angular distribution, generated
from two parameters $x_1$ and $x_2$:
\begin{equation}
\cos\theta = 1 - 2x_1, \qquad \phi = 2\pi x_2
\end{equation}
We generate a rotation (Lorentz transformation) which rotates the
positive $z$ axis into this point on the unit sphere. This rotation
is applied to the [[p]] momenta, which are assumed to be
back-to-back, on-shell, and with the correct mass.
We do not compute a Jacobian (constant). The uniform distribution is
assumed to be normalized.
<<PHS base: public>>=
public :: compute_kinematics_solid_angle
<<PHS base: procedures>>=
subroutine compute_kinematics_solid_angle (p, q, x)
type(vector4_t), dimension(2), intent(in) :: p
type(vector4_t), dimension(2), intent(out) :: q
real(default), dimension(2), intent(in) :: x
real(default) :: ct, st, phi
type(lorentz_transformation_t) :: rot
integer :: i
ct = 1 - 2*x(1)
st = sqrt (1 - ct**2)
phi = twopi * x(2)
rot = rotation (phi, 3) * rotation (ct, st, 2)
do i = 1, 2
q(i) = rot * p(i)
end do
end subroutine compute_kinematics_solid_angle
@ %def compute_kinematics_solid_angle
@ This is the inverse transformation. We assume that the outgoing
momenta are rotated versions of the incoming momenta, back-to-back.
Thus, we determine the angles from $q(1)$ alone. [[p]] is unused.
<<PHS base: public>>=
public :: inverse_kinematics_solid_angle
<<PHS base: procedures>>=
subroutine inverse_kinematics_solid_angle (p, q, x)
type(vector4_t), dimension(:), intent(in) :: p
type(vector4_t), dimension(2), intent(in) :: q
real(default), dimension(2), intent(out) :: x
real(default) :: ct, phi
ct = polar_angle_ct (q(1))
phi = azimuthal_angle (q(1))
x(1) = (1 - ct) / 2
x(2) = phi / twopi
end subroutine inverse_kinematics_solid_angle
@ %def inverse_kinematics_solid_angle
@
\subsection{Auxiliary stuff}
The [[pacify]] subroutine, which is provided by the Lorentz module,
has the purpose of setting numbers to zero which are (by comparing
with a [[tolerance]] parameter) considered equivalent with zero. This
is useful for numerical checks.
<<PHS base: public>>=
public :: pacify
<<PHS base: interfaces>>=
interface pacify
module procedure pacify_phs
end interface pacify
<<PHS base: procedures>>=
subroutine pacify_phs (phs)
class(phs_t), intent(inout) :: phs
if (phs%p_defined) then
call pacify (phs%p, 30 * epsilon (1._default) * phs%config%sqrts)
call pacify (phs%lt_cm_to_lab, 30 * epsilon (1._default))
end if
if (phs%q_defined) then
call pacify (phs%q, 30 * epsilon (1._default) * phs%config%sqrts)
end if
end subroutine pacify_phs
@ %def pacify
@
\subsection{Unit tests}
Test module, followed by the corresponding implementation module.
<<[[phs_base_ut.f90]]>>=
<<File header>>
module phs_base_ut
use unit_tests
use phs_base_uti
<<Standard module head>>
<<PHS base: public test>>
<<PHS base: public test auxiliary>>
contains
<<PHS base: test driver>>
end module phs_base_ut
@ %def phs_base_ut
@
<<[[phs_base_uti.f90]]>>=
<<File header>>
module phs_base_uti
<<Use kinds>>
<<Use strings>>
use diagnostics
use io_units
use format_defs, only: FMT_19
use physics_defs, only: BORN
use lorentz
use flavors
use model_data
use process_constants
use phs_base
<<Standard module head>>
<<PHS base: public test auxiliary>>
<<PHS base: test declarations>>
<<PHS base: test types>>
contains
<<PHS base: tests>>
<<PHS base: test auxiliary>>
end module phs_base_uti
@ %def phs_base_ut
@ API: driver for the unit tests below.
<<PHS base: public test>>=
public :: phs_base_test
<<PHS base: test driver>>=
subroutine phs_base_test (u, results)
integer, intent(in) :: u
type(test_results_t), intent(inout) :: results
<<PHS base: execute tests>>
end subroutine phs_base_test
@ %def phs_base_test
@
\subsubsection{Test process data}
We provide a procedure that initializes a test case for the process
constants. This set of process data contains just the minimal
contents that we need for the phase space. The rest is left
uninitialized.
<<PHS base: public test auxiliary>>=
public :: init_test_process_data
<<PHS base: test auxiliary>>=
subroutine init_test_process_data (id, data)
type(process_constants_t), intent(out) :: data
type(string_t), intent(in), optional :: id
if (present (id)) then
data%id = id
else
data%id = "testproc"
end if
data%model_name = "Test"
data%n_in = 2
data%n_out = 2
data%n_flv = 1
allocate (data%flv_state (data%n_in + data%n_out, data%n_flv))
data%flv_state = 25
end subroutine init_test_process_data
@ %def init_test_process_data
@ This is the variant for a decay process.
<<PHS base: public test auxiliary>>=
public :: init_test_decay_data
<<PHS base: test auxiliary>>=
subroutine init_test_decay_data (id, data)
type(process_constants_t), intent(out) :: data
type(string_t), intent(in), optional :: id
if (present (id)) then
data%id = id
else
data%id = "testproc"
end if
data%model_name = "Test"
data%n_in = 1
data%n_out = 2
data%n_flv = 1
allocate (data%flv_state (data%n_in + data%n_out, data%n_flv))
data%flv_state(:,1) = [25, 6, -6]
end subroutine init_test_decay_data
@ %def init_test_decay_data
@
\subsubsection{Test kinematics configuration}
This is a trivial implementation of the [[phs_config_t]] configuration object.
<<PHS base: public test auxiliary>>=
public :: phs_test_config_t
<<PHS base: test types>>=
type, extends (phs_config_t) :: phs_test_config_t
logical :: create_equivalences = .false.
contains
procedure :: final => phs_test_config_final
procedure :: write => phs_test_config_write
procedure :: configure => phs_test_config_configure
procedure :: startup_message => phs_test_config_startup_message
procedure, nopass :: allocate_instance => phs_test_config_allocate_instance
end type phs_test_config_t
@ %def phs_test_config_t
@ The finalizer is empty.
<<PHS base: test auxiliary>>=
subroutine phs_test_config_final (object)
class(phs_test_config_t), intent(inout) :: object
end subroutine phs_test_config_final
@ %def phs_test_config_final
@ The [[lab_is_cm]] parameter is not tested here; we defer this to the
[[phs_single]] implementation.
<<PHS base: test auxiliary>>=
subroutine phs_test_config_write (object, unit, include_id)
class(phs_test_config_t), intent(in) :: object
integer, intent(in), optional :: unit
logical, intent(in), optional :: include_id
integer :: u
u = given_output_unit (unit)
write (u, "(1x,A)") "Partonic phase-space configuration:"
call object%base_write (unit)
end subroutine phs_test_config_write
subroutine phs_test_config_configure (phs_config, sqrts, &
sqrts_fixed, lab_is_cm, azimuthal_dependence, rebuild, &
ignore_mismatch, nlo_type, subdir)
class(phs_test_config_t), intent(inout) :: phs_config
real(default), intent(in) :: sqrts
logical, intent(in), optional :: sqrts_fixed
logical, intent(in), optional :: lab_is_cm
logical, intent(in), optional :: azimuthal_dependence
logical, intent(in), optional :: rebuild
logical, intent(in), optional :: ignore_mismatch
integer, intent(in), optional :: nlo_type
type(string_t), intent(in), optional :: subdir
phs_config%n_channel = 2
phs_config%n_par = 2
phs_config%sqrts = sqrts
if (.not. present (nlo_type)) &
phs_config%nlo_type = BORN
if (present (sqrts_fixed)) then
phs_config%sqrts_fixed = sqrts_fixed
end if
if (present (lab_is_cm)) then
phs_config%lab_is_cm = lab_is_cm
end if
if (present (azimuthal_dependence)) then
phs_config%azimuthal_dependence = azimuthal_dependence
end if
if (allocated (phs_config%channel)) deallocate (phs_config%channel)
allocate (phs_config%channel (phs_config%n_channel))
if (phs_config%create_equivalences) then
call setup_test_equivalences (phs_config)
call setup_test_channel_props (phs_config)
end if
call phs_config%compute_md5sum ()
end subroutine phs_test_config_configure
@ %def phs_test_config_write
@ %def phs_test_config_configure
@ If requested, we make up an arbitrary set of equivalences.
<<PHS base: test auxiliary>>=
subroutine setup_test_equivalences (phs_config)
class(phs_test_config_t), intent(inout) :: phs_config
integer :: i
associate (channel => phs_config%channel(1))
allocate (channel%eq (2))
do i = 1, size (channel%eq)
call channel%eq(i)%init (phs_config%n_par)
end do
associate (eq => channel%eq(1))
eq%c = 1; eq%perm = [1, 2]; eq%mode = [EQ_IDENTITY, EQ_SYMMETRIC]
end associate
associate (eq => channel%eq(2))
eq%c = 2; eq%perm = [2, 1]; eq%mode = [EQ_INVARIANT, EQ_IDENTITY]
end associate
end associate
end subroutine setup_test_equivalences
@ %def setup_test_equivalences
@ Ditto, for channel properties.
<<PHS base: test auxiliary>>=
subroutine setup_test_channel_props (phs_config)
class(phs_test_config_t), intent(inout) :: phs_config
associate (channel => phs_config%channel(2))
call channel%set_resonant (140._default, 3.1415_default)
end associate
end subroutine setup_test_channel_props
@ %def setup_test_channel_props
@ Startup message
<<PHS base: test auxiliary>>=
subroutine phs_test_config_startup_message (phs_config, unit)
class(phs_test_config_t), intent(in) :: phs_config
integer, intent(in), optional :: unit
call phs_config%base_startup_message (unit)
write (msg_buffer, "(A)") "Phase space: Test"
call msg_message (unit = unit)
end subroutine phs_test_config_startup_message
@ %def phs_test_config_startup_message
@ The instance type that matches [[phs_test_config_t]] is [[phs_test_t]].
<<PHS base: test auxiliary>>=
subroutine phs_test_config_allocate_instance (phs)
class(phs_t), intent(inout), pointer :: phs
allocate (phs_test_t :: phs)
end subroutine phs_test_config_allocate_instance
@ %def phs_test_config_allocate_instance
@
\subsubsection{Test kinematics implementation}
This implementation of kinematics generates a simple two-particle
configuration from the incoming momenta. The incoming momenta must be
in the c.m.\ system, all masses equal.
There are two channels: one generates $\cos\theta$ and $\phi$
uniformly, in the other channel we map the $r_1$ parameter which
belongs to $\cos\theta$.
We should store the mass parameter that we need.
<<PHS base: public test auxiliary>>=
public :: phs_test_t
<<PHS base: test types>>=
type, extends (phs_t) :: phs_test_t
real(default) :: m = 0
real(default), dimension(:), allocatable :: x
contains
<<PHS base: phs test: TBP>>
end type phs_test_t
@ %def phs_test_t
@ Output. The specific data are displayed only if [[verbose]] is set.
<<PHS base: phs test: TBP>>=
procedure :: write => phs_test_write
<<PHS base: test auxiliary>>=
subroutine phs_test_write (object, unit, verbose)
class(phs_test_t), intent(in) :: object
integer, intent(in), optional :: unit
logical, intent(in), optional :: verbose
integer :: u
logical :: verb
u = given_output_unit (unit)
verb = .false.; if (present (verbose)) verb = verbose
if (verb) then
write (u, "(1x,A)") "Partonic phase space: data"
write (u, "(3x,A," // FMT_19 // ")") "m = ", object%m
end if
call object%base_write (u)
end subroutine phs_test_write
@ %def phs_test_write
@ The finalizer is empty.
<<PHS base: phs test: TBP>>=
procedure :: final => phs_test_final
<<PHS base: test auxiliary>>=
subroutine phs_test_final (object)
class(phs_test_t), intent(inout) :: object
end subroutine phs_test_final
@ %def phs_test_final
@ Initialization: set the mass value.
<<PHS base: phs test: TBP>>=
procedure :: init => phs_test_init
<<PHS base: test auxiliary>>=
subroutine phs_test_init (phs, phs_config)
class(phs_test_t), intent(out) :: phs
class(phs_config_t), intent(in), target :: phs_config
call phs%base_init (phs_config)
phs%m = phs%config%flv(1,1)%get_mass ()
allocate (phs%x (phs_config%n_par), source = 0._default)
end subroutine phs_test_init
@ %def phs_test_init
@ Evaluation. In channel 1, we uniformly generate $\cos\theta$ and
$\phi$, with Jacobian normalized to one. In channel 2, we prepend a
mapping $r_1 \to r_1^(1/3)$ with Jacobian $f=3r_1^2$.
The component [[x]] is allocated in the first subroutine, used and deallocated
in the second one.
<<PHS base: phs test: TBP>>=
procedure :: evaluate_selected_channel => phs_test_evaluate_selected_channel
procedure :: evaluate_other_channels => phs_test_evaluate_other_channels
<<PHS base: test auxiliary>>=
subroutine phs_test_evaluate_selected_channel (phs, c_in, r_in)
class(phs_test_t), intent(inout) :: phs
integer, intent(in) :: c_in
real(default), intent(in), dimension(:) :: r_in
if (phs%p_defined) then
call phs%select_channel (c_in)
phs%r(:,c_in) = r_in
select case (c_in)
case (1)
phs%x = r_in
case (2)
phs%x(1) = r_in(1) ** (1 / 3._default)
phs%x(2) = r_in(2)
end select
call compute_kinematics_solid_angle (phs%p, phs%q, phs%x)
phs%volume = 1
phs%q_defined = .true.
end if
end subroutine phs_test_evaluate_selected_channel
subroutine phs_test_evaluate_other_channels (phs, c_in)
class(phs_test_t), intent(inout) :: phs
integer, intent(in) :: c_in
integer :: c, n_channel
if (phs%p_defined) then
n_channel = phs%config%n_channel
do c = 1, n_channel
if (c /= c_in) then
call inverse_kinematics_solid_angle (phs%p, phs%q, phs%x)
select case (c)
case (1)
phs%r(:,c) = phs%x
case (2)
phs%r(1,c) = phs%x(1) ** 3
phs%r(2,c) = phs%x(2)
end select
end if
end do
phs%f(1) = 1
if (phs%r(1,2) /= 0) then
phs%f(2) = 1 / (3 * phs%r(1,2) ** (2/3._default))
else
phs%f(2) = 0
end if
phs%r_defined = .true.
end if
end subroutine phs_test_evaluate_other_channels
@ %def phs_test_evaluate_selected_channels
@ %def phs_test_evaluate_other_channels
@ Inverse evaluation.
<<PHS base: phs test: TBP>>=
procedure :: inverse => phs_test_inverse
<<PHS base: test auxiliary>>=
subroutine phs_test_inverse (phs)
class(phs_test_t), intent(inout) :: phs
integer :: c, n_channel
real(default), dimension(:), allocatable :: x
if (phs%p_defined .and. phs%q_defined) then
call phs%select_channel ()
n_channel = phs%config%n_channel
allocate (x (phs%config%n_par))
do c = 1, n_channel
call inverse_kinematics_solid_angle (phs%p, phs%q, x)
select case (c)
case (1)
phs%r(:,c) = x
case (2)
phs%r(1,c) = x(1) ** 3
phs%r(2,c) = x(2)
end select
end do
phs%f(1) = 1
if (phs%r(1,2) /= 0) then
phs%f(2) = 1 / (3 * phs%r(1,2) ** (2/3._default))
else
phs%f(2) = 0
end if
phs%volume = 1
phs%r_defined = .true.
end if
end subroutine phs_test_inverse
@ %def phs_test_inverse
@
\subsubsection{Phase-space configuration data}
Construct and display a test phase-space configuration object.
<<PHS base: execute tests>>=
call test (phs_base_1, "phs_base_1", &
"phase-space configuration", &
u, results)
<<PHS base: test declarations>>=
public :: phs_base_1
<<PHS base: tests>>=
subroutine phs_base_1 (u)
integer, intent(in) :: u
type(model_data_t), target :: model
type(process_constants_t) :: process_data
class(phs_config_t), allocatable :: phs_data
write (u, "(A)") "* Test output: phs_base_1"
write (u, "(A)") "* Purpose: initialize and display &
&test phase-space configuration data"
write (u, "(A)")
call model%init_test ()
write (u, "(A)") "* Initialize a process and a matching &
&phase-space configuration"
write (u, "(A)")
call init_test_process_data (var_str ("phs_base_1"), process_data)
allocate (phs_test_config_t :: phs_data)
call phs_data%init (process_data, model)
call phs_data%write (u)
call phs_data%final ()
call model%final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: phs_base_1"
end subroutine phs_base_1
@ %def phs_base_1
@
\subsubsection{Phase space evaluation}
Compute kinematics for given parameters, also invert the calculation.
<<PHS base: execute tests>>=
call test (phs_base_2, "phs_base_2", &
"phase-space evaluation", &
u, results)
<<PHS base: test declarations>>=
public :: phs_base_2
<<PHS base: tests>>=
subroutine phs_base_2 (u)
integer, intent(in) :: u
type(model_data_t), target :: model
type(flavor_t) :: flv
type(process_constants_t) :: process_data
real(default) :: sqrts, E
class(phs_config_t), allocatable, target :: phs_data
class(phs_t), pointer :: phs => null ()
type(vector4_t), dimension(2) :: p, q
write (u, "(A)") "* Test output: phs_base_2"
write (u, "(A)") "* Purpose: test simple two-channel phase space"
write (u, "(A)")
call model%init_test ()
call flv%init (25, model)
write (u, "(A)") "* Initialize a process and a matching &
&phase-space configuration"
write (u, "(A)")
call init_test_process_data (var_str ("phs_base_2"), process_data)
allocate (phs_test_config_t :: phs_data)
call phs_data%init (process_data, model)
sqrts = 1000._default
call phs_data%configure (sqrts)
call phs_data%write (u)
write (u, "(A)")
write (u, "(A)") "* Initialize the phase-space instance"
write (u, "(A)")
call phs_data%allocate_instance (phs)
select type (phs)
type is (phs_test_t)
call phs%init (phs_data)
end select
call phs%write (u, verbose=.true.)
write (u, "(A)")
write (u, "(A)") "* Set incoming momenta"
write (u, "(A)")
E = sqrts / 2
p(1) = vector4_moving (E, sqrt (E**2 - flv%get_mass ()**2), 3)
p(2) = vector4_moving (E,-sqrt (E**2 - flv%get_mass ()**2), 3)
call phs%set_incoming_momenta (p)
call phs%compute_flux ()
call phs%write (u)
write (u, "(A)")
write (u, "(A)") "* Compute phase-space point in channel 1 &
&for x = 0.5, 0.125"
write (u, "(A)")
call phs%evaluate_selected_channel (1, [0.5_default, 0.125_default])
call phs%evaluate_other_channels (1)
call phs%write (u)
write (u, "(A)")
write (u, "(A)") "* Compute phase-space point in channel 2 &
&for x = 0.125, 0.125"
write (u, "(A)")
call phs%evaluate_selected_channel (2, [0.125_default, 0.125_default])
call phs%evaluate_other_channels (2)
call phs%write (u)
write (u, "(A)")
write (u, "(A)") "* Inverse kinematics"
write (u, "(A)")
call phs%get_outgoing_momenta (q)
deallocate (phs)
call phs_data%allocate_instance (phs)
call phs%init (phs_data)
sqrts = 1000._default
select type (phs_data)
type is (phs_test_config_t)
call phs_data%configure (sqrts)
end select
call phs%set_incoming_momenta (p)
call phs%compute_flux ()
call phs%set_outgoing_momenta (q)
call phs%inverse ()
call phs%write (u)
call phs%final ()
deallocate (phs)
call phs_data%final ()
call model%final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: phs_base_2"
end subroutine phs_base_2
@ %def phs_base_2
@
\subsubsection{Phase-space equivalences}
Construct a test phase-space configuration which contains channel
equivalences.
<<PHS base: execute tests>>=
call test (phs_base_3, "phs_base_3", &
"channel equivalences", &
u, results)
<<PHS base: test declarations>>=
public :: phs_base_3
<<PHS base: tests>>=
subroutine phs_base_3 (u)
integer, intent(in) :: u
type(model_data_t), target :: model
type(process_constants_t) :: process_data
class(phs_config_t), allocatable :: phs_data
write (u, "(A)") "* Test output: phs_base_3"
write (u, "(A)") "* Purpose: construct phase-space configuration data &
&with equivalences"
write (u, "(A)")
call model%init_test ()
write (u, "(A)") "* Initialize a process and a matching &
&phase-space configuration"
write (u, "(A)")
call init_test_process_data (var_str ("phs_base_3"), process_data)
allocate (phs_test_config_t :: phs_data)
call phs_data%init (process_data, model)
select type (phs_data)
type is (phs_test_config_t)
phs_data%create_equivalences = .true.
end select
call phs_data%configure (1000._default)
call phs_data%write (u)
call phs_data%final ()
call model%final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: phs_base_3"
end subroutine phs_base_3
@ %def phs_base_3
@
\subsubsection{MD5 sum checks}
Construct a test phase-space configuration, compute and compare MD5 sums.
<<PHS base: execute tests>>=
call test (phs_base_4, "phs_base_4", &
"MD5 sum", &
u, results)
<<PHS base: test declarations>>=
public :: phs_base_4
<<PHS base: tests>>=
subroutine phs_base_4 (u)
integer, intent(in) :: u
type(model_data_t), target :: model
type(process_constants_t) :: process_data
class(phs_config_t), allocatable :: phs_data
write (u, "(A)") "* Test output: phs_base_4"
write (u, "(A)") "* Purpose: compute and compare MD5 sums"
write (u, "(A)")
call model%init_test ()
write (u, "(A)") "* Model parameters"
write (u, "(A)")
call model%write (unit = u, &
show_parameters = .true., &
show_particles = .false., show_vertices = .false.)
write (u, "(A)")
write (u, "(A)") "* Initialize a process and a matching &
&phase-space configuration"
write (u, "(A)")
call init_test_process_data (var_str ("phs_base_4"), process_data)
process_data%md5sum = "test_process_data_m6sum_12345678"
allocate (phs_test_config_t :: phs_data)
call phs_data%init (process_data, model)
call phs_data%compute_md5sum ()
call phs_data%write (u)
write (u, "(A)")
write (u, "(A)") "* Modify model parameter"
write (u, "(A)")
call model%set_par (var_str ("ms"), 100._default)
call model%write (show_parameters = .true., &
show_particles = .false., show_vertices = .false.)
write (u, "(A)")
write (u, "(A)") "* PHS configuration"
write (u, "(A)")
call phs_data%compute_md5sum ()
call phs_data%write (u)
call phs_data%final ()
call model%final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: phs_base_4"
end subroutine phs_base_4
@ %def phs_base_4
@
\subsubsection{Phase-space channel collection}
Set up an array of various phase-space channels and collect them in a list.
<<PHS base: execute tests>>=
call test (phs_base_5, "phs_base_5", &
"channel collection", &
u, results)
<<PHS base: test declarations>>=
public :: phs_base_5
<<PHS base: tests>>=
subroutine phs_base_5 (u)
integer, intent(in) :: u
type(phs_channel_t), dimension(:), allocatable :: channel
type(phs_channel_collection_t) :: coll
integer :: i, n
write (u, "(A)") "* Test output: phs_base_5"
write (u, "(A)") "* Purpose: collect channel properties"
write (u, "(A)")
write (u, "(A)") "* Set up an array of channels"
write (u, "(A)")
n = 6
allocate (channel (n))
call channel(2)%set_resonant (75._default, 3._default)
call channel(4)%set_resonant (130._default, 1._default)
call channel(5)%set_resonant (75._default, 3._default)
call channel(6)%set_on_shell (33._default)
do i = 1, n
write (u, "(1x,I0)", advance="no") i
call channel(i)%write (u)
end do
write (u, "(A)")
write (u, "(A)") "* Collect distinct properties"
write (u, "(A)")
do i = 1, n
call coll%push (channel(i))
end do
write (u, "(1x,A,I0)") "n = ", coll%get_n ()
write (u, "(A)")
call coll%write (u)
write (u, "(A)")
write (u, "(A)") "* Channel array with collection index assigned"
write (u, "(A)")
do i = 1, n
write (u, "(1x,I0)", advance="no") i
call channel(i)%write (u)
end do
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call coll%final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: phs_base_5"
end subroutine phs_base_5
@ %def phs_base_5
@
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\clearpage
\section{Dummy phase space}
This module implements a dummy phase space module for cases where the
program structure demands the existence of a phase-space module, but
no phase space integration is performed.
<<[[phs_none.f90]]>>=
<<File header>>
module phs_none
<<Use kinds>>
<<Use strings>>
use io_units, only: given_output_unit
use diagnostics, only: msg_message, msg_fatal
use phs_base, only: phs_config_t, phs_t
<<Standard module head>>
<<PHS none: public>>
<<PHS none: types>>
contains
<<PHS none: procedures>>
end module phs_none
@ %def phs_none
@
\subsection{Configuration}
Nothing to configure, but we provide the type and methods.
<<PHS none: public>>=
public :: phs_none_config_t
<<PHS none: types>>=
type, extends (phs_config_t) :: phs_none_config_t
contains
<<PHS none: phs none config: TBP>>
end type phs_none_config_t
@ %def phs_none_config_t
@ The finalizer is empty.
<<PHS none: phs none config: TBP>>=
procedure :: final => phs_none_config_final
<<PHS none: procedures>>=
subroutine phs_none_config_final (object)
class(phs_none_config_t), intent(inout) :: object
end subroutine phs_none_config_final
@ %def phs_none_final
@ Output. No contents, just an informative line.
<<PHS none: phs none config: TBP>>=
procedure :: write => phs_none_config_write
<<PHS none: procedures>>=
subroutine phs_none_config_write (object, unit, include_id)
class(phs_none_config_t), intent(in) :: object
integer, intent(in), optional :: unit
logical, intent(in), optional :: include_id
integer :: u
u = given_output_unit (unit)
write (u, "(1x,A)") "Partonic phase-space configuration: non-functional dummy"
end subroutine phs_none_config_write
@ %def phs_none_config_write
@ Configuration: we have to implement this method, but it obviously does nothing.
<<PHS none: phs none config: TBP>>=
procedure :: configure => phs_none_config_configure
<<PHS none: procedures>>=
subroutine phs_none_config_configure (phs_config, sqrts, &
sqrts_fixed, lab_is_cm, azimuthal_dependence, rebuild, ignore_mismatch, &
nlo_type, subdir)
class(phs_none_config_t), intent(inout) :: phs_config
real(default), intent(in) :: sqrts
logical, intent(in), optional :: sqrts_fixed
logical, intent(in), optional :: lab_is_cm
logical, intent(in), optional :: azimuthal_dependence
logical, intent(in), optional :: rebuild
logical, intent(in), optional :: ignore_mismatch
integer, intent(in), optional :: nlo_type
type(string_t), intent(in), optional :: subdir
end subroutine phs_none_config_configure
@ %def phs_none_config_configure
@ Startup message, after configuration is complete.
<<PHS none: phs none config: TBP>>=
procedure :: startup_message => phs_none_config_startup_message
<<PHS none: procedures>>=
subroutine phs_none_config_startup_message (phs_config, unit)
class(phs_none_config_t), intent(in) :: phs_config
integer, intent(in), optional :: unit
call msg_message ("Phase space: none")
end subroutine phs_none_config_startup_message
@ %def phs_none_config_startup_message
@ Allocate an instance: the actual phase-space object.
<<PHS none: phs none config: TBP>>=
procedure, nopass :: allocate_instance => phs_none_config_allocate_instance
<<PHS none: procedures>>=
subroutine phs_none_config_allocate_instance (phs)
class(phs_t), intent(inout), pointer :: phs
allocate (phs_none_t :: phs)
end subroutine phs_none_config_allocate_instance
@ %def phs_none_config_allocate_instance
@
\subsection{Kinematics implementation}
This is considered as empty, but we have to implement the minimal set of methods.
<<PHS none: public>>=
public :: phs_none_t
<<PHS none: types>>=
type, extends (phs_t) :: phs_none_t
contains
<<PHS none: phs none: TBP>>
end type phs_none_t
@ %def phs_none_t
@ Output.
<<PHS none: phs none: TBP>>=
procedure :: write => phs_none_write
<<PHS none: procedures>>=
subroutine phs_none_write (object, unit, verbose)
class(phs_none_t), intent(in) :: object
integer, intent(in), optional :: unit
logical, intent(in), optional :: verbose
integer :: u
u = given_output_unit (unit)
write (u, "(A)") "Partonic phase space: none"
end subroutine phs_none_write
@ %def phs_none_write
@ The finalizer is empty.
<<PHS none: phs none: TBP>>=
procedure :: final => phs_none_final
<<PHS none: procedures>>=
subroutine phs_none_final (object)
class(phs_none_t), intent(inout) :: object
end subroutine phs_none_final
@ %def phs_none_final
@ Initialization, trivial.
<<PHS none: phs none: TBP>>=
procedure :: init => phs_none_init
<<PHS none: procedures>>=
subroutine phs_none_init (phs, phs_config)
class(phs_none_t), intent(out) :: phs
class(phs_config_t), intent(in), target :: phs_config
call phs%base_init (phs_config)
end subroutine phs_none_init
@ %def phs_none_init
@ Evaluation. This must not be called at all.
<<PHS none: phs none: TBP>>=
procedure :: evaluate_selected_channel => phs_none_evaluate_selected_channel
procedure :: evaluate_other_channels => phs_none_evaluate_other_channels
<<PHS none: procedures>>=
subroutine phs_none_evaluate_selected_channel (phs, c_in, r_in)
class(phs_none_t), intent(inout) :: phs
integer, intent(in) :: c_in
real(default), intent(in), dimension(:) :: r_in
call msg_fatal ("Phase space: attempt to evaluate with the 'phs_none' method")
end subroutine phs_none_evaluate_selected_channel
subroutine phs_none_evaluate_other_channels (phs, c_in)
class(phs_none_t), intent(inout) :: phs
integer, intent(in) :: c_in
end subroutine phs_none_evaluate_other_channels
@ %def phs_none_evaluate_selected_channel
@ %def phs_none_evaluate_other_channels
@ Inverse evaluation, likewise.
<<PHS none: phs none: TBP>>=
procedure :: inverse => phs_none_inverse
<<PHS none: procedures>>=
subroutine phs_none_inverse (phs)
class(phs_none_t), intent(inout) :: phs
call msg_fatal ("Phase space: attempt to evaluate inverse with the 'phs_none' method")
end subroutine phs_none_inverse
@ %def phs_none_inverse
@
\subsection{Unit tests}
Test module, followed by the corresponding implementation module.
<<[[phs_none_ut.f90]]>>=
<<File header>>
module phs_none_ut
use unit_tests
use phs_none_uti
<<Standard module head>>
<<PHS none: public test>>
contains
<<PHS none: test driver>>
end module phs_none_ut
@ %def phs_none_ut
@
<<[[phs_none_uti.f90]]>>=
<<File header>>
module phs_none_uti
<<Use kinds>>
<<Use strings>>
use flavors
use lorentz
use model_data
use process_constants
use phs_base
use phs_none
use phs_base_ut, only: init_test_process_data, init_test_decay_data
<<Standard module head>>
<<PHS none: test declarations>>
contains
<<PHS none: tests>>
end module phs_none_uti
@ %def phs_none_ut
@ API: driver for the unit tests below.
<<PHS none: public test>>=
public :: phs_none_test
<<PHS none: test driver>>=
subroutine phs_none_test (u, results)
integer, intent(in) :: u
type(test_results_t), intent(inout) :: results
<<PHS none: execute tests>>
end subroutine phs_none_test
@ %def phs_none_test
@
\subsubsection{Phase-space configuration data}
Construct and display a test phase-space configuration object. Also
check the [[azimuthal_dependence]] flag.
<<PHS none: execute tests>>=
call test (phs_none_1, "phs_none_1", &
"phase-space configuration dummy", &
u, results)
<<PHS none: test declarations>>=
public :: phs_none_1
<<PHS none: tests>>=
subroutine phs_none_1 (u)
integer, intent(in) :: u
type(model_data_t), target :: model
type(process_constants_t) :: process_data
class(phs_config_t), allocatable :: phs_data
real(default) :: sqrts
write (u, "(A)") "* Test output: phs_none_1"
write (u, "(A)") "* Purpose: display &
&phase-space configuration data"
write (u, "(A)")
allocate (phs_none_config_t :: phs_data)
call phs_data%init (process_data, model)
sqrts = 1000._default
call phs_data%configure (sqrts, azimuthal_dependence=.false.)
call phs_data%write (u)
call phs_data%final ()
call model%final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: phs_none_1"
end subroutine phs_none_1
@ %def phs_none_1
@
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\clearpage
\section{Single-particle phase space}
This module implements the phase space for a single particle, i.e., the solid
angle, in a straightforward parameterization with a single channel. The
phase-space implementation may be used either for $1\to 2$ decays or for $2\to
2$ scattering processes, so the number of incoming particles is the only free
parameter in the configuration. In the latter case, we should restrict its
use to non-resonant s-channel processes, because there is no mapping of the
scattering angle.
(We might extend this later to account for generic $2\to 2$ situations, e.g.,
account for a Coulomb singularity or detect an s-channel resonance structure
that requires matching structure-function mappings.)
This is derived from the [[phs_test]] implementation in the
[[phs_base]] module above, even more simplified, but intended for
actual use.
<<[[phs_single.f90]]>>=
<<File header>>
module phs_single
<<Use kinds>>
<<Use strings>>
use io_units
use constants
use numeric_utils
use diagnostics
use os_interface
use lorentz
use physics_defs
use model_data
use flavors
use process_constants
use phs_base
<<Standard module head>>
<<PHS single: public>>
<<PHS single: types>>
contains
<<PHS single: procedures>>
end module phs_single
@ %def phs_single
@
\subsection{Configuration}
<<PHS single: public>>=
public :: phs_single_config_t
<<PHS single: types>>=
type, extends (phs_config_t) :: phs_single_config_t
contains
<<PHS single: phs single config: TBP>>
end type phs_single_config_t
@ %def phs_single_config_t
@ The finalizer is empty.
<<PHS single: phs single config: TBP>>=
procedure :: final => phs_single_config_final
<<PHS single: procedures>>=
subroutine phs_single_config_final (object)
class(phs_single_config_t), intent(inout) :: object
end subroutine phs_single_config_final
@ %def phs_single_final
@ Output.
<<PHS single: phs single config: TBP>>=
procedure :: write => phs_single_config_write
<<PHS single: procedures>>=
subroutine phs_single_config_write (object, unit, include_id)
class(phs_single_config_t), intent(in) :: object
integer, intent(in), optional :: unit
logical, intent(in), optional :: include_id
integer :: u
u = given_output_unit (unit)
write (u, "(1x,A)") "Partonic phase-space configuration (single-particle):"
call object%base_write (unit)
end subroutine phs_single_config_write
@ %def phs_single_config_write
@ Configuration: there is only one channel and two parameters. The
second parameter is the azimuthal angle, which may be a flat dimension.
<<PHS single: phs single config: TBP>>=
procedure :: configure => phs_single_config_configure
<<PHS single: procedures>>=
subroutine phs_single_config_configure (phs_config, sqrts, &
sqrts_fixed, lab_is_cm, azimuthal_dependence, rebuild, ignore_mismatch, &
nlo_type, subdir)
class(phs_single_config_t), intent(inout) :: phs_config
real(default), intent(in) :: sqrts
logical, intent(in), optional :: sqrts_fixed
logical, intent(in), optional :: lab_is_cm
logical, intent(in), optional :: azimuthal_dependence
logical, intent(in), optional :: rebuild
logical, intent(in), optional :: ignore_mismatch
integer, intent(in), optional :: nlo_type
type(string_t), intent(in), optional :: subdir
if (.not. present (nlo_type)) &
phs_config%nlo_type = BORN
if (phs_config%n_out == 2) then
phs_config%n_channel = 1
phs_config%n_par = 2
phs_config%sqrts = sqrts
if (present (sqrts_fixed)) phs_config%sqrts_fixed = sqrts_fixed
if (present (lab_is_cm)) phs_config%lab_is_cm = lab_is_cm
if (present (azimuthal_dependence)) then
phs_config%azimuthal_dependence = azimuthal_dependence
if (.not. azimuthal_dependence) then
allocate (phs_config%dim_flat (1))
phs_config%dim_flat(1) = 2
end if
end if
if (allocated (phs_config%channel)) deallocate (phs_config%channel)
allocate (phs_config%channel (1))
call phs_config%compute_md5sum ()
else
call msg_fatal ("Single-particle phase space requires n_out = 2")
end if
end subroutine phs_single_config_configure
@ %def phs_single_config_configure
@ Startup message, after configuration is complete.
<<PHS single: phs single config: TBP>>=
procedure :: startup_message => phs_single_config_startup_message
<<PHS single: procedures>>=
subroutine phs_single_config_startup_message (phs_config, unit)
class(phs_single_config_t), intent(in) :: phs_config
integer, intent(in), optional :: unit
call phs_config%base_startup_message (unit)
write (msg_buffer, "(A,2(1x,I0,1x,A))") &
"Phase space: single-particle"
call msg_message (unit = unit)
end subroutine phs_single_config_startup_message
@ %def phs_single_config_startup_message
@ Allocate an instance: the actual phase-space object.
<<PHS single: phs single config: TBP>>=
procedure, nopass :: allocate_instance => phs_single_config_allocate_instance
<<PHS single: procedures>>=
subroutine phs_single_config_allocate_instance (phs)
class(phs_t), intent(inout), pointer :: phs
allocate (phs_single_t :: phs)
end subroutine phs_single_config_allocate_instance
@ %def phs_single_config_allocate_instance
@
\subsection{Kinematics implementation}
We generate $\cos\theta$ and $\phi$ uniformly, covering the solid angle.
Note: The incoming momenta must be in the c.m. system.
<<PHS single: public>>=
public :: phs_single_t
<<PHS single: types>>=
type, extends (phs_t) :: phs_single_t
contains
<<PHS single: phs single: TBP>>
end type phs_single_t
@ %def phs_single_t
@ Output. The [[verbose]] setting is irrelevant, we just display the contents
of the base object.
<<PHS single: phs single: TBP>>=
procedure :: write => phs_single_write
<<PHS single: procedures>>=
subroutine phs_single_write (object, unit, verbose)
class(phs_single_t), intent(in) :: object
integer, intent(in), optional :: unit
logical, intent(in), optional :: verbose
integer :: u
u = given_output_unit (unit)
call object%base_write (u)
end subroutine phs_single_write
@ %def phs_single_write
@ The finalizer is empty.
<<PHS single: phs single: TBP>>=
procedure :: final => phs_single_final
<<PHS single: procedures>>=
subroutine phs_single_final (object)
class(phs_single_t), intent(inout) :: object
end subroutine phs_single_final
@ %def phs_single_final
@ Initialization. We allocate arrays ([[base_init]]) and adjust the
phase-space volume. The massless two-particle phase space volume is
\begin{equation}
\Phi_2 = \frac{1}{4(2\pi)^5} = 2.55294034614 \times 10^{-5}
\end{equation}
For a decay with nonvanishing masses ($m_3$, $m_4$), there is a correction
factor
\begin{equation}
\Phi_2(m) / \Phi_2(0) = \frac{1}{\hat s}
\lambda^{1/2}(\hat s, m_3^2, m_4^2).
\end{equation}
For a scattering process with nonvanishing masses, the correction
factor is
\begin{equation}
\Phi_2(m) / \Phi_2(0) = \frac{1}{\hat s ^ 2}
\lambda^{1/2}(\hat s, m_1^2, m_2^2)\,
\lambda^{1/2}(\hat s, m_3^2, m_4^2).
\end{equation}
If the energy is fixed, this is constant. Otherwise, we have to account for
varying $\hat s$.
<<PHS single: phs single: TBP>>=
procedure :: init => phs_single_init
<<PHS single: procedures>>=
subroutine phs_single_init (phs, phs_config)
class(phs_single_t), intent(out) :: phs
class(phs_config_t), intent(in), target :: phs_config
call phs%base_init (phs_config)
phs%volume = 1 / (4 * twopi5)
call phs%compute_factor ()
end subroutine phs_single_init
@ %def phs_single_init
@ Compute the correction factor for nonzero masses. We do this during
initialization (when the incoming momenta [[p]] are undefined), unless
[[sqrts]] is variable. We do this again once for each phase-space point, but
then we skip the calculation if [[sqrts]] is fixed.
<<PHS single: phs single: TBP>>=
procedure :: compute_factor => phs_single_compute_factor
<<PHS single: procedures>>=
subroutine phs_single_compute_factor (phs)
class(phs_single_t), intent(inout) :: phs
real(default) :: s_hat
select case (phs%config%n_in)
case (1)
if (.not. phs%p_defined) then
if (sum (phs%m_out) < phs%m_in(1)) then
s_hat = phs%m_in(1) ** 2
phs%f(1) = 1 / s_hat &
* sqrt (lambda (s_hat, phs%m_out(1)**2, phs%m_out(2)**2))
else
print *, "m_in = ", phs%m_in
print *, "m_out = ", phs%m_out
call msg_fatal ("Decay is kinematically forbidden")
end if
end if
case (2)
if (phs%config%sqrts_fixed) then
if (phs%p_defined) return
s_hat = phs%config%sqrts ** 2
else
if (.not. phs%p_defined) return
s_hat = sum (phs%p) ** 2
end if
if (sum (phs%m_in)**2 < s_hat .and. sum (phs%m_out)**2 < s_hat) then
phs%f(1) = 1 / s_hat * &
( lambda (s_hat, phs%m_in (1)**2, phs%m_in (2)**2) &
* lambda (s_hat, phs%m_out(1)**2, phs%m_out(2)**2) ) &
** 0.25_default
else
phs%f(1) = 0
end if
end select
end subroutine phs_single_compute_factor
@ %def phs_single_compute_factor
@ Evaluation. We uniformly generate $\cos\theta$ and
$\phi$, with Jacobian normalized to one.
There is only a single channel, so the second subroutine does nothing.
Note: the current implementation works for elastic scattering only.
<<PHS single: phs single: TBP>>=
procedure :: evaluate_selected_channel => phs_single_evaluate_selected_channel
procedure :: evaluate_other_channels => phs_single_evaluate_other_channels
<<PHS single: procedures>>=
subroutine phs_single_evaluate_selected_channel (phs, c_in, r_in)
class(phs_single_t), intent(inout) :: phs
integer, intent(in) :: c_in
real(default), intent(in), dimension(:) :: r_in
if (phs%p_defined) then
call phs%select_channel (c_in)
phs%r(:,c_in) = r_in
select case (phs%config%n_in)
case (2)
if (all (phs%m_in == phs%m_out)) then
call compute_kinematics_solid_angle (phs%p, phs%q, r_in)
else
call msg_bug ("PHS single: inelastic scattering not implemented")
end if
case (1)
call compute_kinematics_solid_angle (phs%decay_p (), phs%q, r_in)
end select
call phs%compute_factor ()
phs%q_defined = .true.
phs%r_defined = .true.
end if
end subroutine phs_single_evaluate_selected_channel
subroutine phs_single_evaluate_other_channels (phs, c_in)
class(phs_single_t), intent(inout) :: phs
integer, intent(in) :: c_in
end subroutine phs_single_evaluate_other_channels
@ %def phs_single_evaluate_selected_channel
@ %def phs_single_evaluate_other_channels
@ Auxiliary: split a decaying particle at rest into the decay products,
aligned along the $z$ axis.
<<PHS single: phs single: TBP>>=
procedure :: decay_p => phs_single_decay_p
<<PHS single: procedures>>=
function phs_single_decay_p (phs) result (p)
class(phs_single_t), intent(in) :: phs
type(vector4_t), dimension(2) :: p
real(default) :: k
real(default), dimension(2) :: E
k = sqrt (lambda (phs%m_in(1) ** 2, phs%m_out(1) ** 2, phs%m_out(2) ** 2)) &
/ (2 * phs%m_in(1))
E = sqrt (phs%m_out ** 2 + k ** 2)
p(1) = vector4_moving (E(1), k, 3)
p(2) = vector4_moving (E(2),-k, 3)
end function phs_single_decay_p
@ %def phs_single_decay_p
@ Inverse evaluation.
<<PHS single: phs single: TBP>>=
procedure :: inverse => phs_single_inverse
<<PHS single: procedures>>=
subroutine phs_single_inverse (phs)
class(phs_single_t), intent(inout) :: phs
real(default), dimension(:), allocatable :: x
if (phs%p_defined .and. phs%q_defined) then
call phs%select_channel ()
allocate (x (phs%config%n_par))
call inverse_kinematics_solid_angle (phs%p, phs%q, x)
phs%r(:,1) = x
call phs%compute_factor ()
phs%r_defined = .true.
end if
end subroutine phs_single_inverse
@ %def phs_single_inverse
@
\subsection{Unit tests}
Test module, followed by the corresponding implementation module.
<<[[phs_single_ut.f90]]>>=
<<File header>>
module phs_single_ut
use unit_tests
use phs_single_uti
<<Standard module head>>
<<PHS single: public test>>
contains
<<PHS single: test driver>>
end module phs_single_ut
@ %def phs_single_ut
@
<<[[phs_single_uti.f90]]>>=
<<File header>>
module phs_single_uti
<<Use kinds>>
<<Use strings>>
use flavors
use lorentz
use model_data
use process_constants
use phs_base
use phs_single
use phs_base_ut, only: init_test_process_data, init_test_decay_data
<<Standard module head>>
<<PHS single: test declarations>>
contains
<<PHS single: tests>>
end module phs_single_uti
@ %def phs_single_ut
@ API: driver for the unit tests below.
<<PHS single: public test>>=
public :: phs_single_test
<<PHS single: test driver>>=
subroutine phs_single_test (u, results)
integer, intent(in) :: u
type(test_results_t), intent(inout) :: results
<<PHS single: execute tests>>
end subroutine phs_single_test
@ %def phs_single_test
@
\subsubsection{Phase-space configuration data}
Construct and display a test phase-space configuration object. Also
check the [[azimuthal_dependence]] flag.
<<PHS single: execute tests>>=
call test (phs_single_1, "phs_single_1", &
"phase-space configuration", &
u, results)
<<PHS single: test declarations>>=
public :: phs_single_1
<<PHS single: tests>>=
subroutine phs_single_1 (u)
integer, intent(in) :: u
type(model_data_t), target :: model
type(process_constants_t) :: process_data
class(phs_config_t), allocatable :: phs_data
real(default) :: sqrts
write (u, "(A)") "* Test output: phs_single_1"
write (u, "(A)") "* Purpose: initialize and display &
&phase-space configuration data"
write (u, "(A)")
call model%init_test ()
write (u, "(A)") "* Initialize a process and a matching &
&phase-space configuration"
write (u, "(A)")
call init_test_process_data (var_str ("phs_single_1"), process_data)
allocate (phs_single_config_t :: phs_data)
call phs_data%init (process_data, model)
sqrts = 1000._default
call phs_data%configure (sqrts, azimuthal_dependence=.false.)
call phs_data%write (u)
call phs_data%final ()
call model%final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: phs_single_1"
end subroutine phs_single_1
@ %def phs_single_1
@
\subsubsection{Phase space evaluation}
Compute kinematics for given parameters, also invert the calculation.
<<PHS single: execute tests>>=
call test (phs_single_2, "phs_single_2", &
"phase-space evaluation", &
u, results)
<<PHS single: test declarations>>=
public :: phs_single_2
<<PHS single: tests>>=
subroutine phs_single_2 (u)
integer, intent(in) :: u
type(model_data_t), target :: model
type(flavor_t) :: flv
type(process_constants_t) :: process_data
real(default) :: sqrts, E
class(phs_config_t), allocatable, target :: phs_data
class(phs_t), pointer :: phs => null ()
type(vector4_t), dimension(2) :: p, q
write (u, "(A)") "* Test output: phs_single_2"
write (u, "(A)") "* Purpose: test simple two-channel phase space"
write (u, "(A)")
call model%init_test ()
call flv%init (25, model)
write (u, "(A)") "* Initialize a process and a matching &
&phase-space configuration"
write (u, "(A)")
call init_test_process_data (var_str ("phs_single_2"), process_data)
allocate (phs_single_config_t :: phs_data)
call phs_data%init (process_data, model)
sqrts = 1000._default
call phs_data%configure (sqrts)
call phs_data%write (u)
write (u, "(A)")
write (u, "(A)") "* Initialize the phase-space instance"
write (u, "(A)")
call phs_data%allocate_instance (phs)
call phs%init (phs_data)
call phs%write (u, verbose=.true.)
write (u, "(A)")
write (u, "(A)") "* Set incoming momenta"
write (u, "(A)")
E = sqrts / 2
p(1) = vector4_moving (E, sqrt (E**2 - flv%get_mass ()**2), 3)
p(2) = vector4_moving (E,-sqrt (E**2 - flv%get_mass ()**2), 3)
call phs%set_incoming_momenta (p)
call phs%compute_flux ()
call phs%write (u)
write (u, "(A)")
write (u, "(A)") "* Compute phase-space point &
&for x = 0.5, 0.125"
write (u, "(A)")
call phs%evaluate_selected_channel (1, [0.5_default, 0.125_default])
call phs%evaluate_other_channels (1)
call phs%write (u)
write (u, "(A)")
write (u, "(A)") "* Inverse kinematics"
write (u, "(A)")
call phs%get_outgoing_momenta (q)
deallocate (phs)
call phs_data%allocate_instance (phs)
call phs%init (phs_data)
sqrts = 1000._default
call phs_data%configure (sqrts)
call phs%set_incoming_momenta (p)
call phs%compute_flux ()
call phs%set_outgoing_momenta (q)
call phs%inverse ()
call phs%write (u)
call phs%final ()
deallocate (phs)
call phs_data%final ()
call model%final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: phs_single_2"
end subroutine phs_single_2
@ %def phs_single_2
@
\subsubsection{Phase space for non-c.m. system}
Compute kinematics for given parameters, also invert the calculation.
Since this will involve cancellations, we call [[pacify]] to eliminate
numerical noise.
<<PHS single: execute tests>>=
call test (phs_single_3, "phs_single_3", &
"phase-space evaluation in lab frame", &
u, results)
<<PHS single: test declarations>>=
public :: phs_single_3
<<PHS single: tests>>=
subroutine phs_single_3 (u)
integer, intent(in) :: u
type(model_data_t), target :: model
type(flavor_t) :: flv
type(process_constants_t) :: process_data
real(default) :: sqrts, E
class(phs_config_t), allocatable, target :: phs_data
class(phs_t), pointer :: phs => null ()
type(vector4_t), dimension(2) :: p, q
type(lorentz_transformation_t) :: lt
write (u, "(A)") "* Test output: phs_single_3"
write (u, "(A)") "* Purpose: test simple two-channel phase space"
write (u, "(A)") "* without c.m. kinematics assumption"
write (u, "(A)")
call model%init_test ()
call flv%init (25, model)
write (u, "(A)") "* Initialize a process and a matching &
&phase-space configuration"
write (u, "(A)")
call init_test_process_data (var_str ("phs_single_3"), process_data)
allocate (phs_single_config_t :: phs_data)
call phs_data%init (process_data, model)
sqrts = 1000._default
call phs_data%configure (sqrts, lab_is_cm=.false., sqrts_fixed=.false.)
call phs_data%write (u)
write (u, "(A)")
write (u, "(A)") "* Initialize the phase-space instance"
write (u, "(A)")
call phs_data%allocate_instance (phs)
call phs%init (phs_data)
call phs%write (u, verbose=.true.)
write (u, "(A)")
write (u, "(A)") "* Set incoming momenta in lab system"
write (u, "(A)")
lt = boost (0.1_default, 1) * boost (0.3_default, 3)
E = sqrts / 2
p(1) = lt * vector4_moving (E, sqrt (E**2 - flv%get_mass ()**2), 3)
p(2) = lt * vector4_moving (E,-sqrt (E**2 - flv%get_mass ()**2), 3)
call vector4_write (p(1), u)
call vector4_write (p(2), u)
write (u, "(A)")
write (u, "(A)") "* Compute phase-space point &
&for x = 0.5, 0.125"
write (u, "(A)")
call phs%set_incoming_momenta (p)
call phs%compute_flux ()
call phs%evaluate_selected_channel (1, [0.5_default, 0.125_default])
call phs%evaluate_other_channels (1)
call pacify (phs)
call phs%write (u)
write (u, "(A)")
write (u, "(A)") "* Extract outgoing momenta in lab system"
write (u, "(A)")
call phs%get_outgoing_momenta (q)
call vector4_write (q(1), u)
call vector4_write (q(2), u)
write (u, "(A)")
write (u, "(A)") "* Inverse kinematics"
write (u, "(A)")
deallocate (phs)
call phs_data%allocate_instance (phs)
call phs%init (phs_data)
sqrts = 1000._default
call phs_data%configure (sqrts)
call phs%set_incoming_momenta (p)
call phs%compute_flux ()
call phs%set_outgoing_momenta (q)
call phs%inverse ()
call pacify (phs)
call phs%write (u)
call phs%final ()
deallocate (phs)
call phs_data%final ()
call model%final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: phs_single_3"
end subroutine phs_single_3
@ %def phs_single_3
@
\subsubsection{Decay Phase space evaluation}
Compute kinematics for given parameters, also invert the calculation. This
time, implement a decay process.
<<PHS single: execute tests>>=
call test (phs_single_4, "phs_single_4", &
"decay phase-space evaluation", &
u, results)
<<PHS single: test declarations>>=
public :: phs_single_4
<<PHS single: tests>>=
subroutine phs_single_4 (u)
integer, intent(in) :: u
type(model_data_t), target :: model
type(flavor_t) :: flv
type(process_constants_t) :: process_data
class(phs_config_t), allocatable, target :: phs_data
class(phs_t), pointer :: phs => null ()
type(vector4_t), dimension(1) :: p
type(vector4_t), dimension(2) :: q
write (u, "(A)") "* Test output: phs_single_4"
write (u, "(A)") "* Purpose: test simple two-channel phase space"
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")))
call flv%init (25, model)
write (u, "(A)") "* Initialize a decay and a matching &
&phase-space configuration"
write (u, "(A)")
call init_test_decay_data (var_str ("phs_single_4"), process_data)
allocate (phs_single_config_t :: phs_data)
call phs_data%init (process_data, model)
call phs_data%configure (flv%get_mass ())
call phs_data%write (u)
write (u, "(A)")
write (u, "(A)") "* Initialize the phase-space instance"
write (u, "(A)")
call phs_data%allocate_instance (phs)
call phs%init (phs_data)
call phs%write (u, verbose=.true.)
write (u, "(A)")
write (u, "(A)") "* Set incoming momenta"
write (u, "(A)")
p(1) = vector4_at_rest (flv%get_mass ())
call phs%set_incoming_momenta (p)
call phs%compute_flux ()
call phs%write (u)
write (u, "(A)")
write (u, "(A)") "* Compute phase-space point &
&for x = 0.5, 0.125"
write (u, "(A)")
call phs%evaluate_selected_channel (1, [0.5_default, 0.125_default])
call phs%evaluate_other_channels (1)
call phs%write (u)
write (u, "(A)")
write (u, "(A)") "* Inverse kinematics"
write (u, "(A)")
call phs%get_outgoing_momenta (q)
deallocate (phs)
call phs_data%allocate_instance (phs)
call phs%init (phs_data)
call phs_data%configure (flv%get_mass ())
call phs%set_incoming_momenta (p)
call phs%compute_flux ()
call phs%set_outgoing_momenta (q)
call phs%inverse ()
call phs%write (u)
call phs%final ()
deallocate (phs)
call phs_data%final ()
call model%final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: phs_single_4"
end subroutine phs_single_4
@ %def phs_single_4
@
\clearpage
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{Flat RAMBO phase space}
This module implements the flat \texttt{RAMBO} phase space for massless and massive particles using the minimal d.o.f $3n - 4$ in a straightforward parameterization with a single channel.
We generate $n$ mass systems $M_i$ with $M_0 = \sqrt{s}$ and $M_{n} = 0$.
We let each mass system decay $1 \rightarrow 2$ in a four-momentum conserving way.
The four-momenta of the two particles are generated back-to-back where we map the d.o.f. to energy, azimuthal and polar angle.
The particle momenta are then boosted to CMS by an appriopriate boost using the kinematics of the parent mass system.
<<[[phs_rambo.f90]]>>=
<<File header>>
module phs_rambo
<<Use kinds>>
<<Use strings>>
use io_units
use constants
use numeric_utils
use format_defs, only: FMT_19
use permutations, only: factorial
use diagnostics
use os_interface
use lorentz
use physics_defs
use model_data
use flavors
use process_constants
use phs_base
<<Standard module head>>
<<PHS rambo: parameters>>
<<PHS rambo: types>>
<<PHS rambo: public>>
contains
<<PHS rambo: procedures>>
end module phs_rambo
@ %def phs_rambo
@
\subsection{Configuration}
<<PHS rambo: public>>=
public :: phs_rambo_config_t
<<PHS rambo: types>>=
type, extends (phs_config_t) :: phs_rambo_config_t
contains
<<PHS rambo: phs rambo config: TBP>>
end type phs_rambo_config_t
@ %def phs_rambo_config_t
@ The finalizer is empty.
<<PHS rambo: phs rambo config: TBP>>=
procedure :: final => phs_rambo_config_final
<<PHS rambo: procedures>>=
subroutine phs_rambo_config_final (object)
class(phs_rambo_config_t), intent(inout) :: object
end subroutine phs_rambo_config_final
@ %def phs_rambo_final
@ Output.
<<PHS rambo: phs rambo config: TBP>>=
procedure :: write => phs_rambo_config_write
<<PHS rambo: procedures>>=
subroutine phs_rambo_config_write (object, unit, include_id)
class(phs_rambo_config_t), intent(in) :: object
integer, intent(in), optional :: unit
logical, intent(in), optional :: include_id
integer :: u
u = given_output_unit (unit)
write (u, "(1x,A)") "Partonic, flat phase-space configuration (RAMBO):"
call object%base_write (unit)
end subroutine phs_rambo_config_write
@ %def phs_rambo_config_write
@ Configuration: there is only one channel and $3n - 4$ parameters.
<<PHS rambo: phs rambo config: TBP>>=
procedure :: configure => phs_rambo_config_configure
<<PHS rambo: procedures>>=
subroutine phs_rambo_config_configure (phs_config, sqrts, &
sqrts_fixed, lab_is_cm, azimuthal_dependence, rebuild, ignore_mismatch, &
nlo_type, subdir)
class(phs_rambo_config_t), intent(inout) :: phs_config
real(default), intent(in) :: sqrts
logical, intent(in), optional :: sqrts_fixed
logical, intent(in), optional :: lab_is_cm
logical, intent(in), optional :: azimuthal_dependence
logical, intent(in), optional :: rebuild
logical, intent(in), optional :: ignore_mismatch
integer, intent(in), optional :: nlo_type
type(string_t), intent(in), optional :: subdir
if (.not. present (nlo_type)) &
phs_config%nlo_type = BORN
if (phs_config%n_out < 2) then
call msg_fatal ("RAMBO phase space requires n_out >= 2")
end if
phs_config%n_channel = 1
phs_config%n_par = 3 * phs_config%n_out - 4
phs_config%sqrts = sqrts
if (present (sqrts_fixed)) phs_config%sqrts_fixed = sqrts_fixed
if (present (lab_is_cm)) phs_config%lab_is_cm = lab_is_cm
if (allocated (phs_config%channel)) deallocate (phs_config%channel)
allocate (phs_config%channel (1))
call phs_config%compute_md5sum ()
end subroutine phs_rambo_config_configure
@ %def phs_rambo_config_configure
@ Startup message, after configuration is complete.
<<PHS rambo: phs rambo config: TBP>>=
procedure :: startup_message => phs_rambo_config_startup_message
<<PHS rambo: procedures>>=
subroutine phs_rambo_config_startup_message (phs_config, unit)
class(phs_rambo_config_t), intent(in) :: phs_config
integer, intent(in), optional :: unit
call phs_config%base_startup_message (unit)
write (msg_buffer, "(A,2(1x,I0,1x,A))") &
"Phase space: flat (RAMBO)"
call msg_message (unit = unit)
end subroutine phs_rambo_config_startup_message
@ %def phs_rambo_config_startup_message
@ Allocate an instance: the actual phase-space object.
<<PHS rambo: phs rambo config: TBP>>=
procedure, nopass :: allocate_instance => phs_rambo_config_allocate_instance
<<PHS rambo: procedures>>=
subroutine phs_rambo_config_allocate_instance (phs)
class(phs_t), intent(inout), pointer :: phs
allocate (phs_rambo_t :: phs)
end subroutine phs_rambo_config_allocate_instance
@ %def phs_rambo_config_allocate_instance
@
\subsection{Kinematics implementation}
We generate $n - 2$ mass systems $M_i$ with $M_0 = \sqrt{s}$ and $M_n = 0$...
Note: The incoming momenta must be in the c.m. system.
<<PHS rambo: public>>=
public :: phs_rambo_t
<<PHS rambo: types>>=
type, extends (phs_t) :: phs_rambo_t
real(default), dimension(:), allocatable :: k
real(default), dimension(:), allocatable :: m
contains
<<PHS rambo: phs rambo: TBP>>
end type phs_rambo_t
@ %def phs_rambo_t
@ Output.
<<PHS rambo: phs rambo: TBP>>=
procedure :: write => phs_rambo_write
<<PHS rambo: procedures>>=
subroutine phs_rambo_write (object, unit, verbose)
class(phs_rambo_t), intent(in) :: object
integer, intent(in), optional :: unit
logical, intent(in), optional :: verbose
integer :: u
u = given_output_unit (unit)
call object%base_write (u)
write (u, "(1X,A)") "Intermediate masses (massless):"
write (u, "(3X,999(" // FMT_19 // "))") object%k
write (u, "(1X,A)") "Intermediate masses (massive):"
write (u, "(3X,999(" // FMT_19 // "))") object%m
end subroutine phs_rambo_write
@ %def phs_rambo_write
@ The finalizer is empty.
<<PHS rambo: phs rambo: TBP>>=
procedure :: final => phs_rambo_final
<<PHS rambo: procedures>>=
subroutine phs_rambo_final (object)
class(phs_rambo_t), intent(inout) :: object
end subroutine phs_rambo_final
@ %def phs_rambo_final
@ Initialization. We allocate arrays ([[base_init]]) and adjust the
phase-space volume.
The energy dependent factor of $s^{n - 2}$ is applied later.
<<PHS rambo: phs rambo: TBP>>=
procedure :: init => phs_rambo_init
<<PHS rambo: procedures>>=
subroutine phs_rambo_init (phs, phs_config)
class(phs_rambo_t), intent(out) :: phs
class(phs_config_t), intent(in), target :: phs_config
call phs%base_init (phs_config)
associate (n => phs%config%n_out)
select case (n)
case (1)
if (sum (phs%m_out) > phs%m_in (1)) then
print *, "m_in = ", phs%m_in
print *, "m_out = ", phs%m_out
call msg_fatal ("[phs_rambo_init] Decay is kinematically forbidden.")
end if
end select
allocate (phs%k(n), source = 0._default)
allocate (phs%m(n), source = 0._default)
phs%volume = 1. / (twopi)**(3 * n) &
* (pi / 2.)**(n - 1) / (factorial(n - 1) * factorial(n - 2))
end associate
end subroutine phs_rambo_init
@ %def phs_rambo_init
@ Evaluation. There is only one channel for RAMBO, so the second subroutine does nothing.
Note: the current implementation works for elastic scattering only.
<<PHS rambo: phs rambo: TBP>>=
procedure :: evaluate_selected_channel => phs_rambo_evaluate_selected_channel
procedure :: evaluate_other_channels => phs_rambo_evaluate_other_channels
<<PHS rambo: procedures>>=
subroutine phs_rambo_evaluate_selected_channel (phs, c_in, r_in)
class(phs_rambo_t), intent(inout) :: phs
integer, intent(in) :: c_in
real(default), intent(in), dimension(:) :: r_in
type(vector4_t), dimension(2) :: p_rest, p_boosted
type(vector4_t) :: q
real(default), dimension(2) :: r_angle
integer :: i
if (.not. phs%p_defined) return
call phs%select_channel (c_in)
phs%r(:,c_in) = r_in
associate (n => phs%config%n_out, m => phs%m)
call phs%generate_intermediates (r_in(:n - 2))
q = sum (phs%p)
do i = 2, n
r_angle(1) = r_in(n - 5 + 2 * i)
r_angle(2) = r_in(n - 4 + 2 * i)
call phs%decay_intermediate (i, r_angle, p_rest)
p_boosted = boost(q, m(i - 1)) * p_rest
q = p_boosted(1)
phs%q(i - 1) = p_boosted(2)
end do
phs%q(n) = q
end associate
phs%q_defined = .true.
phs%r_defined = .true.
end subroutine phs_rambo_evaluate_selected_channel
subroutine phs_rambo_evaluate_other_channels (phs, c_in)
class(phs_rambo_t), intent(inout) :: phs
integer, intent(in) :: c_in
end subroutine phs_rambo_evaluate_other_channels
@ %def phs_rambo_evaluate_selected_channel
@ %def phs_rambo_evaluate_other_channels
@ Decay intermediate mass system $M_{i - 1}$ into a on-shell particle with mass
$m_{i - 1}$ and subsequent intermediate mass system with fixed $M_i$.
<<PHS rambo: phs rambo: TBP>>=
procedure, private :: decay_intermediate => phs_rambo_decay_intermediate
<<PHS rambo: procedures>>=
subroutine phs_rambo_decay_intermediate (phs, i, r_angle, p)
class(phs_rambo_t), intent(in) :: phs
integer, intent(in) :: i
real(default), dimension(2), intent(in) :: r_angle
type(vector4_t), dimension(2), intent(out) :: p
real(default) :: k_abs, cos_theta, phi
type(vector3_t):: k
real(default), dimension(2) :: E
cos_theta = 2. * r_angle(1) - 1.
phi = twopi * r_angle(2)
if (phi > pi) phi = phi - twopi
k_abs = sqrt (lambda (phs%m(i - 1)**2, phs%m(i)**2, phs%m_out(i - 1)**2)) &
/ (2. * phs%m(i - 1))
k = k_abs * [cos(phi) * sqrt(1. - cos_theta**2), &
sin(phi) * sqrt(1. - cos_theta**2), cos_theta]
E(1) = sqrt (phs%m(i)**2 + k_abs**2)
E(2) = sqrt (phs%m_out(i - 1)**2 + k_abs**2)
p(1) = vector4_moving (E(1), -k)
p(2) = vector4_moving (E(2), k)
end subroutine phs_rambo_decay_intermediate
@ %def phs_rambo_decay_intermediate
@ Generate intermediate masses.
<<PHS rambo: parameters>>=
integer, parameter :: BISECT_MAX_ITERATIONS = 1000
real(default), parameter :: BISECT_MIN_PRECISION = tiny_10
<<PHS rambo: phs rambo: TBP>>=
procedure, private :: generate_intermediates => phs_rambo_generate_intermediates
procedure, private :: invert_intermediates => phs_rambo_invert_intermediates
<<PHS rambo: procedures>>=
subroutine phs_rambo_generate_intermediates (phs, r)
class(phs_rambo_t), intent(inout) :: phs
real(default), dimension(:), intent(in) :: r
integer :: i, j
associate (n => phs%config%n_out, k => phs%k, m => phs%m)
m(1) = invariant_mass (sum (phs%p))
m(n) = phs%m_out (n)
call calculate_k (r)
do i = 2, n - 1
m(i) = k(i) + sum (phs%m_out (i:n))
end do
! Massless volume times reweighting for massive volume
phs%f(1) = k(1)**(2 * n - 4) &
* 8. * rho(m(n - 1), phs%m_out(n), phs%m_out(n - 1))
do i = 2, n - 1
phs%f(1) = phs%f(1) * &
rho(m(i - 1), m(i), phs%m_out(i - 1)) / &
rho(k(i - 1), k(i), 0._default) * &
M(i) / K(i)
end do
end associate
contains
subroutine calculate_k (r)
real(default), dimension(:), intent(in) :: r
real(default), dimension(:), allocatable :: u
integer :: i
associate (n => phs%config%n_out, k => phs%k, m => phs%m)
k = 0
k(1) = m(1) - sum(phs%m_out(1:n))
allocate (u(2:n - 1), source=0._default)
call solve_for_u (r, u)
do i = 2, n - 1
k(i) = sqrt (u(i) * k(i - 1)**2)
end do
end associate
end subroutine calculate_k
subroutine solve_for_u (r, u)
real(default), dimension(phs%config%n_out - 2), intent(in) :: r
real(default), dimension(2:phs%config%n_out - 1), intent(out) :: u
integer :: i, j
real(default) :: f, f_mid, xl, xr, xmid
associate (n => phs%config%n_out)
do i = 2, n - 1
xl = 0
xr = 1
if (r(i - 1) == 1 .or. r(i - 1) == 0) then
u(i) = r(i - 1)
else
do j = 1, BISECT_MAX_ITERATIONS
xmid = (xl + xr) / 2.
f = f_rambo (xl, n - i) - r(i - 1)
f_mid = f_rambo (xmid, n - i) - r(i - 1)
if (f * f_mid > 0) then
xl = xmid
else
xr = xmid
end if
if (abs(xl - xr) < BISECT_MIN_PRECISION) exit
end do
u(i) = xmid
end if
end do
end associate
end subroutine solve_for_u
real(default) function f_rambo(u, n)
real(default), intent(in) :: u
integer, intent(in) :: n
f_rambo = (n + 1) * u**n - n * u**(n + 1)
end function f_rambo
real(default) function rho (M1, M2, m)
real(default), intent(in) :: M1, M2, m
real(default) :: MP, MM
rho = sqrt ((M1**2 - (M2 + m)**2) * (M1**2 - (M2 - m)**2))
! MP = (M1 - (M2 + m)) * (M1 + (M2 + m))
! MM = (M1 - (M2 - m)) * (M1 + (M2 - m))
! rho = sqrt (MP) * sqrt (MM)
rho = rho / (8._default * M1**2)
end function rho
end subroutine phs_rambo_generate_intermediates
subroutine phs_rambo_invert_intermediates (phs)
class(phs_rambo_t), intent(inout) :: phs
real(default) :: u
integer :: i
associate (n => phs%config%n_out, k => phs%k, m => phs%m)
k = m
do i = 1, n - 1
k(i) = k(i) - sum (phs%m_out(i:n))
end do
do i = 2, n - 1
u = (k(i) / k(i - 1))**2
phs%r(i - 1, 1) = (n + 1 - i) * u**(n - i) &
- (n - i) * u**(n + 1 - i)
end do
end associate
end subroutine phs_rambo_invert_intermediates
@ %def phs_rambo_generate_intermediates
@ Inverse evaluation.
<<PHS rambo: phs rambo: TBP>>=
procedure :: inverse => phs_rambo_inverse
<<PHS rambo: procedures>>=
subroutine phs_rambo_inverse (phs)
class(phs_rambo_t), intent(inout) :: phs
type(vector4_t), dimension(:), allocatable :: q
type(vector4_t) :: p
type(lorentz_transformation_t) :: L
real(default) :: phi, cos_theta
integer :: i
if (.not. (phs%p_defined .and. phs%q_defined)) return
call phs%select_channel ()
associate (n => phs%config%n_out, m => phs%m)
allocate(q(n))
m(1) = invariant_mass (sum (phs%p))
q(1) = vector4_at_rest (m(1))
q(n) = phs%q(n)
do i = 2, n - 1
q(i) = q(i) + sum (phs%q(i:n))
m(i) = invariant_mass (q(i))
end do
call phs%invert_intermediates ()
do i = 2, n
L = inverse (boost (q(i - 1), m(i - 1)))
p = L * phs%q(i - 1)
phi = azimuthal_angle (p); cos_theta = polar_angle_ct (p)
phs%r(n - 5 + 2 * i, 1) = (cos_theta + 1.) / 2.
phs%r(n - 4 + 2 * i, 1) = phi / twopi
end do
end associate
phs%r_defined = .true.
end subroutine phs_rambo_inverse
@ %def phs_rambo_inverse
@
\subsection{Unit tests}
Test module, followed by the corresponding implementation module.
<<[[phs_rambo_ut.f90]]>>=
<<File header>>
module phs_rambo_ut
use unit_tests
use phs_rambo_uti
<<Standard module head>>
<<PHS rambo: public test>>
contains
<<PHS rambo: test driver>>
end module phs_rambo_ut
@ %def phs_rambo_ut
@
<<[[phs_rambo_uti.f90]]>>=
<<File header>>
module phs_rambo_uti
<<Use kinds>>
<<Use strings>>
use flavors
use lorentz
use model_data
use process_constants
use phs_base
use phs_rambo
use phs_base_ut, only: init_test_process_data, init_test_decay_data
<<Standard module head>>
<<PHS rambo: test declarations>>
contains
<<PHS rambo: tests>>
end module phs_rambo_uti
@ %def phs_rambo_ut
@ API: driver for the unit tests below.
<<PHS rambo: public test>>=
public :: phs_rambo_test
<<PHS rambo: test driver>>=
subroutine phs_rambo_test (u, results)
integer, intent(in) :: u
type(test_results_t), intent(inout) :: results
<<PHS rambo: execute tests>>
end subroutine phs_rambo_test
@ %def phs_rambo_test
@
\subsubsection{Phase-space configuration data}
Construct and display a test phase-space configuration object. Also
check the [[azimuthal_dependence]] flag.
<<PHS rambo: execute tests>>=
call test (phs_rambo_1, "phs_rambo_1", &
"phase-space configuration", &
u, results)
<<PHS rambo: test declarations>>=
public :: phs_rambo_1
<<PHS rambo: tests>>=
subroutine phs_rambo_1 (u)
integer, intent(in) :: u
type(model_data_t), target :: model
type(process_constants_t) :: process_data
class(phs_config_t), allocatable :: phs_data
real(default) :: sqrts
write (u, "(A)") "* Test output: phs_rambo_1"
write (u, "(A)") "* Purpose: initialize and display &
&phase-space configuration data"
write (u, "(A)")
call model%init_test ()
write (u, "(A)") "* Initialize a process and a matching &
&phase-space configuration"
write (u, "(A)")
call init_test_process_data (var_str ("phs_rambo_1"), process_data)
allocate (phs_rambo_config_t :: phs_data)
call phs_data%init (process_data, model)
sqrts = 1000._default
call phs_data%configure (sqrts)
call phs_data%write (u)
call phs_data%final ()
call model%final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: phs_rambo_1"
end subroutine phs_rambo_1
@ %def phs_rambo_1
@
\subsubsection{Phase space evaluation}
Compute kinematics for given parameters, also invert the calculation.
<<PHS rambo: execute tests>>=
call test (phs_rambo_2, "phs_rambo_2", &
"phase-space evaluation", &
u, results)
<<PHS rambo: test declarations>>=
public :: phs_rambo_2
<<PHS rambo: tests>>=
subroutine phs_rambo_2 (u)
integer, intent(in) :: u
type(model_data_t), target :: model
type(flavor_t) :: flv
type(process_constants_t) :: process_data
real(default) :: sqrts, E
class(phs_config_t), allocatable, target :: phs_data
class(phs_t), pointer :: phs => null ()
type(vector4_t), dimension(2) :: p, q
write (u, "(A)") "* Test output: phs_rambo_2"
write (u, "(A)") "* Purpose: test simple two-channel phase space"
write (u, "(A)")
call model%init_test ()
call flv%init (25, model)
write (u, "(A)") "* Initialize a process and a matching &
&phase-space configuration"
write (u, "(A)")
call init_test_process_data (var_str ("phs_rambo_2"), process_data)
allocate (phs_rambo_config_t :: phs_data)
call phs_data%init (process_data, model)
sqrts = 1000._default
call phs_data%configure (sqrts)
call phs_data%write (u)
write (u, "(A)")
write (u, "(A)") "* Initialize the phase-space instance"
write (u, "(A)")
call phs_data%allocate_instance (phs)
call phs%init (phs_data)
call phs%write (u, verbose=.true.)
write (u, "(A)")
write (u, "(A)") "* Set incoming momenta"
write (u, "(A)")
E = sqrts / 2
p(1) = vector4_moving (E, sqrt (E**2 - flv%get_mass ()**2), 3)
p(2) = vector4_moving (E,-sqrt (E**2 - flv%get_mass ()**2), 3)
call phs%set_incoming_momenta (p)
call phs%compute_flux ()
call phs%write (u)
write (u, "(A)")
write (u, "(A)") "* Compute phase-space point &
&for x = 0.5, 0.125"
write (u, "(A)")
call phs%evaluate_selected_channel (1, [0.5_default, 0.125_default])
call phs%evaluate_other_channels (1)
call phs%write (u)
write (u, "(A)")
write (u, "(A)") "* Inverse kinematics"
write (u, "(A)")
call phs%get_outgoing_momenta (q)
deallocate (phs)
call phs_data%allocate_instance (phs)
call phs%init (phs_data)
sqrts = 1000._default
call phs_data%configure (sqrts)
call phs%set_incoming_momenta (p)
call phs%compute_flux ()
call phs%set_outgoing_momenta (q)
call phs%inverse ()
call phs%write (u)
call phs%final ()
deallocate (phs)
call phs_data%final ()
call model%final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: phs_rambo_2"
end subroutine phs_rambo_2
@ %def phs_rambo_2
@
\subsubsection{Phase space for non-c.m. system}
Compute kinematics for given parameters, also invert the calculation.
Since this will involve cancellations, we call [[pacify]] to eliminate
numerical noise.
<<PHS rambo: execute tests>>=
call test (phs_rambo_3, "phs_rambo_3", &
"phase-space evaluation in lab frame", &
u, results)
<<PHS rambo: test declarations>>=
public :: phs_rambo_3
<<PHS rambo: tests>>=
subroutine phs_rambo_3 (u)
integer, intent(in) :: u
type(model_data_t), target :: model
type(flavor_t) :: flv
type(process_constants_t) :: process_data
real(default) :: sqrts, E
class(phs_config_t), allocatable, target :: phs_data
class(phs_t), pointer :: phs => null ()
type(vector4_t), dimension(2) :: p, q
type(lorentz_transformation_t) :: lt
write (u, "(A)") "* Test output: phs_rambo_3"
write (u, "(A)") "* Purpose: phase-space evaluation in lab frame"
write (u, "(A)")
call model%init_test ()
call flv%init (25, model)
write (u, "(A)") "* Initialize a process and a matching &
&phase-space configuration"
write (u, "(A)")
call init_test_process_data (var_str ("phs_rambo_3"), process_data)
allocate (phs_rambo_config_t :: phs_data)
call phs_data%init (process_data, model)
sqrts = 1000._default
call phs_data%configure (sqrts, lab_is_cm=.false., sqrts_fixed=.false.)
call phs_data%write (u)
write (u, "(A)")
write (u, "(A)") "* Initialize the phase-space instance"
write (u, "(A)")
call phs_data%allocate_instance (phs)
call phs%init (phs_data)
call phs%write (u, verbose=.true.)
write (u, "(A)")
write (u, "(A)") "* Set incoming momenta in lab system"
write (u, "(A)")
lt = boost (0.1_default, 1) * boost (0.3_default, 3)
E = sqrts / 2
p(1) = lt * vector4_moving (E, sqrt (E**2 - flv%get_mass ()**2), 3)
p(2) = lt * vector4_moving (E,-sqrt (E**2 - flv%get_mass ()**2), 3)
call vector4_write (p(1), u)
call vector4_write (p(2), u)
write (u, "(A)")
write (u, "(A)") "* Compute phase-space point &
&for x = 0.5, 0.125"
write (u, "(A)")
call phs%set_incoming_momenta (p)
call phs%compute_flux ()
call phs%evaluate_selected_channel (1, [0.5_default, 0.125_default])
call phs%evaluate_other_channels (1)
call pacify (phs)
call phs%write (u)
write (u, "(A)")
write (u, "(A)") "* Extract outgoing momenta in lab system"
write (u, "(A)")
call phs%get_outgoing_momenta (q)
call vector4_write (q(1), u)
call vector4_write (q(2), u)
write (u, "(A)")
write (u, "(A)") "* Inverse kinematics"
write (u, "(A)")
deallocate (phs)
call phs_data%allocate_instance (phs)
call phs%init (phs_data)
sqrts = 1000._default
call phs_data%configure (sqrts)
call phs%set_incoming_momenta (p)
call phs%compute_flux ()
call phs%set_outgoing_momenta (q)
call phs%inverse ()
call pacify (phs)
call phs%write (u)
call phs%final ()
deallocate (phs)
call phs_data%final ()
call model%final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: phs_rambo_3"
end subroutine phs_rambo_3
@ %def phs_rambo_3
@
\subsubsection{Decay Phase space evaluation}
Compute kinematics for given parameters, also invert the calculation. This
time, implement a decay process.
<<PHS rambo: execute tests>>=
call test (phs_rambo_4, "phs_rambo_4", &
"decay phase-space evaluation", &
u, results)
<<PHS rambo: test declarations>>=
public :: phs_rambo_4
<<PHS rambo: tests>>=
subroutine phs_rambo_4 (u)
integer, intent(in) :: u
type(model_data_t), target :: model
type(flavor_t) :: flv
type(process_constants_t) :: process_data
class(phs_config_t), allocatable, target :: phs_data
class(phs_t), pointer :: phs => null ()
type(vector4_t), dimension(1) :: p
type(vector4_t), dimension(2) :: q
write (u, "(A)") "* Test output: phs_rambo_4"
write (u, "(A)") "* Purpose: test simple two-channel phase space"
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")))
call flv%init (25, model)
write (u, "(A)") "* Initialize a decay and a matching &
&phase-space configuration"
write (u, "(A)")
call init_test_decay_data (var_str ("phs_rambo_4"), process_data)
allocate (phs_rambo_config_t :: phs_data)
call phs_data%init (process_data, model)
call phs_data%configure (flv%get_mass ())
call phs_data%write (u)
write (u, "(A)")
write (u, "(A)") "* Initialize the phase-space instance"
write (u, "(A)")
call phs_data%allocate_instance (phs)
call phs%init (phs_data)
call phs%write (u, verbose=.true.)
write (u, "(A)")
write (u, "(A)") "* Set incoming momenta"
write (u, "(A)")
p(1) = vector4_at_rest (flv%get_mass ())
call phs%set_incoming_momenta (p)
call phs%compute_flux ()
call phs%write (u)
write (u, "(A)")
write (u, "(A)") "* Compute phase-space point &
&for x = 0.5, 0.125"
write (u, "(A)")
call phs%evaluate_selected_channel (1, [0.5_default, 0.125_default])
call phs%evaluate_other_channels (1)
call phs%write (u)
write (u, "(A)")
write (u, "(A)") "* Inverse kinematics"
write (u, "(A)")
call phs%get_outgoing_momenta (q)
deallocate (phs)
call phs_data%allocate_instance (phs)
call phs%init (phs_data)
call phs_data%configure (flv%get_mass ())
call phs%set_incoming_momenta (p)
call phs%compute_flux ()
call phs%set_outgoing_momenta (q)
call phs%inverse ()
call phs%write (u)
call phs%final ()
deallocate (phs)
call phs_data%final ()
call model%final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: phs_rambo_4"
end subroutine phs_rambo_4
@ %def phs_rambo_4
@
\clearpage
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{Resonance Handler}
For various purposes (e.g., shower histories), we should extract the set of
resonances and resonant channels from a phase-space tree set. A few methods
do kinematics calculations specifically for those resonance data.
<<[[resonances.f90]]>>=
<<File header>>
module resonances
<<Use kinds>>
<<Use strings>>
<<Use debug>>
use string_utils, only: str
use format_utils, only: write_indent
use io_units
use diagnostics
use lorentz
use constants, only: one
use model_data, only: model_data_t
use flavors, only: flavor_t
<<Standard module head>>
<<Resonances: public>>
<<Resonances: parameters>>
<<Resonances: types>>
contains
<<Resonances: procedures>>
end module resonances
@ %def resonances
@
\subsection{Decay products (contributors)}
This stores the indices of the particles that contribute to a resonance, i.e.,
the decay products.
<<Resonances: public>>=
public :: resonance_contributors_t
<<Resonances: types>>=
type :: resonance_contributors_t
integer, dimension(:), allocatable :: c
contains
<<Resonances: resonance contributors: TBP>>
end type resonance_contributors_t
@ %def resonance_contributors_t
@ Equality (comparison)
<<Resonances: resonance contributors: TBP>>=
procedure, private :: resonance_contributors_equal
generic :: operator(==) => resonance_contributors_equal
<<Resonances: procedures>>=
elemental function resonance_contributors_equal (c1, c2) result (equal)
logical :: equal
class(resonance_contributors_t), intent(in) :: c1, c2
equal = allocated (c1%c) .and. allocated (c2%c)
if (equal) equal = size (c1%c) == size (c2%c)
if (equal) equal = all (c1%c == c2%c)
end function resonance_contributors_equal
@ %def resonance_contributors_equal
@ Assignment
<<Resonances: resonance contributors: TBP>>=
procedure, private :: resonance_contributors_assign
generic :: assignment(=) => resonance_contributors_assign
<<Resonances: procedures>>=
pure subroutine resonance_contributors_assign (contributors_out, contributors_in)
class(resonance_contributors_t), intent(inout) :: contributors_out
class(resonance_contributors_t), intent(in) :: contributors_in
if (allocated (contributors_out%c)) deallocate (contributors_out%c)
if (allocated (contributors_in%c)) then
allocate (contributors_out%c (size (contributors_in%c)))
contributors_out%c = contributors_in%c
end if
end subroutine resonance_contributors_assign
@ %def resonance_contributors_assign
@
\subsection{Resonance info object}
This data structure augments the set of resonance contributors by a flavor
object, such that we can perform calculations that take into
account the particle properties, including mass and width.
Avoiding nameclash with similar but different [[resonance_t]] of
[[phs_base]]:
<<Resonances: public>>=
public :: resonance_info_t
<<Resonances: types>>=
type :: resonance_info_t
type(flavor_t) :: flavor
type(resonance_contributors_t) :: contributors
contains
<<Resonances: resonance info: TBP>>
end type resonance_info_t
@ %def resonance_info_t
@
<<Resonances: resonance info: TBP>>=
procedure :: copy => resonance_info_copy
<<Resonances: procedures>>=
subroutine resonance_info_copy (resonance_in, resonance_out)
class(resonance_info_t), intent(in) :: resonance_in
type(resonance_info_t), intent(out) :: resonance_out
resonance_out%flavor = resonance_in%flavor
if (allocated (resonance_in%contributors%c)) then
associate (c => resonance_in%contributors%c)
allocate (resonance_out%contributors%c (size (c)))
resonance_out%contributors%c = c
end associate
end if
end subroutine resonance_info_copy
@ %def resonance_info_copy
@
<<Resonances: resonance info: TBP>>=
procedure :: write => resonance_info_write
<<Resonances: procedures>>=
subroutine resonance_info_write (resonance, unit, verbose)
class(resonance_info_t), intent(in) :: resonance
integer, optional, intent(in) :: unit
logical, optional, intent(in) :: verbose
integer :: u, i
logical :: verb
u = given_output_unit (unit); if (u < 0) return
verb = .true.; if (present (verbose)) verb = verbose
if (verb) then
write (u, '(A)', advance='no') "Resonance contributors: "
else
write (u, '(1x)', advance="no")
end if
if (allocated (resonance%contributors%c)) then
do i = 1, size(resonance%contributors%c)
write (u, '(I0,1X)', advance='no') resonance%contributors%c(i)
end do
else if (verb) then
write (u, "(A)", advance="no") "[not allocated]"
end if
if (resonance%flavor%is_defined ()) call resonance%flavor%write (u)
write (u, '(A)')
end subroutine resonance_info_write
@ %def resonance_info_write
@ Create a resonance-info object. The particle info may be available
in term of a flavor object or as a PDG code; in the latter case we
have to require a model data object that provides mass and width information.
<<Resonances: resonance info: TBP>>=
procedure, private :: resonance_info_init_pdg
procedure, private :: resonance_info_init_flv
generic :: init => resonance_info_init_pdg, resonance_info_init_flv
<<Resonances: procedures>>=
subroutine resonance_info_init_pdg (resonance, mom_id, pdg, model, n_out)
class(resonance_info_t), intent(out) :: resonance
integer, intent(in) :: mom_id
integer, intent(in) :: pdg, n_out
class(model_data_t), intent(in), target :: model
type(flavor_t) :: flv
if (debug_on) call msg_debug (D_PHASESPACE, "resonance_info_init_pdg")
call flv%init (pdg, model)
call resonance%init (mom_id, flv, n_out)
end subroutine resonance_info_init_pdg
subroutine resonance_info_init_flv (resonance, mom_id, flv, n_out)
class(resonance_info_t), intent(out) :: resonance
integer, intent(in) :: mom_id
type(flavor_t), intent(in) :: flv
integer, intent(in) :: n_out
integer :: i
logical, dimension(n_out) :: contrib
integer, dimension(n_out) :: tmp
if (debug_on) call msg_debug (D_PHASESPACE, "resonance_info_init_flv")
resonance%flavor = flv
do i = 1, n_out
tmp(i) = i
end do
contrib = btest (mom_id, tmp - 1)
allocate (resonance%contributors%c (count (contrib)))
resonance%contributors%c = pack (tmp, contrib)
end subroutine resonance_info_init_flv
@ %def resonance_info_init
@
<<Resonances: resonance info: TBP>>=
procedure, private :: resonance_info_equal
generic :: operator(==) => resonance_info_equal
<<Resonances: procedures>>=
elemental function resonance_info_equal (r1, r2) result (equal)
logical :: equal
class(resonance_info_t), intent(in) :: r1, r2
equal = r1%flavor == r2%flavor .and. r1%contributors == r2%contributors
end function resonance_info_equal
@ %def resonance_info_equal
@ With each resonance region we associate a Breit-Wigner function
\begin{equation*}
P = \frac{M_{res}^4}{(s - M_{res}^2)^2 + \Gamma_{res}^2 M_{res}^2},
\end{equation*}
where $s$ denotes the invariant mass of the outgoing momenta originating
from this resonance. Note that the $M_{res}^4$ in the nominator makes
the mapping a dimensionless quantity.
<<Resonances: resonance info: TBP>>=
procedure :: mapping => resonance_info_mapping
<<Resonances: procedures>>=
function resonance_info_mapping (resonance, s) result (bw)
real(default) :: bw
class(resonance_info_t), intent(in) :: resonance
real(default), intent(in) :: s
real(default) :: m, gamma
if (resonance%flavor%is_defined ()) then
m = resonance%flavor%get_mass ()
gamma = resonance%flavor%get_width ()
bw = m**4 / ((s - m**2)**2 + gamma**2 * m**2)
else
bw = one
end if
end function resonance_info_mapping
@ %def resonance_info_mapping
@ Used for building a resonance tree below.
<<Resonances: resonance info: TBP>>=
procedure, private :: get_n_contributors => resonance_info_get_n_contributors
procedure, private :: contains => resonance_info_contains
<<Resonances: procedures>>=
elemental function resonance_info_get_n_contributors (resonance) result (n)
class(resonance_info_t), intent(in) :: resonance
integer :: n
if (allocated (resonance%contributors%c)) then
n = size (resonance%contributors%c)
else
n = 0
end if
end function resonance_info_get_n_contributors
elemental function resonance_info_contains (resonance, c) result (flag)
class(resonance_info_t), intent(in) :: resonance
integer, intent(in) :: c
logical :: flag
if (allocated (resonance%contributors%c)) then
flag = any (resonance%contributors%c == c)
else
flag = .false.
end if
end function resonance_info_contains
@ %def resonance_info_get_n_contributors
@ %def resonance_info_contains
@
\subsection{Resonance history object}
This data structure stores a set of resonances, i.e., the resonances that
appear in a particular Feynman graph or, in the context of phase space, phase
space diagram.
<<Resonances: public>>=
public :: resonance_history_t
<<Resonances: types>>=
type :: resonance_history_t
type(resonance_info_t), dimension(:), allocatable :: resonances
integer :: n_resonances = 0
contains
<<Resonances: resonance history: TBP>>
end type resonance_history_t
@ %def resonance_history_t
@ Clear the resonance history. Assuming that there are no
pointer-allocated parts, a straightforward [[intent(out)]] will do.
<<Resonances: resonance history: TBP>>=
procedure :: clear => resonance_history_clear
<<Resonances: procedures>>=
subroutine resonance_history_clear (res_hist)
class(resonance_history_t), intent(out) :: res_hist
end subroutine resonance_history_clear
@ %def resonance_history_clear
@
<<Resonances: resonance history: TBP>>=
procedure :: copy => resonance_history_copy
<<Resonances: procedures>>=
subroutine resonance_history_copy (res_hist_in, res_hist_out)
class(resonance_history_t), intent(in) :: res_hist_in
type(resonance_history_t), intent(out) :: res_hist_out
integer :: i
res_hist_out%n_resonances = res_hist_in%n_resonances
allocate (res_hist_out%resonances (size (res_hist_in%resonances)))
do i = 1, size (res_hist_in%resonances)
call res_hist_in%resonances(i)%copy (res_hist_out%resonances(i))
end do
end subroutine resonance_history_copy
@ %def resonance_history_copy
@
<<Resonances: resonance history: TBP>>=
procedure :: write => resonance_history_write
<<Resonances: procedures>>=
subroutine resonance_history_write (res_hist, unit, verbose, indent)
class(resonance_history_t), intent(in) :: res_hist
integer, optional, intent(in) :: unit
logical, optional, intent(in) :: verbose
integer, optional, intent(in) :: indent
integer :: u, i
u = given_output_unit (unit); if (u < 0) return
call write_indent (u, indent)
write(u, '(A,I0,A)') "Resonance history with ", &
res_hist%n_resonances, " resonances:"
do i = 1, res_hist%n_resonances
call write_indent (u, indent)
write (u, "(2x)", advance="no")
call res_hist%resonances(i)%write (u, verbose)
end do
end subroutine resonance_history_write
@ %def resonance_history_write
@ Assignment. Indirectly calls type-bound assignment for the contributors.
Strictly speaking, this is redundant. But NAGfor 6.208 intrinsic assignment
crashes under certain conditions.
<<Resonances: resonance history: TBP>>=
procedure, private :: resonance_history_assign
generic :: assignment(=) => resonance_history_assign
<<Resonances: procedures>>=
subroutine resonance_history_assign (res_hist_out, res_hist_in)
class(resonance_history_t), intent(out) :: res_hist_out
class(resonance_history_t), intent(in) :: res_hist_in
if (allocated (res_hist_in%resonances)) then
res_hist_out%resonances = res_hist_in%resonances
res_hist_out%n_resonances = res_hist_in%n_resonances
end if
end subroutine resonance_history_assign
@ %def resonance_history_assign
@ Equality. If this turns out to slow down the program, we should
change the implementation or use hash codes.
<<Resonances: resonance history: TBP>>=
procedure, private :: resonance_history_equal
generic :: operator(==) => resonance_history_equal
<<Resonances: procedures>>=
elemental function resonance_history_equal (rh1, rh2) result (equal)
logical :: equal
class(resonance_history_t), intent(in) :: rh1, rh2
integer :: i
equal = .false.
if (rh1%n_resonances == rh2%n_resonances) then
do i = 1, rh1%n_resonances
if (.not. rh1%resonances(i) == rh2%resonances(i)) then
return
end if
end do
equal = .true.
end if
end function resonance_history_equal
@ %def resonance_history_equal
@ Check if a resonance history is a strict superset of another one. This is
true if the first one is nonempty and the second one is empty.
Otherwise, we check if each entry of the second argument appears in
the first one.
<<Resonances: resonance history: TBP>>=
procedure, private :: resonance_history_contains
generic :: operator(.contains.) => resonance_history_contains
@
<<Resonances: procedures>>=
elemental function resonance_history_contains (rh1, rh2) result (flag)
logical :: flag
class(resonance_history_t), intent(in) :: rh1, rh2
integer :: i
if (rh1%n_resonances > rh2%n_resonances) then
flag = .true.
do i = 1, rh2%n_resonances
flag = flag .and. any (rh1%resonances == rh2%resonances(i))
end do
else
flag = .false.
end if
end function resonance_history_contains
@ %def resonance_history_contains
@ Number of entries for dynamically extending the resonance-info array.
<<Resonances: parameters>>=
integer, parameter :: n_max_resonances = 10
@
<<Resonances: resonance history: TBP>>=
procedure :: add_resonance => resonance_history_add_resonance
<<Resonances: procedures>>=
subroutine resonance_history_add_resonance (res_hist, resonance)
class(resonance_history_t), intent(inout) :: res_hist
type(resonance_info_t), intent(in) :: resonance
type(resonance_info_t), dimension(:), allocatable :: tmp
integer :: n, i
if (debug_on) call msg_debug (D_PHASESPACE, "resonance_history_add_resonance")
if (.not. allocated (res_hist%resonances)) then
n = 0
allocate (res_hist%resonances (1))
else
n = res_hist%n_resonances
allocate (tmp (n))
do i = 1, n
call res_hist%resonances(i)%copy (tmp(i))
end do
deallocate (res_hist%resonances)
allocate (res_hist%resonances (n+1))
do i = 1, n
call tmp(i)%copy (res_hist%resonances(i))
end do
deallocate (tmp)
end if
call resonance%copy (res_hist%resonances(n+1))
res_hist%n_resonances = n + 1
if (debug_on) call msg_debug &
(D_PHASESPACE, "res_hist%n_resonances", res_hist%n_resonances)
end subroutine resonance_history_add_resonance
@ %def resonance_history_add_resonance
@
<<Resonances: resonance history: TBP>>=
procedure :: remove_resonance => resonance_history_remove_resonance
<<Resonances: procedures>>=
subroutine resonance_history_remove_resonance (res_hist, i_res)
class(resonance_history_t), intent(inout) :: res_hist
integer, intent(in) :: i_res
type(resonance_info_t), dimension(:), allocatable :: tmp_1, tmp_2
integer :: i, j, n
n = res_hist%n_resonances
res_hist%n_resonances = n - 1
if (res_hist%n_resonances == 0) then
deallocate (res_hist%resonances)
else
if (i_res > 1) allocate (tmp_1(1:i_res-1))
if (i_res < n) allocate (tmp_2(i_res+1:n))
if (allocated (tmp_1)) then
do i = 1, i_res - 1
call res_hist%resonances(i)%copy (tmp_1(i))
end do
end if
if (allocated (tmp_2)) then
do i = i_res + 1, n
call res_hist%resonances(i)%copy (tmp_2(i))
end do
end if
deallocate (res_hist%resonances)
allocate (res_hist%resonances (res_hist%n_resonances))
j = 1
if (allocated (tmp_1)) then
do i = 1, i_res - 1
call tmp_1(i)%copy (res_hist%resonances(j))
j = j + 1
end do
deallocate (tmp_1)
end if
if (allocated (tmp_2)) then
do i = i_res + 1, n
call tmp_2(i)%copy (res_hist%resonances(j))
j = j + 1
end do
deallocate (tmp_2)
end if
end if
end subroutine resonance_history_remove_resonance
@ %def resonance_history_remove_resonance
@
<<Resonances: resonance history: TBP>>=
procedure :: add_offset => resonance_history_add_offset
<<Resonances: procedures>>=
subroutine resonance_history_add_offset (res_hist, n)
class(resonance_history_t), intent(inout) :: res_hist
integer, intent(in) :: n
integer :: i_res
do i_res = 1, res_hist%n_resonances
associate (contributors => res_hist%resonances(i_res)%contributors%c)
contributors = contributors + n
end associate
end do
end subroutine resonance_history_add_offset
@ %def resonance_history_add_offset
@
<<Resonances: resonance history: TBP>>=
procedure :: contains_leg => resonance_history_contains_leg
<<Resonances: procedures>>=
function resonance_history_contains_leg (res_hist, i_leg) result (val)
logical :: val
class(resonance_history_t), intent(in) :: res_hist
integer, intent(in) :: i_leg
integer :: i_res
val = .false.
do i_res = 1, res_hist%n_resonances
if (any (res_hist%resonances(i_res)%contributors%c == i_leg)) then
val = .true.
exit
end if
end do
end function resonance_history_contains_leg
@ %def resonance_history_contains_leg
@
<<Resonances: resonance history: TBP>>=
procedure :: mapping => resonance_history_mapping
<<Resonances: procedures>>=
function resonance_history_mapping (res_hist, p, i_gluon) result (p_map)
real(default) :: p_map
class(resonance_history_t), intent(in) :: res_hist
type(vector4_t), intent(in), dimension(:) :: p
integer, intent(in), optional :: i_gluon
integer :: i_res
real(default) :: s
p_map = one
do i_res = 1, res_hist%n_resonances
associate (res => res_hist%resonances(i_res))
s = compute_resonance_mass (p, res%contributors%c, i_gluon)**2
p_map = p_map * res%mapping (s)
end associate
end do
end function resonance_history_mapping
@ %def resonance_history_mapping
@ This predicate is true if all resonances in the history have exactly
[[n]] contributors. For instance, if $n=2$, all resonances have a
two-particle decay.
<<Resonances: resonance history: TBP>>=
procedure :: only_has_n_contributors => resonance_history_only_has_n_contributors
<<Resonances: procedures>>=
function resonance_history_only_has_n_contributors (res_hist, n) result (value)
logical :: value
class(resonance_history_t), intent(in) :: res_hist
integer, intent(in) :: n
integer :: i_res
value = .true.
do i_res = 1, res_hist%n_resonances
associate (res => res_hist%resonances(i_res))
value = value .and. size (res%contributors%c) == n
end associate
end do
end function resonance_history_only_has_n_contributors
@ %def resonance_history_only_has_n_contributors
@
<<Resonances: resonance history: TBP>>=
procedure :: has_flavor => resonance_history_has_flavor
<<Resonances: procedures>>=
function resonance_history_has_flavor (res_hist, flv) result (has_flv)
logical :: has_flv
class(resonance_history_t), intent(in) :: res_hist
type(flavor_t), intent(in) :: flv
integer :: i
has_flv = .false.
do i = 1, res_hist%n_resonances
has_flv = has_flv .or. res_hist%resonances(i)%flavor == flv
end do
end function resonance_history_has_flavor
@ %def resonance_history_has_flavor
@
\subsection{Kinematics}
Evaluate the distance from a resonance. The distance is given by
$|p^2-m^2|/(m\Gamma)$. For $\Gamma\ll m$, this is the relative
distance from the resonance peak in units of the half-width.
<<Resonances: resonance info: TBP>>=
procedure :: evaluate_distance => resonance_info_evaluate_distance
<<Resonances: procedures>>=
subroutine resonance_info_evaluate_distance (res_info, p, dist)
class(resonance_info_t), intent(in) :: res_info
type(vector4_t), dimension(:), intent(in) :: p
real(default), intent(out) :: dist
real(default) :: m, w
type(vector4_t) :: q
m = res_info%flavor%get_mass ()
w = res_info%flavor%get_width ()
q = sum (p(res_info%contributors%c))
dist = abs (q**2 - m**2) / (m * w)
end subroutine resonance_info_evaluate_distance
@ %def resonance_info_evaluate_distance
@
Evaluate the array of distances from a resonance history. We assume that the
array has been allocated with correct size, namely the number of resonances in
this history.
<<Resonances: resonance history: TBP>>=
procedure :: evaluate_distances => resonance_history_evaluate_distances
<<Resonances: procedures>>=
subroutine resonance_history_evaluate_distances (res_hist, p, dist)
class(resonance_history_t), intent(in) :: res_hist
type(vector4_t), dimension(:), intent(in) :: p
real(default), dimension(:), intent(out) :: dist
integer :: i
do i = 1, res_hist%n_resonances
call res_hist%resonances(i)%evaluate_distance (p, dist(i))
end do
end subroutine resonance_history_evaluate_distances
@ %def resonance_history_evaluate_distances
@ Use the distance to determine a Gaussian turnoff factor for a
resonance. The factor is given by a Gaussian function
$e^{-d^2/\sigma^2}$, where $\sigma$ is the [[gw]] parameter multiplied
by the resonance width, and $d$ is the distance (see above). So, for
$d=\sigma$, the factor is $0.37$, and for $d=2\sigma$ we get $0.018$.
If the [[gw]] factor is less or equal to zero, return $1$.
<<Resonances: resonance info: TBP>>=
procedure :: evaluate_gaussian => resonance_info_evaluate_gaussian
<<Resonances: procedures>>=
function resonance_info_evaluate_gaussian (res_info, p, gw) result (factor)
class(resonance_info_t), intent(in) :: res_info
type(vector4_t), dimension(:), intent(in) :: p
real(default), intent(in) :: gw
real(default) :: factor
real(default) :: dist, w
if (gw > 0) then
w = res_info%flavor%get_width ()
call res_info%evaluate_distance (p, dist)
factor = exp (- (dist / (gw * w)) **2)
else
factor = 1
end if
end function resonance_info_evaluate_gaussian
@ %def resonance_info_evaluate_gaussian
@ The Gaussian factor of the history is the product of all factors.
<<Resonances: resonance history: TBP>>=
procedure :: evaluate_gaussian => resonance_history_evaluate_gaussian
<<Resonances: procedures>>=
function resonance_history_evaluate_gaussian (res_hist, p, gw) result (factor)
class(resonance_history_t), intent(in) :: res_hist
type(vector4_t), dimension(:), intent(in) :: p
real(default), intent(in) :: gw
real(default), dimension(:), allocatable :: dist
real(default) :: factor
integer :: i
factor = 1
do i = 1, res_hist%n_resonances
factor = factor * res_hist%resonances(i)%evaluate_gaussian (p, gw)
end do
end function resonance_history_evaluate_gaussian
@ %def resonance_history_evaluate_gaussian
@
Use the distances to determine whether the resonance history can qualify as
on-shell. The criterion is whether the distance is greater than the number of
width values as given by [[on_shell_limit]].
<<Resonances: resonance info: TBP>>=
procedure :: is_on_shell => resonance_info_is_on_shell
<<Resonances: procedures>>=
function resonance_info_is_on_shell (res_info, p, on_shell_limit) &
result (flag)
class(resonance_info_t), intent(in) :: res_info
type(vector4_t), dimension(:), intent(in) :: p
real(default), intent(in) :: on_shell_limit
logical :: flag
real(default) :: dist
call res_info%evaluate_distance (p, dist)
flag = dist < on_shell_limit
end function resonance_info_is_on_shell
@ %def resonance_info_is_on_shell
@
<<Resonances: resonance history: TBP>>=
procedure :: is_on_shell => resonance_history_is_on_shell
<<Resonances: procedures>>=
function resonance_history_is_on_shell (res_hist, p, on_shell_limit) &
result (flag)
class(resonance_history_t), intent(in) :: res_hist
type(vector4_t), dimension(:), intent(in) :: p
real(default), intent(in) :: on_shell_limit
logical :: flag
integer :: i
flag = .true.
do i = 1, res_hist%n_resonances
flag = flag .and. res_hist%resonances(i)%is_on_shell (p, on_shell_limit)
end do
end function resonance_history_is_on_shell
@ %def resonance_history_is_on_shell
@
\subsection{OMega restriction strings}
One application of the resonance module is creating restriction
strings that can be fed into process definitions with the OMega
generator. Since OMega counts the incoming particles first, we have
to supply [[n_in]] as an offset.
<<Resonances: resonance info: TBP>>=
procedure :: as_omega_string => resonance_info_as_omega_string
<<Resonances: resonance history: TBP>>=
procedure :: as_omega_string => resonance_history_as_omega_string
<<Resonances: procedures>>=
function resonance_info_as_omega_string (res_info, n_in) result (string)
class(resonance_info_t), intent(in) :: res_info
integer, intent(in) :: n_in
type(string_t) :: string
integer :: i
string = ""
if (allocated (res_info%contributors%c)) then
do i = 1, size (res_info%contributors%c)
if (i > 1) string = string // "+"
string = string // str (res_info%contributors%c(i) + n_in)
end do
string = string // "~" // res_info%flavor%get_name ()
end if
end function resonance_info_as_omega_string
function resonance_history_as_omega_string (res_hist, n_in) result (string)
class(resonance_history_t), intent(in) :: res_hist
integer, intent(in) :: n_in
type(string_t) :: string
integer :: i
string = ""
do i = 1, res_hist%n_resonances
if (i > 1) string = string // " && "
string = string // res_hist%resonances(i)%as_omega_string (n_in)
end do
end function resonance_history_as_omega_string
@ %def resonance_info_as_omega_string
@ %def resonance_history_as_omega_string
@
\subsection{Resonance history as tree}
If we want to organize the resonances and their decay products, it can be
useful to have them explicitly as a tree structure. We implement this in the
traditional event-record form with the resonances sorted by decreasing number
of contributors, and their decay products added as an extra array.
<<Resonances: public>>=
public :: resonance_tree_t
<<Resonances: types>>=
type :: resonance_branch_t
integer :: i = 0
type(flavor_t) :: flv
integer, dimension(:), allocatable :: r_child
integer, dimension(:), allocatable :: o_child
end type resonance_branch_t
type :: resonance_tree_t
private
integer :: n = 0
type(resonance_branch_t), dimension(:), allocatable :: branch
contains
<<Resonances: resonance tree: TBP>>
end type resonance_tree_t
@ %def resonance_branch_t resonance_tree_t
@
<<Resonances: resonance tree: TBP>>=
procedure :: write => resonance_tree_write
<<Resonances: procedures>>=
subroutine resonance_tree_write (tree, unit, indent)
class(resonance_tree_t), intent(in) :: tree
integer, intent(in), optional :: unit, indent
integer :: u, b, c
u = given_output_unit (unit)
call write_indent (u, indent)
write (u, "(A)", advance="no") "Resonance tree:"
if (tree%n > 0) then
write (u, *)
do b = 1, tree%n
call write_indent (u, indent)
write (u, "(2x,'r',I0,':',1x)", advance="no") b
associate (branch => tree%branch(b))
call branch%flv%write (u)
write (u, "(1x,'=>')", advance="no")
if (allocated (branch%r_child)) then
do c = 1, size (branch%r_child)
write (u, "(1x,'r',I0)", advance="no") branch%r_child(c)
end do
end if
if (allocated (branch%o_child)) then
do c = 1, size (branch%o_child)
write (u, "(1x,I0)", advance="no") branch%o_child(c)
end do
end if
write (u, *)
end associate
end do
else
write (u, "(1x,A)") "[empty]"
end if
end subroutine resonance_tree_write
@ %def resonance_tree_write
@ Contents.
<<Resonances: resonance tree: TBP>>=
procedure :: get_n_resonances => resonance_tree_get_n_resonances
procedure :: get_flv => resonance_tree_get_flv
<<Resonances: procedures>>=
function resonance_tree_get_n_resonances (tree) result (n)
class(resonance_tree_t), intent(in) :: tree
integer :: n
n = tree%n
end function resonance_tree_get_n_resonances
function resonance_tree_get_flv (tree, i) result (flv)
class(resonance_tree_t), intent(in) :: tree
integer, intent(in) :: i
type(flavor_t) :: flv
flv = tree%branch(i)%flv
end function resonance_tree_get_flv
@ %def resonance_tree_get_n_resonances
@ %def resonance_tree_get_flv
@ Return the shifted indices of the resonance children for branch [[i]]. For
a child which is itself a resonance, add [[offset_r]] to the index value. For
the others, add [[offset_o]]. Combine both in a single array.
<<Resonances: resonance tree: TBP>>=
procedure :: get_children => resonance_tree_get_children
<<Resonances: procedures>>=
function resonance_tree_get_children (tree, i, offset_r, offset_o) &
result (child)
class(resonance_tree_t), intent(in) :: tree
integer, intent(in) :: i, offset_r, offset_o
integer, dimension(:), allocatable :: child
integer :: nr, no
associate (branch => tree%branch(i))
nr = size (branch%r_child)
no = size (branch%o_child)
allocate (child (nr + no))
child(1:nr) = branch%r_child + offset_r
child(nr+1:nr+no) = branch%o_child + offset_o
end associate
end function resonance_tree_get_children
@ %def resonance_tree_get_children
@ Transform a resonance history into a resonance tree.
Algorithm:
\begin{enumerate}
\item
Determine a mapping of the resonance array, such that in the new array the
resonances are ordered by decreasing number of contributors.
\item
Copy the flavor entries to the mapped array.
\item
Scan all resonances and, for each one, find a resonance that is its parent.
Since the resonances are ordered, later matches overwrite earlier ones. The
last match is the correct one. Then scan again and, for each resonance,
collect the resonances that have it as parent. This is the set of child
resonances.
\item
Analogously, scan all outgoing particles that appear in any of the
contributors list. Determine their immediate parent as above, and set the
child outgoing parents for the resonances, as above.
\end{enumerate}
<<Resonances: resonance history: TBP>>=
procedure :: to_tree => resonance_history_to_tree
<<Resonances: procedures>>=
subroutine resonance_history_to_tree (res_hist, tree)
class(resonance_history_t), intent(in) :: res_hist
type(resonance_tree_t), intent(out) :: tree
integer :: nr
integer, dimension(:), allocatable :: r_branch, r_source
nr = res_hist%n_resonances
tree%n = nr
allocate (tree%branch (tree%n), r_branch (tree%n), r_source (tree%n))
if (tree%n > 0) then
call find_branch_ordering ()
call set_flavors ()
call set_child_resonances ()
call set_child_outgoing ()
end if
contains
subroutine find_branch_ordering ()
integer, dimension(:), allocatable :: nc_array
integer :: r, ir, nc
allocate (nc_array (tree%n))
nc_array(:) = res_hist%resonances%get_n_contributors ()
ir = 0
do nc = maxval (nc_array), minval (nc_array), -1
do r = 1, nr
if (nc_array(r) == nc) then
ir = ir + 1
r_branch(r) = ir
r_source(ir) = r
end if
end do
end do
end subroutine find_branch_ordering
subroutine set_flavors ()
integer :: r
do r = 1, nr
tree%branch(r_branch(r))%flv = res_hist%resonances(r)%flavor
end do
end subroutine set_flavors
subroutine set_child_resonances ()
integer, dimension(:), allocatable :: r_child, r_parent
integer :: r, ir, pr
allocate (r_parent (nr), source = 0)
SCAN_RES: do r = 1, nr
associate (this_res => res_hist%resonances(r))
SCAN_PARENT: do ir = 1, nr
pr = r_source(ir)
if (pr == r) cycle SCAN_PARENT
if (all (res_hist%resonances(pr)%contains &
(this_res%contributors%c))) then
r_parent (r) = pr
end if
end do SCAN_PARENT
end associate
end do SCAN_RES
allocate (r_child (nr), source = [(r, r = 1, nr)])
do r = 1, nr
ir = r_branch(r)
tree%branch(ir)%r_child = r_branch (pack (r_child, r_parent == r))
end do
end subroutine set_child_resonances
subroutine set_child_outgoing ()
integer, dimension(:), allocatable :: o_child, o_parent
integer :: o_max, r, o, ir
o_max = 0
do r = 1, nr
associate (this_res => res_hist%resonances(r))
o_max = max (o_max, maxval (this_res%contributors%c))
end associate
end do
allocate (o_parent (o_max), source=0)
SCAN_OUT: do o = 1, o_max
SCAN_PARENT: do ir = 1, nr
r = r_source(ir)
associate (this_res => res_hist%resonances(r))
if (this_res%contains (o)) o_parent(o) = r
end associate
end do SCAN_PARENT
end do SCAN_OUT
allocate (o_child (o_max), source = [(o, o = 1, o_max)])
do r = 1, nr
ir = r_branch(r)
tree%branch(ir)%o_child = pack (o_child, o_parent == r)
end do
end subroutine set_child_outgoing
end subroutine resonance_history_to_tree
@ %def resonance_history_to_tree
@
\subsection{Resonance history set}
This is an array of resonance histories. The elements are supposed to
be unique. That is, entering a new element is successful only if the
element does not already exist.
The current implementation uses a straightforward linear search for
comparison. If this should become an issue, we may change the
implementation to a hash table. To keep this freedom, the set should
be an opaque object. In fact, we expect to use it as a transient data
structure. Once the set is complete, we transform it into a
contiguous array.
<<Resonances: public>>=
public :: resonance_history_set_t
<<Resonances: types>>=
type :: index_array_t
integer, dimension(:), allocatable :: i
end type index_array_t
type :: resonance_history_set_t
private
logical :: complete = .false.
integer :: n_filter = 0
type(resonance_history_t), dimension(:), allocatable :: history
type(index_array_t), dimension(:), allocatable :: contains_this
type(resonance_tree_t), dimension(:), allocatable :: tree
integer :: last = 0
contains
<<Resonances: resonance history set: TBP>>
end type resonance_history_set_t
@ %def resonance_history_set_t
@ Display.
The tree-format version of the histories is displayed only upon request.
<<Resonances: resonance history set: TBP>>=
procedure :: write => resonance_history_set_write
<<Resonances: procedures>>=
subroutine resonance_history_set_write (res_set, unit, indent, show_trees)
class(resonance_history_set_t), intent(in) :: res_set
integer, intent(in), optional :: unit
integer, intent(in), optional :: indent
logical, intent(in), optional :: show_trees
logical :: s_trees
integer :: u, i, j, ind
u = given_output_unit (unit)
s_trees = .false.; if (present (show_trees)) s_trees = show_trees
ind = 0; if (present (indent)) ind = indent
call write_indent (u, indent)
write (u, "(A)", advance="no") "Resonance history set:"
if (res_set%complete) then
write (u, *)
else
write (u, "(1x,A)") "[incomplete]"
end if
do i = 1, res_set%last
write (u, "(1x,I0,1x)", advance="no") i
call res_set%history(i)%write (u, verbose=.false., indent=indent)
if (allocated (res_set%contains_this)) then
call write_indent (u, indent)
write (u, "(3x,A)", advance="no") "contained in ("
do j = 1, size (res_set%contains_this(i)%i)
if (j>1) write (u, "(',')", advance="no")
write (u, "(I0)", advance="no") res_set%contains_this(i)%i(j)
end do
write (u, "(A)") ")"
end if
if (s_trees .and. allocated (res_set%tree)) then
call res_set%tree(i)%write (u, ind + 1)
end if
end do
end subroutine resonance_history_set_write
@ %def resonance_history_set_write
@ Initialization. The default initial size is 16 elements, to be doubled in
size repeatedly as needed.
<<Resonances: parameters>>=
integer, parameter :: resonance_history_set_initial_size = 16
@ %def resonance_history_set_initial_size = 16
<<Resonances: resonance history set: TBP>>=
procedure :: init => resonance_history_set_init
<<Resonances: procedures>>=
subroutine resonance_history_set_init (res_set, n_filter, initial_size)
class(resonance_history_set_t), intent(out) :: res_set
integer, intent(in), optional :: n_filter
integer, intent(in), optional :: initial_size
if (present (n_filter)) res_set%n_filter = n_filter
if (present (initial_size)) then
allocate (res_set%history (initial_size))
else
allocate (res_set%history (resonance_history_set_initial_size))
end if
end subroutine resonance_history_set_init
@ %def resonance_history_set_init
@ Enter an entry: append to the array if it does not yet exist, expand
as needed. If a [[n_filter]] value has been provided, enter the
resonance only if it fulfils the requirement.
An empty resonance history is entered only if the [[trivial]] flag is set.
<<Resonances: resonance history set: TBP>>=
procedure :: enter => resonance_history_set_enter
<<Resonances: procedures>>=
subroutine resonance_history_set_enter (res_set, res_history, trivial)
class(resonance_history_set_t), intent(inout) :: res_set
type(resonance_history_t), intent(in) :: res_history
logical, intent(in), optional :: trivial
integer :: i, new
if (res_history%n_resonances == 0) then
if (present (trivial)) then
if (.not. trivial) return
else
return
end if
end if
if (res_set%n_filter > 0) then
if (.not. res_history%only_has_n_contributors (res_set%n_filter)) return
end if
do i = 1, res_set%last
if (res_set%history(i) == res_history) return
end do
new = res_set%last + 1
if (new > size (res_set%history)) call res_set%expand ()
res_set%history(new) = res_history
res_set%last = new
end subroutine resonance_history_set_enter
@ %def resonance_history_set_enter
@ Freeze the resonance history set: determine the array that determines
in which other resonance histories a particular history is contained.
This can only be done once, and once this is done, no further histories can be
entered.
<<Resonances: resonance history set: TBP>>=
procedure :: freeze => resonance_history_set_freeze
<<Resonances: procedures>>=
subroutine resonance_history_set_freeze (res_set)
class(resonance_history_set_t), intent(inout) :: res_set
integer :: i, n, c
logical, dimension(:), allocatable :: contains_this
integer, dimension(:), allocatable :: index_array
n = res_set%last
allocate (contains_this (n))
allocate (index_array (n), source = [(i, i=1, n)])
allocate (res_set%contains_this (n))
do i = 1, n
contains_this = resonance_history_contains &
(res_set%history(1:n), res_set%history(i))
c = count (contains_this)
allocate (res_set%contains_this(i)%i (c))
res_set%contains_this(i)%i = pack (index_array, contains_this)
end do
allocate (res_set%tree (n))
do i = 1, n
call res_set%history(i)%to_tree (res_set%tree(i))
end do
res_set%complete = .true.
end subroutine resonance_history_set_freeze
@ %def resonance_history_set_freeze
@ Determine the histories (in form of their indices in the array) that can be
considered on-shell, given a set of momenta and a maximum distance. The
distance from the resonance is measured in multiples of the resonance width.
Note that the momentum array must only contain the outgoing particles.
If a particular history is on-shell, but there is another history which
contains this and also is on-shell, only the latter is retained.
<<Resonances: resonance history set: TBP>>=
procedure :: determine_on_shell_histories &
=> resonance_history_set_determine_on_shell_histories
<<Resonances: procedures>>=
subroutine resonance_history_set_determine_on_shell_histories &
(res_set, p, on_shell_limit, index_array)
class(resonance_history_set_t), intent(in) :: res_set
type(vector4_t), dimension(:), intent(in) :: p
real(default), intent(in) :: on_shell_limit
integer, dimension(:), allocatable, intent(out) :: index_array
integer :: n, i
integer, dimension(:), allocatable :: i_array
if (res_set%complete) then
n = res_set%last
allocate (i_array (n), source=0)
do i = 1, n
if (res_set%history(i)%is_on_shell (p, on_shell_limit)) i_array(i) = i
end do
do i = 1, n
if (any (i_array(res_set%contains_this(i)%i) /= 0)) then
i_array(i) = 0
end if
end do
allocate (index_array (count (i_array /= 0)))
index_array(:) = pack (i_array, i_array /= 0)
end if
end subroutine resonance_history_set_determine_on_shell_histories
@ %def resonance_history_set_determine_on_shell_histories
@ For the selected history, compute the Gaussian turnoff factor.
The turnoff parameter is [[gw]].
<<Resonances: resonance history set: TBP>>=
procedure :: evaluate_gaussian => resonance_history_set_evaluate_gaussian
<<Resonances: procedures>>=
function resonance_history_set_evaluate_gaussian (res_set, p, gw, i) &
result (factor)
class(resonance_history_set_t), intent(in) :: res_set
type(vector4_t), dimension(:), intent(in) :: p
real(default), intent(in) :: gw
integer, intent(in) :: i
real(default) :: factor
factor = res_set%history(i)%evaluate_gaussian (p, gw)
end function resonance_history_set_evaluate_gaussian
@ %def resonance_history_set_evaluate_gaussian
@ Return the number of histories. This is zero if there are none, or
if [[freeze]] has not been called yet.
<<Resonances: resonance history set: TBP>>=
procedure :: get_n_history => resonance_history_set_get_n_history
<<Resonances: procedures>>=
function resonance_history_set_get_n_history (res_set) result (n)
class(resonance_history_set_t), intent(in) :: res_set
integer :: n
if (res_set%complete) then
n = res_set%last
else
n = 0
end if
end function resonance_history_set_get_n_history
@ %def resonance_history_set_get_n_history
@ Return a single history.
<<Resonances: resonance history set: TBP>>=
procedure :: get_history => resonance_history_set_get_history
<<Resonances: procedures>>=
function resonance_history_set_get_history (res_set, i) result (res_history)
class(resonance_history_set_t), intent(in) :: res_set
integer, intent(in) :: i
type(resonance_history_t) :: res_history
if (res_set%complete .and. i <= res_set%last) then
res_history = res_set%history(i)
end if
end function resonance_history_set_get_history
@ %def resonance_history_set_get_history
@ Conversion to a plain array, sized correctly.
<<Resonances: resonance history set: TBP>>=
procedure :: to_array => resonance_history_set_to_array
<<Resonances: procedures>>=
subroutine resonance_history_set_to_array (res_set, res_history)
class(resonance_history_set_t), intent(in) :: res_set
type(resonance_history_t), dimension(:), allocatable, intent(out) :: res_history
if (res_set%complete) then
allocate (res_history (res_set%last))
res_history(:) = res_set%history(1:res_set%last)
end if
end subroutine resonance_history_set_to_array
@ %def resonance_history_set_to_array
@ Return a selected history in tree form.
<<Resonances: resonance history set: TBP>>=
procedure :: get_tree => resonance_history_set_get_tree
<<Resonances: procedures>>=
subroutine resonance_history_set_get_tree (res_set, i, res_tree)
class(resonance_history_set_t), intent(in) :: res_set
integer, intent(in) :: i
type(resonance_tree_t), intent(out) :: res_tree
if (res_set%complete) then
res_tree = res_set%tree(i)
end if
end subroutine resonance_history_set_get_tree
@ %def resonance_history_set_to_array
@ Expand: double the size of the array. We do not need this in the API.
<<Resonances: resonance history set: TBP>>=
procedure, private :: expand => resonance_history_set_expand
<<Resonances: procedures>>=
subroutine resonance_history_set_expand (res_set)
class(resonance_history_set_t), intent(inout) :: res_set
type(resonance_history_t), dimension(:), allocatable :: history_new
integer :: s
s = size (res_set%history)
allocate (history_new (2 * s))
history_new(1:s) = res_set%history(1:s)
call move_alloc (history_new, res_set%history)
end subroutine resonance_history_set_expand
@ %def resonance_history_set_expand
@
\subsection{Unit tests}
Test module, followed by the corresponding implementation module.
<<[[resonances_ut.f90]]>>=
<<File header>>
module resonances_ut
use unit_tests
use resonances_uti
<<Standard module head>>
<<Resonances: public test>>
contains
<<Resonances: test driver>>
end module resonances_ut
@ %def resonances_ut
@
<<[[resonances_uti.f90]]>>=
<<File header>>
module resonances_uti
<<Use kinds>>
<<Use strings>>
use format_defs, only: FMF_12
use lorentz, only: vector4_t, vector4_at_rest
use model_data, only: model_data_t
use flavors, only: flavor_t
use resonances, only: resonance_history_t
use resonances
<<Standard module head>>
<<Resonances: test declarations>>
contains
<<Resonances: tests>>
end module resonances_uti
@ %def resonances_ut
@ API: driver for the unit tests below.
<<Resonances: public test>>=
public :: resonances_test
<<Resonances: test driver>>=
subroutine resonances_test (u, results)
integer, intent(in) :: u
type(test_results_t), intent(inout) :: results
<<Resonances: execute tests>>
end subroutine resonances_test
@ %def resonances_test
@ Basic operations on a resonance history object.
<<Resonances: execute tests>>=
call test (resonances_1, "resonances_1", &
"check resonance history setup", &
u, results)
<<Resonances: test declarations>>=
public :: resonances_1
<<Resonances: tests>>=
subroutine resonances_1 (u)
integer, intent(in) :: u
type(resonance_info_t) :: res_info
type(resonance_history_t) :: res_history
type(model_data_t), target :: model
write (u, "(A)") "* Test output: resonances_1"
write (u, "(A)") "* Purpose: test resonance history setup"
write (u, "(A)")
write (u, "(A)") "* Read model file"
call model%init_sm_test ()
write (u, "(A)")
write (u, "(A)") "* Empty resonance history"
write (u, "(A)")
call res_history%write (u)
write (u, "(A)")
write (u, "(A)") "* Add resonance"
write (u, "(A)")
call res_info%init (3, -24, model, 5)
call res_history%add_resonance (res_info)
call res_history%write (u)
write (u, "(A)")
write (u, "(A)") "* Add another resonance"
write (u, "(A)")
call res_info%init (7, 23, model, 5)
call res_history%add_resonance (res_info)
call res_history%write (u)
write (u, "(A)")
write (u, "(A)") "* Remove resonance"
write (u, "(A)")
call res_history%remove_resonance (1)
call res_history%write (u)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call model%final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: resonances_1"
end subroutine resonances_1
@ %def resonances_1
@ Basic operations on a resonance history object.
<<Resonances: execute tests>>=
call test (resonances_2, "resonances_2", &
"check O'Mega restriction strings", &
u, results)
<<Resonances: test declarations>>=
public :: resonances_2
<<Resonances: tests>>=
subroutine resonances_2 (u)
integer, intent(in) :: u
type(resonance_info_t) :: res_info
type(resonance_history_t) :: res_history
type(model_data_t), target :: model
type(string_t) :: restrictions
write (u, "(A)") "* Test output: resonances_2"
write (u, "(A)") "* Purpose: test OMega restrictions strings &
&for resonance history"
write (u, "(A)")
write (u, "(A)") "* Read model file"
call model%init_sm_test ()
write (u, "(A)")
write (u, "(A)") "* Empty resonance history"
write (u, "(A)")
restrictions = res_history%as_omega_string (2)
write (u, "(A,A,A)") "restrictions = '", char (restrictions), "'"
write (u, "(A)")
write (u, "(A)") "* Add resonance"
write (u, "(A)")
call res_info%init (3, -24, model, 5)
call res_history%add_resonance (res_info)
restrictions = res_history%as_omega_string (2)
write (u, "(A,A,A)") "restrictions = '", char (restrictions), "'"
write (u, "(A)")
write (u, "(A)") "* Add another resonance"
write (u, "(A)")
call res_info%init (7, 23, model, 5)
call res_history%add_resonance (res_info)
restrictions = res_history%as_omega_string (2)
write (u, "(A,A,A)") "restrictions = '", char (restrictions), "'"
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call model%final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: resonances_2"
end subroutine resonances_2
@ %def resonances_2
@ Basic operations on a resonance history set.
<<Resonances: execute tests>>=
call test (resonances_3, "resonances_3", &
"check resonance history set", &
u, results)
<<Resonances: test declarations>>=
public :: resonances_3
<<Resonances: tests>>=
subroutine resonances_3 (u)
integer, intent(in) :: u
type(resonance_info_t) :: res_info
type(resonance_history_t) :: res_history
type(resonance_history_t), dimension(:), allocatable :: res_histories
type(resonance_history_set_t) :: res_set
type(model_data_t), target :: model
integer :: i
write (u, "(A)") "* Test output: resonances_3"
write (u, "(A)") "* Purpose: test resonance history set"
write (u, "(A)")
write (u, "(A)") "* Read model file"
call model%init_sm_test ()
write (u, "(A)")
write (u, "(A)") "* Initialize resonance history set"
write (u, "(A)")
call res_set%init (initial_size = 2)
write (u, "(A)") "* Add resonance histories, one at a time"
write (u, "(A)")
call res_history%write (u)
call res_set%enter (res_history)
call res_history%clear ()
write (u, *)
call res_info%init (3, -24, model, 5)
call res_history%add_resonance (res_info)
call res_history%write (u)
call res_set%enter (res_history)
call res_history%clear ()
write (u, *)
call res_info%init (3, -24, model, 5)
call res_history%add_resonance (res_info)
call res_info%init (7, 23, model, 5)
call res_history%add_resonance (res_info)
call res_history%write (u)
call res_set%enter (res_history)
call res_history%clear ()
write (u, *)
call res_info%init (7, 23, model, 5)
call res_history%add_resonance (res_info)
call res_history%write (u)
call res_set%enter (res_history)
call res_history%clear ()
write (u, *)
call res_info%init (3, -24, model, 5)
call res_history%add_resonance (res_info)
call res_history%write (u)
call res_set%enter (res_history)
call res_history%clear ()
write (u, *)
call res_info%init (3, -24, model, 5)
call res_history%add_resonance (res_info)
call res_info%init (7, 25, model, 5)
call res_history%add_resonance (res_info)
call res_history%write (u)
call res_set%enter (res_history)
call res_history%clear ()
call res_set%freeze ()
write (u, "(A)")
write (u, "(A)") "* Result"
write (u, "(A)")
call res_set%write (u)
write (u, "(A)")
write (u, "(A)") "* Queries"
write (u, "(A)")
write (u, "(A,1x,I0)") "n_history =", res_set%get_n_history ()
write (u, "(A)")
write (u, "(A)") "History #2:"
res_history = res_set%get_history (2)
call res_history%write (u, indent=1)
call res_history%clear ()
write (u, "(A)")
write (u, "(A)") "* Result in array form"
call res_set%to_array (res_histories)
do i = 1, size (res_histories)
write (u, *)
call res_histories(i)%write (u)
end do
write (u, "(A)")
write (u, "(A)") "* Re-initialize resonance history set with filter n=2"
write (u, "(A)")
call res_set%init (n_filter = 2)
write (u, "(A)") "* Add resonance histories, one at a time"
write (u, "(A)")
call res_info%init (3, -24, model, 5)
call res_history%add_resonance (res_info)
call res_history%write (u)
call res_set%enter (res_history)
call res_history%clear ()
write (u, *)
call res_info%init (3, -24, model, 5)
call res_history%add_resonance (res_info)
call res_info%init (7, 23, model, 5)
call res_history%add_resonance (res_info)
call res_history%write (u)
call res_set%enter (res_history)
call res_history%clear ()
write (u, *)
call res_info%init (7, 23, model, 5)
call res_history%add_resonance (res_info)
call res_history%write (u)
call res_set%enter (res_history)
call res_history%clear ()
write (u, *)
call res_info%init (3, -24, model, 5)
call res_history%add_resonance (res_info)
call res_history%write (u)
call res_set%enter (res_history)
call res_history%clear ()
call res_set%freeze ()
write (u, "(A)")
write (u, "(A)") "* Result"
write (u, "(A)")
call res_set%write (u)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call model%final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: resonances_3"
end subroutine resonances_3
@ %def resonances_3
@ Probe momenta for resonance histories
<<Resonances: execute tests>>=
call test (resonances_4, "resonances_4", &
"resonance history: distance evaluation", &
u, results)
<<Resonances: test declarations>>=
public :: resonances_4
<<Resonances: tests>>=
subroutine resonances_4 (u)
integer, intent(in) :: u
type(resonance_info_t) :: res_info
type(resonance_history_t) :: res_history
type(model_data_t), target :: model
type(flavor_t) :: fw, fz
real(default) :: mw, mz, ww, wz
type(vector4_t), dimension(3) :: p
real(default), dimension(2) :: dist
real(default) :: gw, factor
integer :: i
write (u, "(A)") "* Test output: resonances_4"
write (u, "(A)") "* Purpose: test resonance history evaluation"
write (u, "(A)")
write (u, "(A)") "* Read model file"
call model%init_sm_test ()
write (u, "(A)")
write (u, "(A)") "* W and Z parameters"
write (u, "(A)")
call fw%init (24, model)
call fz%init (23, model)
mw = fw%get_mass ()
ww = fw%get_width ()
mz = fz%get_mass ()
wz = fz%get_width ()
write (u, "(A,1x," // FMF_12 // ")") "mW =", mw
write (u, "(A,1x," // FMF_12 // ")") "wW =", ww
write (u, "(A,1x," // FMF_12 // ")") "mZ =", mz
write (u, "(A,1x," // FMF_12 // ")") "wZ =", wz
write (u, "(A)")
write (u, "(A)") "* Gaussian width parameter"
write (u, "(A)")
gw = 2
write (u, "(A,1x," // FMF_12 // ")") "gw =", gw
write (u, "(A)")
write (u, "(A)") "* Setup resonance histories"
write (u, "(A)")
call res_info%init (3, -24, model, 5)
call res_history%add_resonance (res_info)
call res_info%init (7, 23, model, 5)
call res_history%add_resonance (res_info)
call res_history%write (u)
write (u, "(A)")
write (u, "(A)") "* Setup zero momenta"
write (u, "(A)")
do i = 1, 3
call p(i)%write (u)
end do
write (u, "(A)")
write (u, "(A)") "* Evaluate distances from resonances"
write (u, "(A)")
call res_history%evaluate_distances (p, dist)
write (u, "(A,1x," // FMF_12 // ")") "distance (W) =", dist(1)
write (u, "(A,1x," // FMF_12 // ")") "m/w (W) =", mw / ww
write (u, "(A,1x," // FMF_12 // ")") "distance (Z) =", dist(2)
write (u, "(A,1x," // FMF_12 // ")") "m/w (Z) =", mz / wz
write (u, "(A)")
write (u, "(A)") "* Evaluate Gaussian turnoff factor"
write (u, "(A)")
factor = res_history%evaluate_gaussian (p, gw)
write (u, "(A,1x," // FMF_12 // ")") "gaussian fac =", factor
write (u, "(A)")
write (u, "(A)") "* Set momenta on W peak"
write (u, "(A)")
p(1) = vector4_at_rest (mw/2)
p(2) = vector4_at_rest (mw/2)
do i = 1, 3
call p(i)%write (u)
end do
write (u, "(A)")
write (u, "(A)") "* Evaluate distances from resonances"
write (u, "(A)")
call res_history%evaluate_distances (p, dist)
write (u, "(A,1x," // FMF_12 // ")") "distance (W) =", dist(1)
write (u, "(A,1x," // FMF_12 // ")") "distance (Z) =", dist(2)
write (u, "(A,1x," // FMF_12 // ")") "expected =", &
abs (mz**2 - mw**2) / (mz*wz)
write (u, "(A)")
write (u, "(A)") "* Evaluate Gaussian turnoff factor"
write (u, "(A)")
factor = res_history%evaluate_gaussian (p, gw)
write (u, "(A,1x," // FMF_12 // ")") "gaussian fac =", factor
write (u, "(A,1x," // FMF_12 // ")") "expected =", &
exp (- (abs (mz**2 - mw**2) / (mz*wz))**2 / (gw * wz)**2)
write (u, "(A)")
write (u, "(A)") "* Set momenta on both peaks"
write (u, "(A)")
p(3) = vector4_at_rest (mz - mw)
do i = 1, 3
call p(i)%write (u)
end do
write (u, "(A)")
write (u, "(A)") "* Evaluate distances from resonances"
write (u, "(A)")
call res_history%evaluate_distances (p, dist)
write (u, "(A,1x," // FMF_12 // ")") "distance (W) =", dist(1)
write (u, "(A,1x," // FMF_12 // ")") "distance (Z) =", dist(2)
write (u, "(A)")
write (u, "(A)") "* Evaluate Gaussian turnoff factor"
write (u, "(A)")
factor = res_history%evaluate_gaussian (p, gw)
write (u, "(A,1x," // FMF_12 // ")") "gaussian fac =", factor
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call model%final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: resonances_4"
end subroutine resonances_4
@ %def resonances_4
@ Probe on-shell test for resonance histories
<<Resonances: execute tests>>=
call test (resonances_5, "resonances_5", &
"resonance history: on-shell test", &
u, results)
<<Resonances: test declarations>>=
public :: resonances_5
<<Resonances: tests>>=
subroutine resonances_5 (u)
integer, intent(in) :: u
type(resonance_info_t) :: res_info
type(resonance_history_t) :: res_history
type(resonance_history_set_t) :: res_set
type(model_data_t), target :: model
type(flavor_t) :: fw, fz
real(default) :: mw, mz, ww, wz
real(default) :: on_shell_limit
integer, dimension(:), allocatable :: on_shell
type(vector4_t), dimension(4) :: p
write (u, "(A)") "* Test output: resonances_5"
write (u, "(A)") "* Purpose: resonance history on-shell test"
write (u, "(A)")
write (u, "(A)") "* Read model file"
call model%init_sm_test ()
write (u, "(A)")
write (u, "(A)") "* W and Z parameters"
write (u, "(A)")
call fw%init (24, model)
call fz%init (23, model)
mw = fw%get_mass ()
ww = fw%get_width ()
mz = fz%get_mass ()
wz = fz%get_width ()
write (u, "(A,1x," // FMF_12 // ")") "mW =", mw
write (u, "(A,1x," // FMF_12 // ")") "wW =", ww
write (u, "(A,1x," // FMF_12 // ")") "mZ =", mz
write (u, "(A,1x," // FMF_12 // ")") "wZ =", wz
write (u, "(A)")
write (u, "(A)") "* On-shell parameter: distance as multiple of width"
write (u, "(A)")
on_shell_limit = 3
write (u, "(A,1x," // FMF_12 // ")") "on-shell limit =", on_shell_limit
write (u, "(A)")
write (u, "(A)") "* Setup resonance history set"
write (u, "(A)")
call res_set%init ()
call res_info%init (3, -24, model, 6)
call res_history%add_resonance (res_info)
call res_set%enter (res_history)
call res_history%clear ()
call res_info%init (12, 24, model, 6)
call res_history%add_resonance (res_info)
call res_set%enter (res_history)
call res_history%clear ()
call res_info%init (15, 23, model, 6)
call res_history%add_resonance (res_info)
call res_set%enter (res_history)
call res_history%clear ()
call res_info%init (3, -24, model, 6)
call res_history%add_resonance (res_info)
call res_info%init (15, 23, model, 6)
call res_history%add_resonance (res_info)
call res_set%enter (res_history)
call res_history%clear ()
call res_info%init (12, 24, model, 6)
call res_history%add_resonance (res_info)
call res_info%init (15, 23, model, 6)
call res_history%add_resonance (res_info)
call res_set%enter (res_history)
call res_history%clear ()
call res_set%freeze ()
call res_set%write (u)
write (u, "(A)")
write (u, "(A)") "* Setup zero momenta"
write (u, "(A)")
call write_momenta (p)
call res_set%determine_on_shell_histories (p, on_shell_limit, on_shell)
call write_on_shell_histories (on_shell)
write (u, "(A)")
write (u, "(A)") "* Setup momenta near W- resonance (2 widths off)"
write (u, "(A)")
p(1) = vector4_at_rest (82.5_default)
call write_momenta (p)
call res_set%determine_on_shell_histories (p, on_shell_limit, on_shell)
call write_on_shell_histories (on_shell)
write (u, "(A)")
write (u, "(A)") "* Setup momenta near W- resonance (4 widths off)"
write (u, "(A)")
p(1) = vector4_at_rest (84.5_default)
call write_momenta (p)
call res_set%determine_on_shell_histories (p, on_shell_limit, on_shell)
call write_on_shell_histories (on_shell)
write (u, "(A)")
write (u, "(A)") "* Setup momenta near Z resonance"
write (u, "(A)")
p(1) = vector4_at_rest (45._default)
p(3) = vector4_at_rest (45._default)
call write_momenta (p)
call res_set%determine_on_shell_histories (p, on_shell_limit, on_shell)
call write_on_shell_histories (on_shell)
write (u, "(A)")
write (u, "(A)") "* Setup momenta near W- and W+ resonances"
write (u, "(A)")
p(1) = vector4_at_rest (40._default)
p(2) = vector4_at_rest (40._default)
p(3) = vector4_at_rest (40._default)
p(4) = vector4_at_rest (40._default)
call write_momenta (p)
call res_set%determine_on_shell_histories (p, on_shell_limit, on_shell)
call write_on_shell_histories (on_shell)
write (u, "(A)")
write (u, "(A)") "* Setup momenta near W- and Z resonances, &
&shadowing single resonances"
write (u, "(A)")
p(1) = vector4_at_rest (40._default)
p(2) = vector4_at_rest (40._default)
p(3) = vector4_at_rest (10._default)
p(4) = vector4_at_rest ( 0._default)
call write_momenta (p)
call res_set%determine_on_shell_histories (p, on_shell_limit, on_shell)
call write_on_shell_histories (on_shell)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call model%final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: resonances_5"
contains
subroutine write_momenta (p)
type(vector4_t), dimension(:), intent(in) :: p
integer :: i
do i = 1, size (p)
call p(i)%write (u)
end do
end subroutine write_momenta
subroutine write_on_shell_histories (on_shell)
integer, dimension(:), intent(in) :: on_shell
integer :: i
write (u, *)
write (u, "(A)", advance="no") "on-shell = ("
do i = 1, size (on_shell)
if (i > 1) write (u, "(',')", advance="no")
write (u, "(I0)", advance="no") on_shell(i)
end do
write (u, "(')')")
end subroutine write_on_shell_histories
end subroutine resonances_5
@ %def resonances_5
@ Organize the resonance history as a tree structure.
<<Resonances: execute tests>>=
call test (resonances_6, "resonances_6", &
"check resonance history setup", &
u, results)
<<Resonances: test declarations>>=
public :: resonances_6
<<Resonances: tests>>=
subroutine resonances_6 (u)
integer, intent(in) :: u
type(resonance_info_t) :: res_info
type(resonance_history_t) :: res_history
type(resonance_tree_t) :: res_tree
type(model_data_t), target :: model
write (u, "(A)") "* Test output: resonances_6"
write (u, "(A)") "* Purpose: retrieve resonance histories as trees"
write (u, "(A)")
write (u, "(A)") "* Read model file"
call model%init_sm_test ()
write (u, "(A)")
write (u, "(A)") "* Empty resonance history"
write (u, "(A)")
call res_history%write (u)
write (u, "(A)")
call res_history%to_tree (res_tree)
call res_tree%write (u)
write (u, "(A)")
write (u, "(A)") "* Single resonance"
write (u, "(A)")
call res_info%init (3, -24, model, 5)
call res_history%add_resonance (res_info)
call res_history%write (u)
write (u, "(A)")
call res_history%to_tree (res_tree)
call res_tree%write (u)
write (u, "(A)")
write (u, "(A)") "* Nested resonances"
write (u, "(A)")
call res_info%init (7, 23, model, 5)
call res_history%add_resonance (res_info)
call res_history%write (u)
write (u, "(A)")
call res_history%to_tree (res_tree)
call res_tree%write (u)
write (u, "(A)")
write (u, "(A)") "* Disjunct resonances"
write (u, "(A)")
call res_history%clear ()
call res_info%init (5, 24, model, 7)
call res_history%add_resonance (res_info)
call res_info%init (7, 6, model, 7)
call res_history%add_resonance (res_info)
call res_info%init (80, -24, model, 7)
call res_history%add_resonance (res_info)
call res_info%init (112, -6, model, 7)
call res_history%add_resonance (res_info)
call res_history%write (u)
write (u, "(A)")
call res_history%to_tree (res_tree)
call res_tree%write (u)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call model%final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: resonances_6"
end subroutine resonances_6
@ %def resonances_6
@ Basic operations on a resonance history set.
<<Resonances: execute tests>>=
call test (resonances_7, "resonances_7", &
"display tree format of history set elements", &
u, results)
<<Resonances: test declarations>>=
public :: resonances_7
<<Resonances: tests>>=
subroutine resonances_7 (u)
integer, intent(in) :: u
type(resonance_info_t) :: res_info
type(resonance_history_t) :: res_history
type(resonance_tree_t) :: res_tree
type(resonance_history_set_t) :: res_set
type(model_data_t), target :: model
type(flavor_t) :: flv
write (u, "(A)") "* Test output: resonances_7"
write (u, "(A)") "* Purpose: test tree format"
write (u, "(A)")
write (u, "(A)") "* Read model file"
call model%init_sm_test ()
write (u, "(A)")
write (u, "(A)") "* Initialize, fill and freeze resonance history set"
write (u, "(A)")
call res_set%init (initial_size = 2)
call res_info%init (3, -24, model, 5)
call res_history%add_resonance (res_info)
call res_history%clear ()
call res_info%init (3, -24, model, 5)
call res_history%add_resonance (res_info)
call res_info%init (7, 23, model, 5)
call res_history%add_resonance (res_info)
call res_set%enter (res_history)
call res_history%clear ()
call res_info%init (7, 23, model, 5)
call res_history%add_resonance (res_info)
call res_set%enter (res_history)
call res_history%clear ()
call res_info%init (3, -24, model, 5)
call res_history%add_resonance (res_info)
call res_set%enter (res_history)
call res_history%clear ()
call res_info%init (3, -24, model, 5)
call res_history%add_resonance (res_info)
call res_info%init (7, 25, model, 5)
call res_history%add_resonance (res_info)
call res_set%enter (res_history)
call res_history%clear ()
call res_set%freeze ()
call res_set%write (u, show_trees = .true.)
write (u, "(A)")
write (u, "(A)") "* Extract tree #1"
write (u, "(A)")
call res_set%get_tree (1, res_tree)
call res_tree%write (u)
write (u, *)
write (u, "(1x,A,1x,I0)") "n_resonances =", res_tree%get_n_resonances ()
write (u, *)
write (u, "(1x,A,1x)", advance="no") "flv(r1) ="
flv = res_tree%get_flv (1)
call flv%write (u)
write (u, *)
write (u, "(1x,A,1x)", advance="no") "flv(r2) ="
flv = res_tree%get_flv (2)
call flv%write (u)
write (u, *)
write (u, *)
write (u, "(1x,A)") "[offset = 2, 4]"
write (u, "(1x,A,9(1x,I0))") "children(r1) =", &
res_tree%get_children(1, 2, 4)
write (u, "(1x,A,9(1x,I0))") "children(r2) =", &
res_tree%get_children(2, 2, 4)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call model%final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: resonances_7"
end subroutine resonances_7
@ %def resonances_7
@
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\clearpage
\section{Mappings}
Mappings are objects that encode the transformation of the interval
$(0,1)$ to a physical variable $m^2$ or $\cos\theta$ (and back), as it
is used in the phase space parameterization. The mapping objects
contain fixed parameters, the associated methods implement the mapping
and inverse mapping operations, including the computation of the
Jacobian (phase space factor).
<<[[mappings.f90]]>>=
<<File header>>
module mappings
<<Use kinds>>
use kinds, only: TC
<<Use strings>>
use io_units
use constants, only: pi
use format_defs, only: FMT_19
use diagnostics
use md5
use model_data
use flavors
<<Standard module head>>
<<Mappings: public>>
<<Mappings: parameters>>
<<Mappings: types>>
<<Mappings: interfaces>>
contains
<<Mappings: procedures>>
end module mappings
@ %def mappings
@
\subsection{Default parameters}
This type holds the default parameters, needed for setting the scale
in cases where no mass parameter is available. The contents are public.
<<Mappings: public>>=
public :: mapping_defaults_t
<<Mappings: types>>=
type :: mapping_defaults_t
real(default) :: energy_scale = 10
real(default) :: invariant_mass_scale = 10
real(default) :: momentum_transfer_scale = 10
logical :: step_mapping = .true.
logical :: step_mapping_exp = .true.
logical :: enable_s_mapping = .false.
contains
<<Mappings: mapping defaults: TBP>>
end type mapping_defaults_t
@ %def mapping_defaults_t
@ Output.
<<Mappings: mapping defaults: TBP>>=
procedure :: write => mapping_defaults_write
<<Mappings: procedures>>=
subroutine mapping_defaults_write (object, unit)
class(mapping_defaults_t), intent(in) :: object
integer, intent(in), optional :: unit
integer :: u
u = given_output_unit (unit)
write (u, "(3x,A," // FMT_19 // ")") "energy scale = ", &
object%energy_scale
write (u, "(3x,A," // FMT_19 // ")") "mass scale = ", &
object%invariant_mass_scale
write (u, "(3x,A," // FMT_19 // ")") "q scale = ", &
object%momentum_transfer_scale
write (u, "(3x,A,L1)") "step mapping = ", &
object%step_mapping
write (u, "(3x,A,L1)") "step exp. mode = ", &
object%step_mapping_exp
write (u, "(3x,A,L1)") "allow s mapping = ", &
object%enable_s_mapping
end subroutine mapping_defaults_write
@ %def mapping_defaults_write
@
<<Mappings: public>>=
public :: mapping_defaults_md5sum
<<Mappings: procedures>>=
function mapping_defaults_md5sum (mapping_defaults) result (md5sum_map)
character(32) :: md5sum_map
type(mapping_defaults_t), intent(in) :: mapping_defaults
integer :: u
u = free_unit ()
open (u, status = "scratch")
write (u, *) mapping_defaults%energy_scale
write (u, *) mapping_defaults%invariant_mass_scale
write (u, *) mapping_defaults%momentum_transfer_scale
write (u, *) mapping_defaults%step_mapping
write (u, *) mapping_defaults%step_mapping_exp
write (u, *) mapping_defaults%enable_s_mapping
rewind (u)
md5sum_map = md5sum (u)
close (u)
end function mapping_defaults_md5sum
@ %def mapping_defaults_md5sum
@
\subsection{The Mapping type}
Each mapping has a type (e.g., s-channel, infrared), a binary code
(redundant, but useful for debugging), and a reference particle. The
flavor code of this particle is stored for bookkeeping reasons, what
matters are the mass and width of this particle. Furthermore,
depending on the type, various mapping parameters can be set and used.
The parameters [[a1]] to [[a3]] (for $m^2$ mappings) and [[b1]] to
[[b3]] (for $\cos\theta$ mappings) are values that are stored once to
speed up the calculation, if [[variable_limits]] is false. The exact
meaning of these parameters depends on the mapping type. The limits
are fixed if there is a fixed c.m. energy.
<<Mappings: public>>=
public :: mapping_t
<<Mappings: types>>=
type :: mapping_t
private
integer :: type = NO_MAPPING
integer(TC) :: bincode
type(flavor_t) :: flv
real(default) :: mass = 0
real(default) :: width = 0
logical :: a_unknown = .true.
real(default) :: a1 = 0
real(default) :: a2 = 0
real(default) :: a3 = 0
logical :: b_unknown = .true.
real(default) :: b1 = 0
real(default) :: b2 = 0
real(default) :: b3 = 0
logical :: variable_limits = .true.
contains
<<Mappings: mapping: TBP>>
end type mapping_t
@ %def mapping_t
@ The valid mapping types. The extra type [[STEP_MAPPING]] is used
only internally.
<<Mappings: parameters>>=
<<Mapping modes>>
@
\subsection{Screen output}
Do not write empty mappings.
<<Mappings: public>>=
public :: mapping_write
<<Mappings: procedures>>=
subroutine mapping_write (map, unit, verbose)
type(mapping_t), intent(in) :: map
integer, intent(in), optional :: unit
logical, intent(in), optional :: verbose
integer :: u
character(len=9) :: str
u = given_output_unit (unit); if (u < 0) return
select case(map%type)
case(S_CHANNEL); str = "s_channel"
case(COLLINEAR); str = "collinear"
case(INFRARED); str = "infrared "
case(RADIATION); str = "radiation"
case(T_CHANNEL); str = "t_channel"
case(U_CHANNEL); str = "u_channel"
case(STEP_MAPPING_E); str = "step_exp"
case(STEP_MAPPING_H); str = "step_hyp"
case(ON_SHELL); str = "on_shell"
case default; str = "????????"
end select
if (map%type /= NO_MAPPING) then
write (u, '(1x,A,I4,A)') &
"Branch #", map%bincode, ": " // &
"Mapping (" // str // ") for particle " // &
'"' // char (map%flv%get_name ()) // '"'
if (present (verbose)) then
if (verbose) then
select case (map%type)
case (S_CHANNEL, RADIATION, STEP_MAPPING_E, STEP_MAPPING_H)
write (u, "(1x,A,3(" // FMT_19 // "))") &
" m/w = ", map%mass, map%width
case default
write (u, "(1x,A,3(" // FMT_19 // "))") &
" m = ", map%mass
end select
select case (map%type)
case (S_CHANNEL, T_CHANNEL, U_CHANNEL, &
STEP_MAPPING_E, STEP_MAPPING_H, &
COLLINEAR, INFRARED, RADIATION)
write (u, "(1x,A,3(" // FMT_19 // "))") &
" a1/2/3 = ", map%a1, map%a2, map%a3
end select
select case (map%type)
case (T_CHANNEL, U_CHANNEL, COLLINEAR)
write (u, "(1x,A,3(" // FMT_19 // "))") &
" b1/2/3 = ", map%b1, map%b2, map%b3
end select
end if
end if
end if
end subroutine mapping_write
@ %def mapping_write
@
\subsection{Define a mapping}
The initialization routine sets the mapping type and the particle
(binary code and flavor code) for which the mapping applies (e.g., a
$Z$ resonance in branch \#3).
<<Mappings: public>>=
public :: mapping_init
<<Mappings: procedures>>=
subroutine mapping_init (mapping, bincode, type, f, model)
type(mapping_t), intent(inout) :: mapping
integer(TC), intent(in) :: bincode
type(string_t), intent(in) :: type
integer, intent(in), optional :: f
class(model_data_t), intent(in), optional, target :: model
mapping%bincode = bincode
select case (char (type))
case ("s_channel"); mapping%type = S_CHANNEL
case ("collinear"); mapping%type = COLLINEAR
case ("infrared"); mapping%type = INFRARED
case ("radiation"); mapping%type = RADIATION
case ("t_channel"); mapping%type = T_CHANNEL
case ("u_channel"); mapping%type = U_CHANNEL
case ("step_exp"); mapping%type = STEP_MAPPING_E
case ("step_hyp"); mapping%type = STEP_MAPPING_H
case ("on_shell"); mapping%type = ON_SHELL
case default
call msg_bug ("Mappings: encountered undefined mapping key '" &
// char (type) // "'")
end select
if (present (f) .and. present (model)) call mapping%flv%init (f, model)
end subroutine mapping_init
@ %def mapping_init
@ This sets the actual mass and width, using a parameter set. Since
the auxiliary parameters will only be determined when the mapping is
first called, they are marked as unknown.
<<Mappings: public>>=
public :: mapping_set_parameters
<<Mappings: procedures>>=
subroutine mapping_set_parameters (map, mapping_defaults, variable_limits)
type(mapping_t), intent(inout) :: map
type(mapping_defaults_t), intent(in) :: mapping_defaults
logical, intent(in) :: variable_limits
if (map%type /= NO_MAPPING) then
map%mass = map%flv%get_mass ()
map%width = map%flv%get_width ()
map%variable_limits = variable_limits
map%a_unknown = .true.
map%b_unknown = .true.
select case (map%type)
case (S_CHANNEL)
if (map%mass <= 0) then
call mapping_write (map)
call msg_fatal &
& (" S-channel resonance must have positive mass")
else if (map%width <= 0) then
call mapping_write (map)
call msg_fatal &
& (" S-channel resonance must have positive width")
end if
case (RADIATION)
map%width = max (map%width, mapping_defaults%energy_scale)
case (INFRARED, COLLINEAR)
map%mass = max (map%mass, mapping_defaults%invariant_mass_scale)
case (T_CHANNEL, U_CHANNEL)
map%mass = max (map%mass, mapping_defaults%momentum_transfer_scale)
end select
end if
end subroutine mapping_set_parameters
@ %def mapping_set_code mapping_set_parameters
@ For a step mapping the mass and width are set directly, instead of
being determined from the flavor parameter (which is meaningless
here). They correspond to the effective upper bound of phase space
due to a resonance, as opposed to the absolute upper bound.
<<Mappings: public>>=
public :: mapping_set_step_mapping_parameters
<<Mappings: procedures>>=
subroutine mapping_set_step_mapping_parameters (map, &
mass, width, variable_limits)
type(mapping_t), intent(inout) :: map
real(default), intent(in) :: mass, width
logical, intent(in) :: variable_limits
select case (map%type)
case (STEP_MAPPING_E, STEP_MAPPING_H)
map%variable_limits = variable_limits
map%a_unknown = .true.
map%b_unknown = .true.
map%mass = mass
map%width = width
end select
end subroutine mapping_set_step_mapping_parameters
@ %def mapping_set_step_mapping_parameters
@
\subsection{Retrieve contents}
Return true if there is any / an s-channel mapping.
<<Mappings: public>>=
public :: mapping_is_set
public :: mapping_is_s_channel
public :: mapping_is_on_shell
<<Mappings: mapping: TBP>>=
procedure :: is_set => mapping_is_set
procedure :: is_s_channel => mapping_is_s_channel
procedure :: is_on_shell => mapping_is_on_shell
<<Mappings: procedures>>=
function mapping_is_set (mapping) result (flag)
class(mapping_t), intent(in) :: mapping
logical :: flag
flag = mapping%type /= NO_MAPPING
end function mapping_is_set
function mapping_is_s_channel (mapping) result (flag)
class(mapping_t), intent(in) :: mapping
logical :: flag
flag = mapping%type == S_CHANNEL
end function mapping_is_s_channel
function mapping_is_on_shell (mapping) result (flag)
class(mapping_t), intent(in) :: mapping
logical :: flag
flag = mapping%type == ON_SHELL
end function mapping_is_on_shell
@ %def mapping_is_set
@ %def mapping_is_s_channel
@ %def mapping_is_on_shell
@ Return the binary code for the mapped particle.
<<Mappings: mapping: TBP>>=
procedure :: get_bincode => mapping_get_bincode
<<Mappings: procedures>>=
function mapping_get_bincode (mapping) result (bincode)
class(mapping_t), intent(in) :: mapping
integer(TC) :: bincode
bincode = mapping%bincode
end function mapping_get_bincode
@ %def mapping_get_bincode
@ Return the flavor object for the mapped particle.
<<Mappings: mapping: TBP>>=
procedure :: get_flv => mapping_get_flv
<<Mappings: procedures>>=
function mapping_get_flv (mapping) result (flv)
class(mapping_t), intent(in) :: mapping
type(flavor_t) :: flv
flv = mapping%flv
end function mapping_get_flv
@ %def mapping_get_flv
@ Return stored mass and width, respectively.
<<Mappings: public>>=
public :: mapping_get_mass
public :: mapping_get_width
<<Mappings: procedures>>=
function mapping_get_mass (mapping) result (mass)
real(default) :: mass
type(mapping_t), intent(in) :: mapping
mass = mapping%mass
end function mapping_get_mass
function mapping_get_width (mapping) result (width)
real(default) :: width
type(mapping_t), intent(in) :: mapping
width = mapping%width
end function mapping_get_width
@ %def mapping_get_mass
@ %def mapping_get_width
@
\subsection{Compare mappings}
Equality for single mappings and arrays
<<Mappings: public>>=
public :: operator(==)
<<Mappings: interfaces>>=
interface operator(==)
module procedure mapping_equal
end interface
<<Mappings: procedures>>=
function mapping_equal (m1, m2) result (equal)
type(mapping_t), intent(in) :: m1, m2
logical :: equal
if (m1%type == m2%type) then
select case (m1%type)
case (NO_MAPPING)
equal = .true.
case (S_CHANNEL, RADIATION, STEP_MAPPING_E, STEP_MAPPING_H)
equal = (m1%mass == m2%mass) .and. (m1%width == m2%width)
case default
equal = (m1%mass == m2%mass)
end select
else
equal = .false.
end if
end function mapping_equal
@ %def mapping_equal
@
\subsection{Mappings of the invariant mass}
Inserting an $x$ value between 0 and 1, we want to compute the
corresponding invariant mass $m^2(x)$ and the jacobian, aka phase
space factor $f(x)$. We also need the reverse operation.
In general, the phase space factor $f$ is defined by
\begin{equation}
\frac{1}{s}\int_{m^2_{\textrm{min}}}^{m^2_{\textrm{max}}} dm^2\,g(m^2)
= \int_0^1 dx\,\frac{1}{s}\,\frac{dm^2}{dx}\,g(m^2(x))
= \int_0^1 dx\,f(x)\,g(x),
\end{equation}
where thus
\begin{equation}
f(x) = \frac{1}{s}\,\frac{dm^2}{dx}.
\end{equation}
With this mapping, a function of the form
\begin{equation}
g(m^2) = c\frac{dx(m^2)}{dm^2}
\end{equation}
is mapped to a constant:
\begin{equation}
\frac{1}{s}\int_{m^2_{\textrm{min}}}^{m^2_{\textrm{max}}} dm^2\,g(m^2)
= \int_0^1 dx\,f(x)\,g(m^2(x)) = \int_0^1 dx\,\frac{c}{s}.
\end{equation}
Here is the mapping routine. Input are the available energy
squared [[s]], the limits for $m^2$, and the $x$ value. Output are
the $m^2$ value and the phase space factor $f$.
<<Mappings: public>>=
public :: mapping_compute_msq_from_x
<<Mappings: procedures>>=
subroutine mapping_compute_msq_from_x (map, s, msq_min, msq_max, msq, f, x)
type(mapping_t), intent(inout) :: map
real(default), intent(in) :: s, msq_min, msq_max
real(default), intent(out) :: msq, f
real(default), intent(in) :: x
real(default) :: z, msq0, msq1, tmp
integer :: type
type = map%type
if (s == 0) &
call msg_fatal (" Applying msq mapping for zero energy")
<<Modify mapping type if necessary>>
select case(type)
case (NO_MAPPING)
<<Constants for trivial msq mapping>>
<<Apply trivial msq mapping>>
case (S_CHANNEL)
<<Constants for s-channel resonance mapping>>
<<Apply s-channel resonance mapping>>
case (COLLINEAR, INFRARED, RADIATION)
<<Constants for s-channel pole mapping>>
<<Apply s-channel pole mapping>>
case (T_CHANNEL, U_CHANNEL)
<<Constants for t-channel pole mapping>>
<<Apply t-channel pole mapping>>
case (STEP_MAPPING_E)
<<Constants for exponential step mapping>>
<<Apply exponential step mapping>>
case (STEP_MAPPING_H)
<<Constants for hyperbolic step mapping>>
<<Apply hyperbolic step mapping>>
case default
call msg_fatal ( " Attempt to apply undefined msq mapping")
end select
end subroutine mapping_compute_msq_from_x
@ %def mapping_compute_msq_from_x
@ The inverse mapping
<<Mappings: public>>=
public :: mapping_compute_x_from_msq
<<Mappings: procedures>>=
subroutine mapping_compute_x_from_msq (map, s, msq_min, msq_max, msq, f, x)
type(mapping_t), intent(inout) :: map
real(default), intent(in) :: s, msq_min, msq_max
real(default), intent(in) :: msq
real(default), intent(out) :: f, x
real(default) :: msq0, msq1, tmp, z
integer :: type
type = map%type
if (s == 0) &
call msg_fatal (" Applying inverse msq mapping for zero energy")
<<Modify mapping type if necessary>>
select case (type)
case (NO_MAPPING)
<<Constants for trivial msq mapping>>
<<Apply inverse trivial msq mapping>>
case (S_CHANNEL)
<<Constants for s-channel resonance mapping>>
<<Apply inverse s-channel resonance mapping>>
case (COLLINEAR, INFRARED, RADIATION)
<<Constants for s-channel pole mapping>>
<<Apply inverse s-channel pole mapping>>
case (T_CHANNEL, U_CHANNEL)
<<Constants for t-channel pole mapping>>
<<Apply inverse t-channel pole mapping>>
case (STEP_MAPPING_E)
<<Constants for exponential step mapping>>
<<Apply inverse exponential step mapping>>
case (STEP_MAPPING_H)
<<Constants for hyperbolic step mapping>>
<<Apply inverse hyperbolic step mapping>>
case default
call msg_fatal ( " Attempt to apply undefined msq mapping")
end select
end subroutine mapping_compute_x_from_msq
@ %def mapping_compute_x_from_msq
@
\subsubsection{Trivial mapping}
We simply map the boundaries of the interval $(m_{\textrm{min}},
m_{\textrm{max}})$ to $(0,1)$:
\begin{equation}
m^2 = (1-x) m_{\textrm{min}}^2 + x m_{\textrm{max}}^2;
\end{equation}
the inverse is
\begin{equation}
x = \frac{m^2 - m_{\textrm{min}}^2}{m_{\textrm{max}}^2- m_{\textrm{min}}^2}.
\end{equation}
Hence
\begin{equation}
f(x) = \frac{m_{\textrm{max}}^2 - m_{\textrm{min}}^2}{s},
\end{equation}
and we have, as required,
\begin{equation}
f(x)\,\frac{dx}{dm^2} = \frac{1}{s}.
\end{equation}
We store the constant parameters the first time the mapping is called
-- or, if limits vary, recompute them each time.
<<Constants for trivial msq mapping>>=
if (map%variable_limits .or. map%a_unknown) then
map%a1 = 0
map%a2 = msq_max - msq_min
map%a3 = map%a2 / s
map%a_unknown = .false.
end if
<<Apply trivial msq mapping>>=
msq = (1-x) * msq_min + x * msq_max
f = map%a3
<<Apply inverse trivial msq mapping>>=
if (map%a2 /= 0) then
x = (msq - msq_min) / map%a2
else
x = 0
end if
f = map%a3
@ Resonance or step mapping does not make much sense if the resonance mass is
outside the kinematical bounds. If this is the case, revert to
[[NO_MAPPING]]. This is possible even if the kinematical bounds vary
from event to event.
<<Modify mapping type if necessary>>=
select case (type)
case (S_CHANNEL, STEP_MAPPING_E, STEP_MAPPING_H)
msq0 = map%mass**2
if (msq0 < msq_min .or. msq0 > msq_max) type = NO_MAPPING
end select
@
\subsubsection{Breit-Wigner mapping}
A Breit-Wigner resonance with mass $M$ and width $\Gamma$ is flattened
by the following mapping:
This mapping does not make much sense if the resonance mass is too low.
If this is the case, revert to [[NO_MAPPING]]. There is a tricky
point with this if the mass is too high: [[msq_max]] is not a
constant if structure functions are around. However, switching the
type depending on the overall energy does not change the integral, it
is just another branching point.
\begin{equation}
m^2 = M(M+t\Gamma),
\end{equation}
where
\begin{equation}
t = \tan\left[(1-x)\arctan\frac{m^2_{\textrm{min}} - M^2}{M\Gamma}
+ x \arctan\frac{m^2_{\textrm{max}} - M^2}{M\Gamma}\right].
\end{equation}
The inverse:
\begin{equation}
x = \frac{ \arctan\frac{m^2 - M^2}{M\Gamma}
- \arctan\frac{m^2_{\textrm{min}} - M^2}{M\Gamma}}
{ \arctan\frac{m^2_{\textrm{max}} - M^2}{M\Gamma}
- \arctan\frac{m^2_{\textrm{min}} - M^2}{M\Gamma}}
\end{equation}
The phase-space factor of this transformation is
\begin{equation}
f(x) = \frac{M\Gamma}{s}\left(
\arctan\frac{m^2_{\textrm{max}} - M^2}{M\Gamma}
- \arctan\frac{m^2_{\textrm{min}} - M^2}{M\Gamma}\right)
(1 + t^2).
\end{equation}
This maps any function proportional to
\begin{equation}
g(m^2) = \frac{M\Gamma}{(m^2-M^2)^2 + M^2\Gamma^2}
\end{equation}
to a constant times $1/s$.
<<Constants for s-channel resonance mapping>>=
if (map%variable_limits .or. map%a_unknown) then
msq0 = map%mass ** 2
map%a1 = atan ((msq_min - msq0) / (map%mass * map%width))
map%a2 = atan ((msq_max - msq0) / (map%mass * map%width))
map%a3 = (map%a2 - map%a1) * (map%mass * map%width) / s
map%a_unknown = .false.
end if
<<Apply s-channel resonance mapping>>=
z = (1-x) * map%a1 + x * map%a2
if (-pi/2 < z .and. z < pi/2) then
tmp = tan (z)
msq = map%mass * (map%mass + map%width * tmp)
f = map%a3 * (1 + tmp**2)
else
msq = 0
f = 0
end if
<<Apply inverse s-channel resonance mapping>>=
tmp = (msq - msq0) / (map%mass * map%width)
x = (atan (tmp) - map%a1) / (map%a2 - map%a1)
f = map%a3 * (1 + tmp**2)
@
\subsubsection{Mapping for massless splittings}
This mapping accounts for approximately scale-invariant behavior where
$\ln M^2$ is evenly distributed.
\begin{equation}
m^2 = m_{\textrm{min}}^2 + M^2\left(\exp(xL)-1\right)
\end{equation}
where
\begin{equation}
L = \ln\left(\frac{m_{\textrm{max}}^2 - m_{\textrm{min}}^2}{M^2} + 1\right).
\end{equation}
The inverse:
\begin{equation}
x = \frac1L\ln\left(\frac{m^2-m_{\textrm{min}}^2}{M^2} + 1\right)
\end{equation}
The constant $M$ is a characteristic scale. Above this scale
($m^2-m_{\textrm{min}}^2 \gg M^2$), this mapping behaves like
$x\propto\ln m^2$, while below the scale it reverts to a linear
mapping.
The phase-space factor is
\begin{equation}
f(x) = \frac{M^2}{s}\,\exp(xL)\,L.
\end{equation}
A function proportional to
\begin{equation}
g(m^2) = \frac{1}{(m^2-m_{\textrm{min}}^2) + M^2}
\end{equation}
is mapped to a constant, i.e., a simple pole near $m_{\textrm{min}}$
with a regulator mass $M$.
This type of mapping is useful for massless collinear and infrared
singularities, where the scale is stored as the mass parameter. In
the radiation case (IR radiation off massive particle), the heavy
particle width is the characteristic scale.
<<Constants for s-channel pole mapping>>=
if (map%variable_limits .or. map%a_unknown) then
if (type == RADIATION) then
msq0 = map%width**2
else
msq0 = map%mass**2
end if
map%a1 = msq0
map%a2 = log ((msq_max - msq_min) / msq0 + 1)
map%a3 = map%a2 / s
map%a_unknown = .false.
end if
<<Apply s-channel pole mapping>>=
msq1 = map%a1 * exp (x * map%a2)
msq = msq1 - map%a1 + msq_min
f = map%a3 * msq1
<<Apply inverse s-channel pole mapping>>=
msq1 = msq - msq_min + map%a1
x = log (msq1 / map%a1) / map%a2
f = map%a3 * msq1
@
\subsubsection{Mapping for t-channel poles}
This is also approximately scale-invariant, and we use the same type
of mapping as before. However, we map $1/x$ singularities at both
ends of the interval; again, the mapping becomes linear when the
distance is less than $M^2$:
\begin{equation}
m^2 =
\begin{cases}
m_{\textrm{min}}^2 + M^2\left(\exp(xL)-1\right)
&
\text{for $0 < x < \frac12$}
\\
m_{\textrm{max}}^2 - M^2\left(\exp((1-x)L)-1\right)
&
\text{for $\frac12 \leq x < 1$}
\end{cases}
\end{equation}
where
\begin{equation}
L = 2\ln\left(\frac{m_{\textrm{max}}^2 - m_{\textrm{min}}^2}{2M^2}
+ 1\right).
\end{equation}
The inverse:
\begin{equation}
x =
\begin{cases}
\frac1L\ln\left(\frac{m^2-m_{\textrm{min}}^2}{M^2} + 1\right)
&
\text{for $m^2 < (m_{\textrm{max}}^2 - m_{\textrm{min}}^2)/2$}
\\
1 - \frac1L\ln\left(\frac{m_{\textrm{max}}-m^2}{M^2} + 1\right)
&
\text{for $m^2 \geq (m_{\textrm{max}}^2 - m_{\textrm{min}}^2)/2$}
\end{cases}
\end{equation}
The phase-space factor is
\begin{equation}
f(x) =
\begin{cases}
\frac{M^2}{s}\,\exp(xL)\,L.
&
\text{for $0 < x < \frac12$}
\\
\frac{M^2}{s}\,\exp((1-x)L)\,L.
&
\text{for $\frac12 \leq x < 1$}
\end{cases}
\end{equation}
A (continuous) function proportional to
\begin{equation}
g(m^2) =
\begin{cases}
1/(m^2-m_{\textrm{min}}^2) + M^2)
&
\text{for $m^2 < (m_{\textrm{max}}^2 - m_{\textrm{min}}^2)/2$}
\\
1/((m_{\textrm{max}}^2 - m^2) + M^2)
&
\text{for $m^2 \leq (m_{\textrm{max}}^2 - m_{\textrm{min}}^2)/2$}
\end{cases}
\end{equation}
is mapped to a constant by this mapping, i.e., poles near both ends of
the interval.
<<Constants for t-channel pole mapping>>=
if (map%variable_limits .or. map%a_unknown) then
msq0 = map%mass**2
map%a1 = msq0
map%a2 = 2 * log ((msq_max - msq_min)/(2*msq0) + 1)
map%a3 = map%a2 / s
map%a_unknown = .false.
end if
<<Apply t-channel pole mapping>>=
if (x < .5_default) then
msq1 = map%a1 * exp (x * map%a2)
msq = msq1 - map%a1 + msq_min
else
msq1 = map%a1 * exp ((1-x) * map%a2)
msq = -(msq1 - map%a1) + msq_max
end if
f = map%a3 * msq1
<<Apply inverse t-channel pole mapping>>=
if (msq < (msq_max + msq_min)/2) then
msq1 = msq - msq_min + map%a1
x = log (msq1/map%a1) / map%a2
else
msq1 = msq_max - msq + map%a1
x = 1 - log (msq1/map%a1) / map%a2
end if
f = map%a3 * msq1
@
\subsection{Step mapping}
Step mapping is useful when the allowed range for a squared-mass
variable is large, but only a fraction at the lower end is populated
because the particle in question is an (off-shell) decay product of a
narrow resonance. I.e., if the resonance was forced to be on-shell,
the upper end of the range would be the resonance mass, minus the
effective (real or resonance) mass of the particle(s) in the sibling
branch of the decay.
The edge of this phase space section has a width which is determined
by the width of the parent, plus the width of the sibling branch. (The
widths might be added in quadrature, but this precision is probably
not important.)
\subsubsection{Fermi function}
A possible mapping is derived from the Fermi function which has
precisely this behavior. The Fermi function is given by
\begin{equation}
f(x) = \frac{1}{1 + \exp\frac{x-\mu}{\gamma}}
\end{equation}
where $x$ is taken as the invariant mass squared, $\mu$ is the
invariant mass squared of the edge, and $\gamma$ is the effective
width which is given by the widths of the parent and the sibling
branch. (Widths might be added in quadrature, but we do not require
this level of precision.)
\begin{align}
x &= \frac{m^2 - m_{\text{min}}^2}{\Delta m^2}
\\
\mu &=
\frac{m_{\text{max,eff}}^2 - m_{\text{min}}^2}
{\Delta m^2}
\\
\gamma &= \frac{2m_{\text{max,eff}}\Gamma}{\Delta m^2}
\end{align}
with
\begin{equation}
\Delta m^2 = m_{\text{max}}^2 - m_{\text{min}}^2
\end{equation}
$m^2$ is thus given by
\begin{equation}
m^2(x) = xm_{\text{max}}^2 + (1-x)m_{\text{min}}^2
\end{equation}
For the mapping, we compute the integral $g(x)$ of the Fermi function,
normalized such that $g(0)=0$ and $g(1)=1$. We introduce the abbreviations
\begin{align}
\alpha &= 1 - \gamma\ln\frac{1 + \beta e^{1/\gamma}}{1 + \beta}
\\
\beta &= e^{- \mu/\gamma}
\end{align}
and obtain
\begin{equation}
g(x) = \frac{1}{\alpha}
\left(x - \gamma\ln\frac{1 + \beta e^{x/\gamma}}
{1 + \beta}\right)
\end{equation}
The actual mapping is the inverse function $h(y) = g^{-1}(y)$,
\begin{equation}
h(y) = -\gamma\ln\left(e^{-\alpha y/\gamma}(1 + \beta) - \beta\right)
\end{equation}
The Jacobian is
\begin{equation}
\frac{dh}{dy} = \alpha\left(1 - e^{\alpha y/\gamma}
\frac{\beta}{1 + \beta}\right)^{-1}
\end{equation}
which is equal to $1/(dg/dx)$, namely
\begin{equation}
\frac{dg}{dx} = \frac{1}{\alpha}\,\frac{1}{1 + \beta e^{x/\gamma}}
\end{equation}
The final result is
\begin{align}
\int_{m_{\text{min}}^2}^{m_{\text{max}}^2} dm^2\,F(m^2)
&= \Delta m^2\int_0^1\,dx\,F(m^2(x))
\\
&= \Delta m^2\int_0^1\,dy\,F(m^2(h(y)))\,\frac{dh}{dy}
\end{align}
Here is the implementation. We fill [[a1]], [[a2]], [[a3]] with
$\alpha,\beta,\gamma$, respectively.
<<Constants for exponential step mapping>>=
if (map%variable_limits .or. map%a_unknown) then
map%a3 = max (2 * map%mass * map%width / (msq_max - msq_min), 0.01_default)
map%a2 = exp (- (map%mass**2 - msq_min) / (msq_max - msq_min) &
/ map%a3)
map%a1 = 1 - map%a3 * log ((1 + map%a2 * exp (1 / map%a3)) / (1 + map%a2))
end if
<<Apply exponential step mapping>>=
tmp = exp (- x * map%a1 / map%a3) * (1 + map%a2)
z = - map%a3 * log (tmp - map%a2)
msq = z * msq_max + (1 - z) * msq_min
f = map%a1 / (1 - map%a2 / tmp) * (msq_max - msq_min) / s
<<Apply inverse exponential step mapping>>=
z = (msq - msq_min) / (msq_max - msq_min)
tmp = 1 + map%a2 * exp (z / map%a3)
x = (z - map%a3 * log (tmp / (1 + map%a2))) &
/ map%a1
f = map%a1 * tmp * (msq_max - msq_min) / s
@
\subsubsection{Hyperbolic mapping}
The Fermi function has the drawback that it decreases exponentially.
It might be preferable to take a function with a power-law decrease,
such that the high-mass region is not completely depopulated.
Here, we start with the actual mapping which we take as
\begin{equation}
h(y) = \frac{b}{a-y} - \frac{b}{a} + \mu y
\end{equation}
with the abbreviation
\begin{equation}
a = \frac12\left(1 + \sqrt{1 + \frac{4b}{1-\mu}}\right)
\end{equation}
This is a hyperbola in the $xy$ plane. The derivative is
\begin{equation}
\frac{dh}{dy} = \frac{b}{(a-y)^2} + \mu
\end{equation}
The constants correspond to
\begin{align}
\mu &=
\frac{m_{\text{max,eff}}^2 - m_{\text{min}}^2}
{\Delta m^2}
\\
b &= \frac{1}{\mu}\left(\frac{2m_{\text{max,eff}}\Gamma}{\Delta m^2}\right)^2
\end{align}
The inverse function is the solution of a quadratic equation,
\begin{equation}
g(x) = \frac{1}{2}
\left[\left(a + \frac{x}{\mu} + \frac{b}{a\mu}\right)
- \sqrt{\left(a-\frac{x}{\mu}\right)^2
+ 2\frac{b}{a\mu}\left(a + \frac{x}{\mu}\right)
+ \left(\frac{b}{a\mu}\right)^2}\right]
\end{equation}
The constants $a_{1,2,3}$ are identified with $a,b,\mu$.
<<Constants for hyperbolic step mapping>>=
if (map%variable_limits .or. map%a_unknown) then
map%a3 = (map%mass**2 - msq_min) / (msq_max - msq_min)
map%a2 = max ((2 * map%mass * map%width / (msq_max - msq_min))**2 &
/ map%a3, 1e-6_default)
map%a1 = (1 + sqrt (1 + 4 * map%a2 / (1 - map%a3))) / 2
end if
<<Apply hyperbolic step mapping>>=
z = map%a2 / (map%a1 - x) - map%a2 / map%a1 + map%a3 * x
msq = z * msq_max + (1 - z) * msq_min
f = (map%a2 / (map%a1 - x)**2 + map%a3) * (msq_max - msq_min) / s
<<Apply inverse hyperbolic step mapping>>=
z = (msq - msq_min) / (msq_max - msq_min)
tmp = map%a2 / (map%a1 * map%a3)
x = ((map%a1 + z / map%a3 + tmp) &
- sqrt ((map%a1 - z / map%a3)**2 + 2 * tmp * (map%a1 + z / map%a3) &
+ tmp**2)) / 2
f = (map%a2 / (map%a1 - x)**2 + map%a3) * (msq_max - msq_min) / s
@
\subsection{Mappings of the polar angle}
The other type of singularity, a simple pole just outside the
integration region, can occur in the integration over $\cos\theta$.
This applies to exchange of massless (or light) particles.
Double poles (Coulomb scattering) are also possible, but only in
certain cases. These are also handled by the single-pole mapping.
The mapping is analogous to the previous $m^2$ pole mapping, but with
a different normalization and notation of variables:
\begin{equation}
\frac12\int_{-1}^1 d\cos\theta\,g(\theta)
= \int_0^1 dx\,\frac{d\cos\theta}{dx}\,g(\theta(x))
= \int_0^1 dx\,f(x)\,g(x),
\end{equation}
where thus
\begin{equation}
f(x) = \frac12\,\frac{d\cos\theta}{dx}.
\end{equation}
With this mapping, a function of the form
\begin{equation}
g(\theta) = c\frac{dx(\cos\theta)}{d\cos\theta}
\end{equation}
is mapped to a constant:
\begin{equation}
\int_{-1}^1 d\cos\theta\,g(\theta)
= \int_0^1 dx\,f(x)\,g(\theta(x)) = \int_0^1 dx\,c.
\end{equation}
<<Mappings: public>>=
public :: mapping_compute_ct_from_x
<<Mappings: procedures>>=
subroutine mapping_compute_ct_from_x (map, s, ct, st, f, x)
type(mapping_t), intent(inout) :: map
real(default), intent(in) :: s
real(default), intent(out) :: ct, st, f
real(default), intent(in) :: x
real(default) :: tmp, ct1
select case (map%type)
case (NO_MAPPING, S_CHANNEL, INFRARED, RADIATION, &
STEP_MAPPING_E, STEP_MAPPING_H)
<<Apply trivial ct mapping>>
case (T_CHANNEL, U_CHANNEL, COLLINEAR)
<<Constants for ct pole mapping>>
<<Apply ct pole mapping>>
case default
call msg_fatal (" Attempt to apply undefined ct mapping")
end select
end subroutine mapping_compute_ct_from_x
@ %def mapping_compute_ct_from_x
<<Mappings: public>>=
public :: mapping_compute_x_from_ct
<<Mappings: procedures>>=
subroutine mapping_compute_x_from_ct (map, s, ct, f, x)
type(mapping_t), intent(inout) :: map
real(default), intent(in) :: s
real(default), intent(in) :: ct
real(default), intent(out) :: f, x
real(default) :: ct1
select case (map%type)
case (NO_MAPPING, S_CHANNEL, INFRARED, RADIATION, &
STEP_MAPPING_E, STEP_MAPPING_H)
<<Apply inverse trivial ct mapping>>
case (T_CHANNEL, U_CHANNEL, COLLINEAR)
<<Constants for ct pole mapping>>
<<Apply inverse ct pole mapping>>
case default
call msg_fatal (" Attempt to apply undefined inverse ct mapping")
end select
end subroutine mapping_compute_x_from_ct
@ %def mapping_compute_x_from_ct
@
\subsubsection{Trivial mapping}
This is just the mapping of the interval $(-1,1)$ to $(0,1)$:
\begin{equation}
\cos\theta = -1 + 2x
\end{equation}
and
\begin{equation}
f(x) = 1
\end{equation}
with the inverse
\begin{equation}
x = \frac{1+\cos\theta}{2}
\end{equation}
<<Apply trivial ct mapping>>=
tmp = 2 * (1-x)
ct = 1 - tmp
st = sqrt (tmp * (2-tmp))
f = 1
<<Apply inverse trivial ct mapping>>=
x = (ct + 1) / 2
f = 1
@
\subsubsection{Pole mapping}
As above for $m^2$, we simultaneously map poles at both ends of the
$\cos\theta$ interval. The formulae are completely analogous:
\begin{equation}
\cos\theta =
\begin{cases}
\frac{M^2}{s}\left[\exp(xL)-1\right] - 1
&
\text{for $x<\frac12$}
\\
-\frac{M^2}{s}\left[\exp((1-x)L)-1\right] + 1
&
\text{for $x\geq\frac12$}
\end{cases}
\end{equation}
where
\begin{equation}
L = 2\ln\frac{M^2+s}{M^2}.
\end{equation}
Inverse:
\begin{equation}
x =
\begin{cases}
\frac{1}{2L}\ln\frac{1 + \cos\theta + M^2/s}{M^2/s}
&
\text{for $\cos\theta < 0$}
\\
1 - \frac{1}{2L}\ln\frac{1 - \cos\theta + M^2/s}{M^2/s}
&
\text{for $\cos\theta \geq 0$}
\end{cases}
\end{equation}
The phase-space factor:
\begin{equation}
f(x) =
\begin{cases}
\frac{M^2}{s}\exp(xL)\,L
&
\text{for $x<\frac12$}
\\
\frac{M^2}{s}\exp((1-x)L)\,L
&
\text{for $x\geq\frac12$}
\end{cases}
\end{equation}
<<Constants for ct pole mapping>>=
if (map%variable_limits .or. map%b_unknown) then
map%b1 = map%mass**2 / s
map%b2 = log ((map%b1 + 1) / map%b1)
map%b3 = 0
map%b_unknown = .false.
end if
<<Apply ct pole mapping>>=
if (x < .5_default) then
ct1 = map%b1 * exp (2 * x * map%b2)
ct = ct1 - map%b1 - 1
else
ct1 = map%b1 * exp (2 * (1-x) * map%b2)
ct = -(ct1 - map%b1) + 1
end if
if (ct >= -1 .and. ct <= 1) then
st = sqrt (1 - ct**2)
f = ct1 * map%b2
else
ct = 1; st = 0; f = 0
end if
<<Apply inverse ct pole mapping>>=
if (ct < 0) then
ct1 = ct + map%b1 + 1
x = log (ct1 / map%b1) / (2 * map%b2)
else
ct1 = -ct + map%b1 + 1
x = 1 - log (ct1 / map%b1) / (2 * map%b2)
end if
f = ct1 * map%b2
@
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\clearpage
\section{Phase-space trees}
The phase space evaluation is organized in terms of trees, where each
branch corresponds to three integrations: $m^2$, $\cos\theta$, and
$\phi$. The complete tree thus makes up a specific parameterization
of the multidimensional phase-space integral. For the multi-channel
integration, the phase-space tree is a single channel.
The trees imply mappings of formal Feynman tree graphs into arrays of
integer numbers: Each branch, corresponding to a particular line in
the graph, is assigned an integer code $c$ (with kind value [[TC]] =
tree code).
In this integer, each bit determines whether a particular external
momentum flows through the line. The external branches therefore have
codes $1,2,4,8,\ldots$. An internal branch has those bits ORed
corresponding to the momenta flowing through it. For example, a
branch with momentum $p_1+p_4$ has code $2^0+2^3=1+8=9$.
There is a two-fold ambiguity: Momentum conservation implies that the
branch with code
\begin{equation}
c_0 = \sum_{i=1}^{n(\rm{ext})} 2^{i-1}
\end{equation}
i.e. the branch with momentum $p_1+p_2+\ldots p_n$ has momentum zero,
which is equivalent to tree code $0$ by definition. Correspondingly,
\begin{equation}
c \quad\textrm{and}\quad c_0 - c = c\;\textrm{XOR}\;c_0
\end{equation}
are equivalent. E.g., if there are five externals with codes
$c=1,2,4,8,16$, then $c=9$ and $\bar c=31-9=22$ are equivalent.
This ambiguity may be used to assign a direction to the line: If all
momenta are understood as outgoing, $c=9$ in the example above means
$p_1+p_4$, but $c=22$ means $p_2+p_3+p_5 = -(p_1+p_4)$.
Here we make use of the ambiguity in a slightly different way. First,
the initial particles are singled out as those externals with the
highest bits, the IN-bits. (Here: $8$ and $16$ for a $2\to 3$
scattering process, $16$ only for a $1\to 4$ decay.) Then we invert
those codes where all IN-bits are set. For a decay process this maps
each tree of an equivalence class onto a unique representative (that one
with the smallest integer codes). For a scattering process we proceed
further:
The ambiguity remains in all branches where only one IN-bit is set,
including the initial particles. If there are only externals with
this property, we have an $s$-channel graph which we leave as it is.
In all other cases, an internal with only one IN-bit is a $t$-channel
line, which for phase space integration should be associated with one
of the initial momenta as a reference axis. We take that one whose
bit is set in the current tree code. (E.g., for branch $c=9$ we use
the initial particle $c=8$ as reference axis, whereas for the same
branch we would take $c=16$ if it had been assigned $\bar c=31-9=22$
as tree code.) Thus, different ways of coding the same $t$-channel
graph imply different phase space parameterizations.
$s$-channel graphs have a unique parameterization. The same sets of
parameterizations are used for $t$-channel graphs, except for the
reference frames of their angular parts. We map each
$t$-channel graph onto an $s$-channel graph as follows:
Working in ascending order, for each $t$-channel line (whose code has
exactly one IN-bit set) the attached initial line is flipped upstream,
while the outgoing line is flipped downstream. (This works only if
$t$-channel graphs are always parameterized beginning at their outer
vertices, which we require as a restriction.) After all possible
flips have been applied, we have an $s$-channel graph. We only have
to remember the initial particle a vertex was originally attached to.
<<[[phs_trees.f90]]>>=
<<File header>>
module phs_trees
<<Use kinds>>
use kinds, only: TC
<<Use strings>>
use io_units
use constants, only: twopi, twopi2, twopi5
use format_defs, only: FMT_19
use numeric_utils, only: vanishes
use diagnostics
use lorentz
use permutations, only: permutation_t, permutation_size
use permutations, only: permutation_init, permutation_find
use permutations, only: tc_decay_level, tc_permute
use model_data
use flavors
use resonances, only: resonance_history_t, resonance_info_t
use mappings
<<Standard module head>>
<<PHS trees: public>>
<<PHS trees: types>>
contains
<<PHS trees: procedures>>
end module phs_trees
@ %def phs_trees
@
\subsection{Particles}
We define a particle type which contains only four-momentum and
invariant mass squared, and a flag that tells whether the momentum is
filled or not.
<<PHS trees: public>>=
public :: phs_prt_t
<<PHS trees: types>>=
type :: phs_prt_t
private
logical :: defined = .false.
type(vector4_t) :: p
real(default) :: p2
end type phs_prt_t
@ %def phs_prt_t
@ Set contents:
<<PHS trees: public>>=
public :: phs_prt_set_defined
public :: phs_prt_set_undefined
public :: phs_prt_set_momentum
public :: phs_prt_set_msq
<<PHS trees: procedures>>=
elemental subroutine phs_prt_set_defined (prt)
type(phs_prt_t), intent(inout) :: prt
prt%defined = .true.
end subroutine phs_prt_set_defined
elemental subroutine phs_prt_set_undefined (prt)
type(phs_prt_t), intent(inout) :: prt
prt%defined = .false.
end subroutine phs_prt_set_undefined
elemental subroutine phs_prt_set_momentum (prt, p)
type(phs_prt_t), intent(inout) :: prt
type(vector4_t), intent(in) :: p
prt%p = p
end subroutine phs_prt_set_momentum
elemental subroutine phs_prt_set_msq (prt, p2)
type(phs_prt_t), intent(inout) :: prt
real(default), intent(in) :: p2
prt%p2 = p2
end subroutine phs_prt_set_msq
@ %def phs_prt_set_defined phs_prt_set_momentum phs_prt_set_msq
@ Access methods:
<<PHS trees: public>>=
public :: phs_prt_is_defined
public :: phs_prt_get_momentum
public :: phs_prt_get_msq
<<PHS trees: procedures>>=
elemental function phs_prt_is_defined (prt) result (defined)
logical :: defined
type(phs_prt_t), intent(in) :: prt
defined = prt%defined
end function phs_prt_is_defined
elemental function phs_prt_get_momentum (prt) result (p)
type(vector4_t) :: p
type(phs_prt_t), intent(in) :: prt
p = prt%p
end function phs_prt_get_momentum
elemental function phs_prt_get_msq (prt) result (p2)
real(default) :: p2
type(phs_prt_t), intent(in) :: prt
p2 = prt%p2
end function phs_prt_get_msq
@ %def phs_prt_is_defined phs_prt_get_momentum phs_prt_get_msq
@ Addition of momenta (invariant mass square is computed).
<<PHS trees: public>>=
public :: phs_prt_combine
<<PHS trees: procedures>>=
elemental subroutine phs_prt_combine (prt, prt1, prt2)
type(phs_prt_t), intent(inout) :: prt
type(phs_prt_t), intent(in) :: prt1, prt2
prt%defined = .true.
prt%p = prt1%p + prt2%p
prt%p2 = prt%p ** 2
call phs_prt_check (prt)
end subroutine phs_prt_combine
@ %def phs_prt_combine
@ Output
<<PHS trees: public>>=
public :: phs_prt_write
<<PHS trees: procedures>>=
subroutine phs_prt_write (prt, unit)
type(phs_prt_t), intent(in) :: prt
integer, intent(in), optional :: unit
integer :: u
u = given_output_unit (unit); if (u < 0) return
if (prt%defined) then
call vector4_write (prt%p, u)
write (u, "(1x,A,1x," // FMT_19 // ")") "T = ", prt%p2
else
write (u, "(3x,A)") "[undefined]"
end if
end subroutine phs_prt_write
@ %def phs_prt_write
<<PHS trees: public>>=
public :: phs_prt_check
<<PHS trees: procedures>>=
elemental subroutine phs_prt_check (prt)
type(phs_prt_t), intent(inout) :: prt
if (prt%p2 < 0._default) then
prt%p2 = 0._default
end if
end subroutine phs_prt_check
@ %def phs_prt_check
@
\subsection{The phase-space tree type}
\subsubsection{Definition}
In the concrete implementation, each branch $c$ may have two
\emph{daughters} $c_1$ and $c_2$ such that $c_1+c_2=c$, a
\emph{sibling} $c_s$ and a \emph{mother} $c_m$ such that $c+c_s =
c_m$, and a \emph{friend} which is kept during flips, such that it can
indicate a fixed reference frame. Absent entries are set $c=0$.
First, declare the branch type. There is some need to have this
public. Give initializations for all components, so no [[init]]
routine is necessary. The branch has some information about the
associated coordinates and about connections.
<<PHS trees: types>>=
type :: phs_branch_t
private
logical :: set = .false.
logical :: inverted_decay = .false.
logical :: inverted_axis = .false.
integer(TC) :: mother = 0
integer(TC) :: sibling = 0
integer(TC) :: friend = 0
integer(TC) :: origin = 0
integer(TC), dimension(2) :: daughter = 0
integer :: firstborn = 0
logical :: has_children = .false.
logical :: has_friend = .false.
logical :: is_real = .false.
end type phs_branch_t
@ %def phs_branch_t
@ The tree type: No initialization, this is done by
[[phs_tree_init]]. In addition to the branch array which
The branches are collected in an array which holds all possible
branches, of which only a few are set. After flips have been applied,
the branch $c_M=\sum_{i=1}^{n({\rm fin})}2^{i-1}$ must be there,
indicating the mother of all decay products. In addition, we should
check for consistency at the beginning.
[[n_branches]] is the number of those actually set. [[n_externals]]
defines the number of significant bit, and [[mask]] is a code where all
bits are set. Analogous: [[n_in]] and [[mask_in]] for the incoming
particles.
The [[mapping]] array contains the mappings associated to the branches
(corresponding indices). The array [[mass_sum]] contains the sum of
the real masses of the external final-state particles associated to
the branch. During phase-space evaluation, this determines the
boundaries.
<<PHS trees: public>>=
public :: phs_tree_t
<<PHS trees: types>>=
type :: phs_tree_t
private
integer :: n_branches, n_externals, n_in, n_msq, n_angles
integer(TC) :: n_branches_tot, n_branches_out
integer(TC) :: mask, mask_in, mask_out
type(phs_branch_t), dimension(:), allocatable :: branch
type(mapping_t), dimension(:), allocatable :: mapping
real(default), dimension(:), allocatable :: mass_sum
real(default), dimension(:), allocatable :: effective_mass
real(default), dimension(:), allocatable :: effective_width
logical :: real_phsp = .false.
integer, dimension(:), allocatable :: momentum_link
contains
<<PHS trees: phs tree: TBP>>
end type phs_tree_t
@ %def phs_tree_t
@ The maximum number of external particles that can be represented is
related to the bit size of the integer that stores binary codes. With
the default integer of 32 bit on common machines, this is more than
enough space. If [[TC]] is actually the default integer kind, there
is no need to keep it separate, but doing so marks this as a
special type of integer. So, just state that the maximum number is 32:
<<Limits: public parameters>>=
integer, parameter, public :: MAX_EXTERNAL = 32
@ %def MAX_EXTERNAL
@
\subsubsection{Constructor and destructor}
Allocate memory for a phase-space tree with given number of externals and
incoming. The number of allocated branches can easily become large,
but appears manageable for realistic cases, e.g., for [[n_in=2]] and
[[n_out=8]] we get $2^{10}-1=1023$.
<<PHS trees: public>>=
public :: phs_tree_init
public :: phs_tree_final
@ Here we set the masks for incoming and for all externals.
<<PHS trees: phs tree: TBP>>=
procedure :: init => phs_tree_init
procedure :: final => phs_tree_final
<<PHS trees: procedures>>=
elemental subroutine phs_tree_init (tree, n_in, n_out, n_masses, n_angles)
class(phs_tree_t), intent(inout) :: tree
integer, intent(in) :: n_in, n_out, n_masses, n_angles
integer(TC) :: i
tree%n_externals = n_in + n_out
tree%n_branches_tot = 2**(n_in+n_out) - 1
tree%n_branches_out = 2**n_out - 1
tree%mask = 0
do i = 0, n_in + n_out - 1
tree%mask = ibset (tree%mask, i)
end do
tree%n_in = n_in
tree%mask_in = 0
do i = n_out, n_in + n_out - 1
tree%mask_in = ibset (tree%mask_in, i)
end do
tree%mask_out = ieor (tree%mask, tree%mask_in)
tree%n_msq = n_masses
tree%n_angles = n_angles
allocate (tree%branch (tree%n_branches_tot))
tree%n_branches = 0
allocate (tree%mapping (tree%n_branches_out))
allocate (tree%mass_sum (tree%n_branches_out))
allocate (tree%effective_mass (tree%n_branches_out))
allocate (tree%effective_width (tree%n_branches_out))
end subroutine phs_tree_init
elemental subroutine phs_tree_final (tree)
class(phs_tree_t), intent(inout) :: tree
deallocate (tree%branch)
deallocate (tree%mapping)
deallocate (tree%mass_sum)
deallocate (tree%effective_mass)
deallocate (tree%effective_width)
end subroutine phs_tree_final
@ %def phs_tree_init phs_tree_final
@
\subsubsection{Screen output}
Write only the branches that are set:
<<PHS trees: public>>=
public :: phs_tree_write
<<PHS trees: phs tree: TBP>>=
procedure :: write => phs_tree_write
<<PHS trees: procedures>>=
subroutine phs_tree_write (tree, unit)
class(phs_tree_t), intent(in) :: tree
integer, intent(in), optional :: unit
integer :: u
integer(TC) :: k
u = given_output_unit (unit); if (u < 0) return
write (u, '(3X,A,1x,I0,5X,A,I3)') &
'External:', tree%n_externals, 'Mask:', tree%mask
write (u, '(3X,A,1x,I0,5X,A,I3)') &
'Incoming:', tree%n_in, 'Mask:', tree%mask_in
write (u, '(3X,A,1x,I0,5X,A,I3)') &
'Branches:', tree%n_branches
do k = size (tree%branch), 1, -1
if (tree%branch(k)%set) &
call phs_branch_write (tree%branch(k), unit=unit, kval=k)
end do
do k = 1, size (tree%mapping)
call mapping_write (tree%mapping (k), unit, verbose=.true.)
end do
write (u, "(3x,A)") "Arrays: mass_sum, effective_mass, effective_width"
do k = 1, size (tree%mass_sum)
if (tree%branch(k)%set) then
write (u, "(5x,I0,3(2x," // FMT_19 // "))") k, tree%mass_sum(k), &
tree%effective_mass(k), tree%effective_width(k)
end if
end do
end subroutine phs_tree_write
subroutine phs_branch_write (b, unit, kval)
type(phs_branch_t), intent(in) :: b
integer, intent(in), optional :: unit
integer(TC), intent(in), optional :: kval
integer :: u
integer(TC) :: k
character(len=6) :: tmp
character(len=1) :: firstborn(2), sign_decay, sign_axis
integer :: i
u = given_output_unit (unit); if (u < 0) return
k = 0; if (present (kval)) k = kval
if (b%origin /= 0) then
write(tmp, '(A,I4,A)') '(', b%origin, ')'
else
tmp = ' '
end if
do i=1, 2
if (b%firstborn == i) then
firstborn(i) = "*"
else
firstborn(i) = " "
end if
end do
if (b%inverted_decay) then
sign_decay = "-"
else
sign_decay = "+"
end if
if (b%inverted_axis) then
sign_axis = "-"
else
sign_axis = "+"
end if
if (b%has_children) then
if (b%has_friend) then
write(u,'(4X,A1,I0,3x,A,1X,A,I0,A1,1x,I0,A1,1X,A1,1X,A,1x,I0)') &
& '*', k, tmp, &
& 'Daughters: ', &
& b%daughter(1), firstborn(1), &
& b%daughter(2), firstborn(2), sign_decay, &
& 'Friend: ', b%friend
else
write(u,'(4X,A1,I0,3x,A,1X,A,I0,A1,1x,I0,A1,1X,A1,1X,A)') &
& '*', k, tmp, &
& 'Daughters: ', &
& b%daughter(1), firstborn(1), &
& b%daughter(2), firstborn(2), sign_decay, &
& '(axis '//sign_axis//')'
end if
else
write(u,'(5X,I0)') k
end if
end subroutine phs_branch_write
@ %def phs_tree_write phs_branch_write
@
\subsection{PHS tree setup}
\subsubsection{Transformation into an array of branch codes and back}
Assume that the tree/array has been created before with the
appropriate length and is empty.
<<PHS trees: public>>=
public :: phs_tree_from_array
<<PHS trees: phs tree: TBP>>=
procedure :: from_array => phs_tree_from_array
<<PHS trees: procedures>>=
subroutine phs_tree_from_array (tree, a)
class(phs_tree_t), intent(inout) :: tree
integer(TC), dimension(:), intent(in) :: a
integer :: i
integer(TC) :: k
<<Set branches from array [[a]]>>
<<Set external branches if necessary>>
<<Check number of branches>>
<<Determine the connections>>
contains
<<Subroutine: set relatives>>
end subroutine phs_tree_from_array
@ %def phs_tree_from_array
@ First, set all branches specified by the user. If all IN-bits
are set, we invert the branch code.
<<Set branches from array [[a]]>>=
do i=1, size(a)
k = a(i)
if (iand(k, tree%mask_in) == tree%mask_in) k = ieor(tree%mask, k)
tree%branch(k)%set = .true.
tree%n_branches = tree%n_branches+1
end do
@ The external branches are understood, so set them now if not yet
done. In all cases ensure that the representative with one bit set is
used, except for decays where the in-particle is represented by all
OUT-bits set instead.
<<Set external branches if necessary>>=
do i=0, tree%n_externals-1
k = ibset(0,i)
if (iand(k, tree%mask_in) == tree%mask_in) k = ieor(tree%mask, k)
if (tree%branch(ieor(tree%mask, k))%set) then
tree%branch(ieor(tree%mask, k))%set = .false.
tree%branch(k)%set = .true.
else if (.not.tree%branch(k)%set) then
tree%branch(k)%set = .true.
tree%n_branches = tree%n_branches+1
end if
end do
@ Now the number of branches set can be checked. Here we assume that
the tree is binary. For three externals there are three branches in
total, and for each additional external branch we get another internal
one.
<<Check number of branches>>=
if (tree%n_branches /= tree%n_externals*2-3) then
call phs_tree_write (tree)
call msg_bug &
& (" Wrong number of branches set in phase space tree")
end if
@ For all branches that are set, except for the externals, we try to
find the daughter branches:
<<Determine the connections>>=
do k=1, size (tree%branch)
if (tree%branch(k)%set .and. tc_decay_level (k) /= 1) then
call branch_set_relatives(k)
end if
end do
@ To this end, we scan all codes less than the current code, whether
we can find two branches which are set and which together give the
current code. After that, the tree may still not be connected, but at
least we know if a branch does not have daughters: This indicates some
inconsistency.
The algorithm ensures that, at this stage, the first daughter has a
smaller code value than the second one.
<<Subroutine: set relatives>>=
subroutine branch_set_relatives (k)
integer(TC), intent(in) :: k
integer(TC) :: m,n
do m=1, k-1
if (iand(k,m)==m) then
n = ieor(k,m)
if ( tree%branch(m)%set .and. tree%branch(n)%set ) then
tree%branch(k)%daughter(1) = m; tree%branch(k)%daughter(2) = n
tree%branch(m)%mother = k; tree%branch(n)%mother = k
tree%branch(m)%sibling = n; tree%branch(n)%sibling = m
tree%branch(k)%has_children = .true.
return
end if
end if
end do
call phs_tree_write (tree)
call msg_bug &
& (" Missing daughter branch(es) in phase space tree")
end subroutine branch_set_relatives
@ The inverse: this is trivial, fortunately.
@
\subsubsection{Flip $t$-channel into $s$-channel}
Flipping the tree is done upwards, beginning from the decay products.
First we select a $t$-channel branch [[k]]: one which is set, which
does have an IN-bit, and which is not an external particle.
Next, we determine the adjacent in-particle (called the 'friend' [[f]]
here, since it will provide the reference axis for the angular
integration). In addition, we look for the 'mother' and 'sibling' of
this particle. If the latter field is empty, we select the (unique)
other out-particle which has no mother, calling the internal
subroutine [[find_orphan]].
The flip is done as follows: We assume that the first daughter [[d]]
is an $s$-channel line, which is true if the daughters are sorted.
This will stay the first daughter. The second one is a $t$-channel
line; it is exchanged with the 'sibling' [[s]]. The new line which
replaces the branch [[k]] is just the sum of [[s]] and [[d]]. In
addition, we have to rearrange the relatives of [[s]] and [[d]], as
well of [[f]].
Finally, we flip 'sibling' and 'friend' and set the new $s$-channel
branch [[n]] which replaces the $t$-channel branch [[k]]. After this
is complete, we are ready to execute another flip.
[Although the friend is not needed for the final flip, since it would
be an initial particle anyway, we need to know whether we have $t$- or
$u$-channel.]
<<PHS trees: public>>=
public :: phs_tree_flip_t_to_s_channel
<<PHS trees: procedures>>=
subroutine phs_tree_flip_t_to_s_channel (tree)
type(phs_tree_t), intent(inout) :: tree
integer(TC) :: k, f, m, n, d, s
if (tree%n_in == 2) then
FLIP: do k=3, tree%mask-1
if (.not. tree%branch(k)%set) cycle FLIP
f = iand(k,tree%mask_in)
if (f==0 .or. f==k) cycle FLIP
m = tree%branch(k)%mother
s = tree%branch(k)%sibling
if (s==0) call find_orphan(s)
d = tree%branch(k)%daughter(1)
n = ior(d,s)
tree%branch(k)%set = .false.
tree%branch(n)%set = .true.
tree%branch(n)%origin = k
tree%branch(n)%daughter(1) = d; tree%branch(d)%mother = n
tree%branch(n)%daughter(2) = s; tree%branch(s)%mother = n
tree%branch(n)%has_children = .true.
tree%branch(d)%sibling = s; tree%branch(s)%sibling = d
tree%branch(n)%sibling = f; tree%branch(f)%sibling = n
tree%branch(n)%mother = m
tree%branch(f)%mother = m
if (m/=0) then
tree%branch(m)%daughter(1) = n
tree%branch(m)%daughter(2) = f
end if
tree%branch(n)%friend = f
tree%branch(n)%has_friend = .true.
tree%branch(n)%firstborn = 2
end do FLIP
end if
contains
subroutine find_orphan(s)
integer(TC) :: s
do s=1, tree%mask_out
if (tree%branch(s)%set .and. tree%branch(s)%mother==0) return
end do
call phs_tree_write (tree)
call msg_bug (" Can't flip phase space tree to channel")
end subroutine find_orphan
end subroutine phs_tree_flip_t_to_s_channel
@ %def phs_tree_flip_t_to_s_channel
@ After the tree has been flipped, one may need to determine what has
become of a particular $t$-channel branch. This function gives the
bincode of the flipped tree. If the original bincode does not contain
IN-bits, we leave it as it is.
<<PHS trees: procedures>>=
function tc_flipped (tree, kt) result (ks)
type(phs_tree_t), intent(in) :: tree
integer(TC), intent(in) :: kt
integer(TC) :: ks
if (iand (kt, tree%mask_in) == 0) then
ks = kt
else
ks = tree%branch(iand (kt, tree%mask_out))%mother
end if
end function tc_flipped
@ %def tc_flipped
@ Scan a tree and make sure that the first daughter has always a
smaller code than the second one. Furthermore, delete any [[friend]]
entry in the root branch -- this branching has the incoming particle
direction as axis anyway. Keep track of reordering by updating
[[inverted_axis]], [[inverted_decay]] and [[firstborn]].
<<PHS trees: public>>=
public :: phs_tree_canonicalize
<<PHS trees: procedures>>=
subroutine phs_tree_canonicalize (tree)
type(phs_tree_t), intent(inout) :: tree
integer :: n_out
integer(TC) :: k_out
call branch_canonicalize (tree%branch(tree%mask_out))
n_out = tree%n_externals - tree%n_in
k_out = tree%mask_out
if (tree%branch(k_out)%has_friend &
& .and. tree%branch(k_out)%friend == ibset (0, n_out)) then
tree%branch(k_out)%inverted_axis = .not.tree%branch(k_out)%inverted_axis
end if
tree%branch(k_out)%has_friend = .false.
tree%branch(k_out)%friend = 0
contains
recursive subroutine branch_canonicalize (b)
type(phs_branch_t), intent(inout) :: b
integer(TC) :: d1, d2
if (b%has_children) then
d1 = b%daughter(1)
d2 = b%daughter(2)
if (d1 > d2) then
b%daughter(1) = d2
b%daughter(2) = d1
b%inverted_decay = .not.b%inverted_decay
if (b%firstborn /= 0) b%firstborn = 3 - b%firstborn
end if
call branch_canonicalize (tree%branch(b%daughter(1)))
call branch_canonicalize (tree%branch(b%daughter(2)))
end if
end subroutine branch_canonicalize
end subroutine phs_tree_canonicalize
@ %def phs_tree_canonicalize
@
\subsubsection{Mappings}
Initialize a mapping for the current tree. This is done while reading
from file, so the mapping parameters are read, but applied to the
flipped tree. Thus, the size of the array of mappings is given by the
number of outgoing particles only.
<<PHS trees: public>>=
public :: phs_tree_init_mapping
<<PHS trees: phs tree: TBP>>=
procedure :: init_mapping => phs_tree_init_mapping
<<PHS trees: procedures>>=
subroutine phs_tree_init_mapping (tree, k, type, pdg, model)
class(phs_tree_t), intent(inout) :: tree
integer(TC), intent(in) :: k
type(string_t), intent(in) :: type
integer, intent(in) :: pdg
class(model_data_t), intent(in), target :: model
integer(TC) :: kk
kk = tc_flipped (tree, k)
call mapping_init (tree%mapping(kk), kk, type, pdg, model)
end subroutine phs_tree_init_mapping
@ %def phs_tree_init_mapping
@ Set the physical parameters for the mapping, using a specific
parameter set. Also set the mass sum array.
<<PHS trees: public>>=
public :: phs_tree_set_mapping_parameters
<<PHS trees: phs tree: TBP>>=
procedure :: set_mapping_parameters => phs_tree_set_mapping_parameters
<<PHS trees: procedures>>=
subroutine phs_tree_set_mapping_parameters &
(tree, mapping_defaults, variable_limits)
class(phs_tree_t), intent(inout) :: tree
type(mapping_defaults_t), intent(in) :: mapping_defaults
logical, intent(in) :: variable_limits
integer(TC) :: k
do k = 1, tree%n_branches_out
call mapping_set_parameters &
(tree%mapping(k), mapping_defaults, variable_limits)
end do
end subroutine phs_tree_set_mapping_parameters
@ %def phs_tree_set_mapping_parameters
@ Return the mapping for the sum of all outgoing particles. This
should either be no mapping or a global s-channel mapping.
<<PHS trees: public>>=
public :: phs_tree_assign_s_mapping
<<PHS trees: procedures>>=
subroutine phs_tree_assign_s_mapping (tree, mapping)
type(phs_tree_t), intent(in) :: tree
type(mapping_t), intent(out) :: mapping
mapping = tree%mapping(tree%mask_out)
end subroutine phs_tree_assign_s_mapping
@ %def phs_tree_assign_s_mapping
@
\subsubsection{Kinematics}
Fill the mass sum array, starting from the external particles and
working down to the tree root. For each bincode [[k]] we scan the
bits in [[k]]; if only one is set, we take the physical mass of the
corresponding external particle; if more then one is set, we sum up
the two masses (which we know have already been set).
<<PHS trees: public>>=
public :: phs_tree_set_mass_sum
<<PHS trees: phs tree: TBP>>=
procedure :: set_mass_sum => phs_tree_set_mass_sum
<<PHS trees: procedures>>=
subroutine phs_tree_set_mass_sum (tree, flv)
class(phs_tree_t), intent(inout) :: tree
type(flavor_t), dimension(:), intent(in) :: flv
integer(TC) :: k
integer :: i
tree%mass_sum = 0
do k = 1, tree%n_branches_out
do i = 0, size (flv) - 1
if (btest(k,i)) then
if (ibclr(k,i) == 0) then
tree%mass_sum(k) = flv(i+1)%get_mass ()
else
tree%mass_sum(k) = &
tree%mass_sum(ibclr(k,i)) + tree%mass_sum(ibset(0,i))
end if
exit
end if
end do
end do
end subroutine phs_tree_set_mass_sum
@ %def phs_tree_set_mass_sum
@ Set the effective masses and widths. For each non-resonant branch
in a tree, the effective mass is equal to the sum of the effective
masses of the children (and analogous for the width). External
particles have their real mass and width zero. For resonant branches,
we insert mass and width from the corresponding mapping.
This routine has [[phs_tree_set_mass_sum]] and
[[phs_tree_set_mapping_parameters]] as prerequisites.
<<PHS trees: public>>=
public :: phs_tree_set_effective_masses
<<PHS trees: phs tree: TBP>>=
procedure :: set_effective_masses => phs_tree_set_effective_masses
<<PHS trees: procedures>>=
subroutine phs_tree_set_effective_masses (tree)
class(phs_tree_t), intent(inout) :: tree
tree%effective_mass = 0
tree%effective_width = 0
call set_masses_x (tree%mask_out)
contains
recursive subroutine set_masses_x (k)
integer(TC), intent(in) :: k
integer(TC) :: k1, k2
if (tree%branch(k)%has_children) then
k1 = tree%branch(k)%daughter(1)
k2 = tree%branch(k)%daughter(2)
call set_masses_x (k1)
call set_masses_x (k2)
if (mapping_is_s_channel (tree%mapping(k))) then
tree%effective_mass(k) = mapping_get_mass (tree%mapping(k))
tree%effective_width(k) = mapping_get_width (tree%mapping(k))
else
tree%effective_mass(k) = &
tree%effective_mass(k1) + tree%effective_mass(k2)
tree%effective_width(k) = &
tree%effective_width(k1) + tree%effective_width(k2)
end if
else
tree%effective_mass(k) = tree%mass_sum(k)
end if
end subroutine set_masses_x
end subroutine phs_tree_set_effective_masses
@ %def phs_tree_set_effective_masses
@ Define step mappings, recursively, for the decay products of all
intermediate resonances. Step mappings account for the fact that a
branch may originate from a resonance, which almost replaces the
upper limit on the possible invariant mass. The step
mapping implements a smooth cutoff that interpolates between the
resonance and the real kinematic limit. The mapping width determines
the sharpness of the cutoff.
Step mappings are inserted only for branches that are not mapped
otherwise.
At each branch, we record the mass that is effectively available for
phase space, by taking the previous limit and subtracting the
effective mass of the sibling branch. Widths are added, not subtracted.
If we encounter a resonance decay, we discard the previous limit and
replace it by the mass and width of the resonance, also subtracting
the sibling branch.
Initially, the limit is zero, so it becomes negative at any branch. Only
if there is a resonance, the limit becomes positive. Whenever the
limit is positive, and the current branch decays, we activate a step
mapping for the current branch.
As a result, step mappings are implemented for all internal lines that
originate from an intermediate resonance decay.
The flag [[variable_limits]] applies to the ultimate limit from the
available energy, not to the intermediate resonances whose masses are
always fixed.
This routine requires [[phs_tree_set_effective_masses]]
<<PHS trees: public>>=
public :: phs_tree_set_step_mappings
<<PHS trees: procedures>>=
subroutine phs_tree_set_step_mappings (tree, exp_type, variable_limits)
type(phs_tree_t), intent(inout) :: tree
logical, intent(in) :: exp_type
logical, intent(in) :: variable_limits
type(string_t) :: map_str
integer(TC) :: k
if (exp_type) then
map_str = "step_exp"
else
map_str = "step_hyp"
end if
k = tree%mask_out
call set_step_mappings_x (k, 0._default, 0._default)
contains
recursive subroutine set_step_mappings_x (k, m_limit, w_limit)
integer(TC), intent(in) :: k
real(default), intent(in) :: m_limit, w_limit
integer(TC), dimension(2) :: kk
real(default), dimension(2) :: m, w
if (tree%branch(k)%has_children) then
if (m_limit > 0) then
if (.not. mapping_is_set (tree%mapping(k))) then
call mapping_init (tree%mapping(k), k, map_str)
call mapping_set_step_mapping_parameters (tree%mapping(k), &
m_limit, w_limit, &
variable_limits)
end if
end if
kk = tree%branch(k)%daughter
m = tree%effective_mass(kk)
w = tree%effective_width(kk)
if (mapping_is_s_channel (tree%mapping(k))) then
call set_step_mappings_x (kk(1), &
mapping_get_mass (tree%mapping(k)) - m(2), &
mapping_get_width (tree%mapping(k)) + w(2))
call set_step_mappings_x (kk(2), &
mapping_get_mass (tree%mapping(k)) - m(1), &
mapping_get_width (tree%mapping(k)) + w(1))
else if (m_limit > 0) then
call set_step_mappings_x (kk(1), &
m_limit - m(2), &
w_limit + w(2))
call set_step_mappings_x (kk(2), &
m_limit - m(1), &
w_limit + w(1))
else
call set_step_mappings_x (kk(1), &
- m(2), &
+ w(2))
call set_step_mappings_x (kk(2), &
- m(1), &
+ w(1))
end if
end if
end subroutine set_step_mappings_x
end subroutine phs_tree_set_step_mappings
@ %def phs_tree_set_step_mappings
@
\subsubsection{Resonance structure}
We identify the resonances within a tree as the set of s-channel
mappings. The [[resonance_history_t]] type serves as the result
container.
<<PHS trees: phs tree: TBP>>=
procedure :: extract_resonance_history => phs_tree_extract_resonance_history
<<PHS trees: procedures>>=
subroutine phs_tree_extract_resonance_history (tree, res_history)
class(phs_tree_t), intent(in) :: tree
type(resonance_history_t), intent(out) :: res_history
type(resonance_info_t) :: res_info
integer :: i
if (allocated (tree%mapping)) then
do i = 1, size (tree%mapping)
associate (mapping => tree%mapping(i))
if (mapping%is_s_channel ()) then
call res_info%init (mapping%get_bincode (), mapping%get_flv (), &
n_out = tree%n_externals - tree%n_in)
call res_history%add_resonance (res_info)
end if
end associate
end do
end if
end subroutine phs_tree_extract_resonance_history
@ %def phs_tree_extract_resonance_history
@
\subsubsection{Structural comparison}
This function allows to check whether one tree is the permutation of
another one. The permutation is applied to the second tree in the
argument list. We do not make up a temporary permuted tree, but
compare the two trees directly. The branches are scanned recursively,
where for each daughter we check the friend and the mapping as well.
Once a discrepancy is found, the recursion is exited immediately.
<<PHS trees: public>>=
public :: phs_tree_equivalent
<<PHS trees: procedures>>=
function phs_tree_equivalent (t1, t2, perm) result (is_equal)
type(phs_tree_t), intent(in) :: t1, t2
type(permutation_t), intent(in) :: perm
logical :: equal, is_equal
integer(TC) :: k1, k2, mask_in
k1 = t1%mask_out
k2 = t2%mask_out
mask_in = t1%mask_in
equal = .true.
call check (t1%branch(k1), t2%branch(k2), k1, k2)
is_equal = equal
contains
recursive subroutine check (b1, b2, k1, k2)
type(phs_branch_t), intent(in) :: b1, b2
integer(TC), intent(in) :: k1, k2
integer(TC), dimension(2) :: d1, d2, pd2
integer :: i
if (.not.b1%has_friend .and. .not.b2%has_friend) then
equal = .true.
else if (b1%has_friend .and. b2%has_friend) then
equal = (b1%friend == tc_permute (b2%friend, perm, mask_in))
end if
if (equal) then
if (b1%has_children .and. b2%has_children) then
d1 = b1%daughter
d2 = b2%daughter
do i=1, 2
pd2(i) = tc_permute (d2(i), perm, mask_in)
end do
if (d1(1)==pd2(1) .and. d1(2)==pd2(2)) then
equal = (b1%firstborn == b2%firstborn)
if (equal) call check &
& (t1%branch(d1(1)), t2%branch(d2(1)), d1(1), d2(1))
if (equal) call check &
& (t1%branch(d1(2)), t2%branch(d2(2)), d1(2), d2(2))
else if (d1(1)==pd2(2) .and. d1(2)==pd2(1)) then
equal = ( (b1%firstborn == 0 .and. b2%firstborn == 0) &
& .or. (b1%firstborn == 3 - b2%firstborn) )
if (equal) call check &
& (t1%branch(d1(1)), t2%branch(d2(2)), d1(1), d2(2))
if (equal) call check &
& (t1%branch(d1(2)), t2%branch(d2(1)), d1(2), d2(1))
else
equal = .false.
end if
end if
end if
if (equal) then
equal = (t1%mapping(k1) == t2%mapping(k2))
end if
end subroutine check
end function phs_tree_equivalent
@ %def phs_tree_equivalent
@ Scan two decay trees and determine the correspondence of mass
variables, i.e., the permutation that transfers the ordered list of
mass variables belonging to the second tree into the first one. Mass
variables are assigned beginning from branches and ending at the root.
<<PHS trees: public>>=
public :: phs_tree_find_msq_permutation
<<PHS trees: procedures>>=
subroutine phs_tree_find_msq_permutation (tree1, tree2, perm2, msq_perm)
type(phs_tree_t), intent(in) :: tree1, tree2
type(permutation_t), intent(in) :: perm2
type(permutation_t), intent(out) :: msq_perm
type(permutation_t) :: perm1
integer(TC) :: mask_in, root
integer(TC), dimension(:), allocatable :: index1, index2
integer :: i
allocate (index1 (tree1%n_msq), index2 (tree2%n_msq))
call permutation_init (perm1, permutation_size (perm2))
mask_in = tree1%mask_in
root = tree1%mask_out
i = 0
call tree_scan (tree1, root, perm1, index1)
i = 0
call tree_scan (tree2, root, perm2, index2)
call permutation_find (msq_perm, index1, index2)
contains
recursive subroutine tree_scan (tree, k, perm, index)
type(phs_tree_t), intent(in) :: tree
integer(TC), intent(in) :: k
type(permutation_t), intent(in) :: perm
integer, dimension(:), intent(inout) :: index
if (tree%branch(k)%has_children) then
call tree_scan (tree, tree%branch(k)%daughter(1), perm, index)
call tree_scan (tree, tree%branch(k)%daughter(2), perm, index)
i = i + 1
if (i <= size (index)) index(i) = tc_permute (k, perm, mask_in)
end if
end subroutine tree_scan
end subroutine phs_tree_find_msq_permutation
@ %def phs_tree_find_msq_permutation
<<PHS trees: public>>=
public :: phs_tree_find_angle_permutation
<<PHS trees: procedures>>=
subroutine phs_tree_find_angle_permutation &
(tree1, tree2, perm2, angle_perm, sig2)
type(phs_tree_t), intent(in) :: tree1, tree2
type(permutation_t), intent(in) :: perm2
type(permutation_t), intent(out) :: angle_perm
logical, dimension(:), allocatable, intent(out) :: sig2
type(permutation_t) :: perm1
integer(TC) :: mask_in, root
integer(TC), dimension(:), allocatable :: index1, index2
logical, dimension(:), allocatable :: sig1
integer :: i
allocate (index1 (tree1%n_angles), index2 (tree2%n_angles))
allocate (sig1 (tree1%n_angles), sig2 (tree2%n_angles))
call permutation_init (perm1, permutation_size (perm2))
mask_in = tree1%mask_in
root = tree1%mask_out
i = 0
call tree_scan (tree1, root, perm1, index1, sig1)
i = 0
call tree_scan (tree2, root, perm2, index2, sig2)
call permutation_find (angle_perm, index1, index2)
contains
recursive subroutine tree_scan (tree, k, perm, index, sig)
type(phs_tree_t), intent(in) :: tree
integer(TC), intent(in) :: k
type(permutation_t), intent(in) :: perm
integer, dimension(:), intent(inout) :: index
logical, dimension(:), intent(inout) :: sig
integer(TC) :: k1, k2, kp
logical :: s
if (tree%branch(k)%has_children) then
k1 = tree%branch(k)%daughter(1)
k2 = tree%branch(k)%daughter(2)
s = (tc_permute(k1, perm, mask_in) < tc_permute(k2, perm, mask_in))
kp = tc_permute (k, perm, mask_in)
i = i + 1
index(i) = kp
sig(i) = s
i = i + 1
index(i) = - kp
sig(i) = s
call tree_scan (tree, k1, perm, index, sig)
call tree_scan (tree, k2, perm, index, sig)
end if
end subroutine tree_scan
end subroutine phs_tree_find_angle_permutation
@ %def phs_tree_find_angle_permutation
@
\subsection{Phase-space evaluation}
\subsubsection{Phase-space volume}
We compute the phase-space volume recursively, following the same path
as for computing other kinematical variables. However, the volume
depends just on $\sqrt{\hat s}$, not on the momentum configuration.
Note: counting branches, we may replace this by a simple formula.
<<PHS trees: public>>=
public :: phs_tree_compute_volume
<<PHS trees: procedures>>=
subroutine phs_tree_compute_volume (tree, sqrts, volume)
type(phs_tree_t), intent(in) :: tree
real(default), intent(in) :: sqrts
real(default), intent(out) :: volume
integer(TC) :: k
k = tree%mask_out
if (tree%branch(k)%has_children) then
call compute_volume_x (tree%branch(k), k, volume, .true.)
else
volume = 1
end if
contains
recursive subroutine compute_volume_x (b, k, volume, initial)
type(phs_branch_t), intent(in) :: b
integer(TC), intent(in) :: k
real(default), intent(out) :: volume
logical, intent(in) :: initial
integer(TC) :: k1, k2
real(default) :: v1, v2
k1 = b%daughter(1); k2 = b%daughter(2)
if (tree%branch(k1)%has_children) then
call compute_volume_x (tree%branch(k1), k1, v1, .false.)
else
v1 = 1
end if
if (tree%branch(k2)%has_children) then
call compute_volume_x (tree%branch(k2), k2, v2, .false.)
else
v2 = 1
end if
if (initial) then
volume = v1 * v2 / (4 * twopi5)
else
volume = v1 * v2 * sqrts**2 / (4 * twopi2)
end if
end subroutine compute_volume_x
end subroutine phs_tree_compute_volume
@ %def phs_tree_compute_volume
@
\subsubsection{Determine momenta}
This is done in two steps: First the masses are determined. This step
may fail, in which case [[ok]] is set to false. If successful, we
generate angles and the actual momenta. The array [[decay_p]] serves
for transferring the individual three-momenta of the daughter
particles in their mother rest frame from the mass generation to the
momentum generation step.
<<PHS trees: public>>=
public :: phs_tree_compute_momenta_from_x
<<PHS trees: procedures>>=
subroutine phs_tree_compute_momenta_from_x &
(tree, prt, factor, volume, sqrts, x, ok)
type(phs_tree_t), intent(inout) :: tree
type(phs_prt_t), dimension(:), intent(inout) :: prt
real(default), intent(out) :: factor, volume
real(default), intent(in) :: sqrts
real(default), dimension(:), intent(in) :: x
logical, intent(out) :: ok
real(default), dimension(tree%mask_out) :: decay_p
integer :: n1, n2
integer :: n_out
if (tree%real_phsp) then
n_out = tree%n_externals - tree%n_in - 1
n1 = max (n_out-2, 0)
n2 = n1 + max (2*n_out, 0)
else
n1 = tree%n_msq
n2 = n1 + tree%n_angles
end if
call phs_tree_set_msq &
(tree, prt, factor, volume, decay_p, sqrts, x(1:n1), ok)
if (ok) call phs_tree_set_angles &
(tree, prt, factor, decay_p, sqrts, x(n1+1:n2))
end subroutine phs_tree_compute_momenta_from_x
@ %def phs_tree_compute_momenta_from_x
@ Mass generation is done recursively. The [[ok]] flag causes the
filled tree to be discarded if set to [[.false.]]. This happens if a
three-momentum turns out to be imaginary, indicating impossible
kinematics. The index [[ix]] tells us how far we have used up the
input array [[x]].
<<PHS trees: procedures>>=
subroutine phs_tree_set_msq &
(tree, prt, factor, volume, decay_p, sqrts, x, ok)
type(phs_tree_t), intent(inout) :: tree
type(phs_prt_t), dimension(:), intent(inout) :: prt
real(default), intent(out) :: factor, volume
real(default), dimension(:), intent(out) :: decay_p
real(default), intent(in) :: sqrts
real(default), dimension(:), intent(in) :: x
logical, intent(out) :: ok
integer :: ix
integer(TC) :: k
real(default) :: m_tot
ok =.true.
ix = 1
k = tree%mask_out
m_tot = tree%mass_sum(k)
decay_p(k) = 0.
if (m_tot < sqrts .or. k == 1) then
if (tree%branch(k)%has_children) then
call set_msq_x (tree%branch(k), k, factor, volume, .true.)
else
factor = 1
volume = 1
end if
else
ok = .false.
end if
contains
recursive subroutine set_msq_x (b, k, factor, volume, initial)
type(phs_branch_t), intent(in) :: b
integer(TC), intent(in) :: k
real(default), intent(out) :: factor, volume
logical, intent(in) :: initial
real(default) :: msq, m, m_min, m_max, m1, m2, msq1, msq2, lda, rlda
integer(TC) :: k1, k2
real(default) :: f1, f2, v1, v2
k1 = b%daughter(1); k2 = b%daughter(2)
if (tree%branch(k1)%has_children) then
call set_msq_x (tree%branch(k1), k1, f1, v1, .false.)
if (.not.ok) return
else
f1 = 1; v1 = 1
end if
if (tree%branch(k2)%has_children) then
call set_msq_x (tree%branch(k2), k2, f2, v2, .false.)
if (.not.ok) return
else
f2 = 1; v2 = 1
end if
m_min = tree%mass_sum(k)
if (initial) then
msq = sqrts**2
m = sqrts
m_max = sqrts
factor = f1 * f2
volume = v1 * v2 / (4 * twopi5)
else
m_max = sqrts - m_tot + m_min
call mapping_compute_msq_from_x &
(tree%mapping(k), sqrts**2, m_min**2, m_max**2, msq, factor, &
x(ix)); ix = ix + 1
if (msq >= 0) then
m = sqrt (msq)
factor = f1 * f2 * factor
volume = v1 * v2 * sqrts**2 / (4 * twopi2)
call phs_prt_set_msq (prt(k), msq)
call phs_prt_set_defined (prt(k))
else
ok = .false.
end if
end if
if (ok) then
msq1 = phs_prt_get_msq (prt(k1)); m1 = sqrt (msq1)
msq2 = phs_prt_get_msq (prt(k2)); m2 = sqrt (msq2)
lda = lambda (msq, msq1, msq2)
if (lda > 0 .and. m > m1 + m2 .and. m <= m_max) then
rlda = sqrt (lda)
decay_p(k1) = rlda / (2*m)
decay_p(k2) = - decay_p(k1)
factor = rlda / msq * factor
else
ok = .false.
end if
end if
end subroutine set_msq_x
end subroutine phs_tree_set_msq
@ %def phs_tree_set_msq
@
The heart of phase space generation: Now we have the invariant masses,
let us generate angles. At each branch, we take a Lorentz
transformation and augment it by a boost to the current particle
rest frame, and by rotations $\phi$ and $\theta$ around the $z$ and
$y$ axis, respectively. This transformation is passed down to the
daughter particles, if present.
<<PHS trees: procedures>>=
subroutine phs_tree_set_angles (tree, prt, factor, decay_p, sqrts, x)
type(phs_tree_t), intent(inout) :: tree
type(phs_prt_t), dimension(:), intent(inout) :: prt
real(default), intent(inout) :: factor
real(default), dimension(:), intent(in) :: decay_p
real(default), intent(in) :: sqrts
real(default), dimension(:), intent(in) :: x
integer :: ix
integer(TC) :: k
ix = 1
k = tree%mask_out
call set_angles_x (tree%branch(k), k)
contains
recursive subroutine set_angles_x (b, k, L0)
type(phs_branch_t), intent(in) :: b
integer(TC), intent(in) :: k
type(lorentz_transformation_t), intent(in), optional :: L0
real(default) :: m, msq, ct, st, phi, f, E, p, bg
type(lorentz_transformation_t) :: L, LL
integer(TC) :: k1, k2
type(vector3_t) :: axis
p = decay_p(k)
msq = phs_prt_get_msq (prt(k)); m = sqrt (msq)
E = sqrt (msq + p**2)
if (present (L0)) then
call phs_prt_set_momentum (prt(k), L0 * vector4_moving (E,p,3))
else
call phs_prt_set_momentum (prt(k), vector4_moving (E,p,3))
end if
call phs_prt_set_defined (prt(k))
if (b%has_children) then
k1 = b%daughter(1)
k2 = b%daughter(2)
if (m > 0) then
bg = p / m
else
bg = 0
end if
phi = x(ix) * twopi; ix = ix + 1
call mapping_compute_ct_from_x &
(tree%mapping(k), sqrts**2, ct, st, f, x(ix)); ix = ix + 1
factor = factor * f
if (.not. b%has_friend) then
L = LT_compose_r2_r3_b3 (ct, st, cos(phi), sin(phi), bg)
!!! The function above is equivalent to:
! L = boost (bg,3) * rotation (phi,3) * rotation (ct,st,2)
else
LL = boost (-bg,3); if (present (L0)) LL = LL * inverse(L0)
axis = space_part ( &
LL * phs_prt_get_momentum (prt(tree%branch(k)%friend)) )
L = boost(bg,3) * rotation_to_2nd (vector3_canonical(3), axis) &
* LT_compose_r2_r3_b3 (ct, st, cos(phi), sin(phi), 0._default)
end if
if (present (L0)) L = L0 * L
call set_angles_x (tree%branch(k1), k1, L)
call set_angles_x (tree%branch(k2), k2, L)
end if
end subroutine set_angles_x
end subroutine phs_tree_set_angles
@ %def phs_tree_set_angles
@
\subsubsection{Recover random numbers}
For the other channels we want to compute the random numbers that
would have generated the momenta that we already know.
<<PHS trees: public>>=
public :: phs_tree_compute_x_from_momenta
<<PHS trees: procedures>>=
subroutine phs_tree_compute_x_from_momenta (tree, prt, factor, sqrts, x)
type(phs_tree_t), intent(inout) :: tree
type(phs_prt_t), dimension(:), intent(in) :: prt
real(default), intent(out) :: factor
real(default), intent(in) :: sqrts
real(default), dimension(:), intent(inout) :: x
real(default), dimension(tree%mask_out) :: decay_p
integer :: n1, n2
n1 = tree%n_msq
n2 = n1 + tree%n_angles
call phs_tree_get_msq &
(tree, prt, factor, decay_p, sqrts, x(1:n1))
call phs_tree_get_angles &
(tree, prt, factor, decay_p, sqrts, x(n1+1:n2))
end subroutine phs_tree_compute_x_from_momenta
@ %def phs_tree_compute_x_from_momenta
@ The inverse operation follows exactly the same steps. The tree is
[[inout]] because it contains mappings whose parameters can be reset
when the mapping is applied.
<<PHS trees: procedures>>=
subroutine phs_tree_get_msq (tree, prt, factor, decay_p, sqrts, x)
type(phs_tree_t), intent(inout) :: tree
type(phs_prt_t), dimension(:), intent(in) :: prt
real(default), intent(out) :: factor
real(default), dimension(:), intent(out) :: decay_p
real(default), intent(in) :: sqrts
real(default), dimension(:), intent(inout) :: x
integer :: ix
integer(TC) :: k
real(default) :: m_tot
ix = 1
k = tree%mask_out
m_tot = tree%mass_sum(k)
decay_p(k) = 0.
if (tree%branch(k)%has_children) then
call get_msq_x (tree%branch(k), k, factor, .true.)
else
factor = 1
end if
contains
recursive subroutine get_msq_x (b, k, factor, initial)
type(phs_branch_t), intent(in) :: b
integer(TC), intent(in) :: k
real(default), intent(out) :: factor
logical, intent(in) :: initial
real(default) :: msq, m, m_min, m_max, msq1, msq2, lda, rlda
integer(TC) :: k1, k2
real(default) :: f1, f2
k1 = b%daughter(1); k2 = b%daughter(2)
if (tree%branch(k1)%has_children) then
call get_msq_x (tree%branch(k1), k1, f1, .false.)
else
f1 = 1
end if
if (tree%branch(k2)%has_children) then
call get_msq_x (tree%branch(k2), k2, f2, .false.)
else
f2 = 1
end if
m_min = tree%mass_sum(k)
m_max = sqrts - m_tot + m_min
msq = phs_prt_get_msq (prt(k)); m = sqrt (msq)
if (initial) then
factor = f1 * f2
else
call mapping_compute_x_from_msq &
(tree%mapping(k), sqrts**2, m_min**2, m_max**2, msq, factor, &
x(ix)); ix = ix + 1
factor = f1 * f2 * factor
end if
msq1 = phs_prt_get_msq (prt(k1))
msq2 = phs_prt_get_msq (prt(k2))
lda = lambda (msq, msq1, msq2)
if (lda > 0) then
rlda = sqrt (lda)
decay_p(k1) = rlda / (2 * m)
decay_p(k2) = - decay_p(k1)
factor = rlda / msq * factor
else
decay_p(k1) = 0
decay_p(k2) = 0
factor = 0
end if
end subroutine get_msq_x
end subroutine phs_tree_get_msq
@ %def phs_tree_get_msq
@ This subroutine is the most time-critical part of the whole
program. Therefore, we do not exactly parallel the angle generation
routine above but make sure that things get evaluated only if they are
really needed, at the expense of readability. Particularly important
is to have as few multiplications of Lorentz transformations as
possible.
<<PHS trees: procedures>>=
subroutine phs_tree_get_angles (tree, prt, factor, decay_p, sqrts, x)
type(phs_tree_t), intent(inout) :: tree
type(phs_prt_t), dimension(:), intent(in) :: prt
real(default), intent(inout) :: factor
real(default), dimension(:), intent(in) :: decay_p
real(default), intent(in) :: sqrts
real(default), dimension(:), intent(out) :: x
integer :: ix
integer(TC) :: k
ix = 1
k = tree%mask_out
if (tree%branch(k)%has_children) then
call get_angles_x (tree%branch(k), k)
end if
contains
recursive subroutine get_angles_x (b, k, ct0, st0, phi0, L0)
type(phs_branch_t), intent(in) :: b
integer(TC), intent(in) :: k
real(default), intent(in), optional :: ct0, st0, phi0
type(lorentz_transformation_t), intent(in), optional :: L0
real(default) :: cp0, sp0, m, msq, ct, st, phi, bg, f
type(lorentz_transformation_t) :: L, LL
type(vector4_t) :: p1, pf
type(vector3_t) :: n, axis
integer(TC) :: k1, k2, kf
logical :: has_friend, need_L
k1 = b%daughter(1)
k2 = b%daughter(2)
kf = b%friend
has_friend = b%has_friend
if (present(L0)) then
p1 = L0 * phs_prt_get_momentum (prt(k1))
if (has_friend) pf = L0 * phs_prt_get_momentum (prt(kf))
else
p1 = phs_prt_get_momentum (prt(k1))
if (has_friend) pf = phs_prt_get_momentum (prt(kf))
end if
if (present(phi0)) then
cp0 = cos (phi0)
sp0 = sin (phi0)
end if
msq = phs_prt_get_msq (prt(k)); m = sqrt (msq)
if (m > 0) then
bg = decay_p(k) / m
else
bg = 0
end if
if (has_friend) then
if (present (phi0)) then
axis = axis_from_p_r3_r2_b3 (pf, cp0, -sp0, ct0, -st0, -bg)
LL = rotation_to_2nd (axis, vector3_canonical (3)) &
* LT_compose_r3_r2_b3 (cp0, -sp0, ct0, -st0, -bg)
else
axis = axis_from_p_b3 (pf, -bg)
LL = rotation_to_2nd (axis, vector3_canonical(3))
if (.not. vanishes (bg)) LL = LL * boost(-bg, 3)
end if
n = space_part (LL * p1)
else if (present (phi0)) then
n = axis_from_p_r3_r2_b3 (p1, cp0, -sp0, ct0, -st0, -bg)
else
n = axis_from_p_b3 (p1, -bg)
end if
phi = azimuthal_angle (n)
x(ix) = phi / twopi; ix = ix + 1
ct = polar_angle_ct (n)
st = sqrt (1 - ct**2)
call mapping_compute_x_from_ct (tree%mapping(k), sqrts**2, ct, f, &
x(ix)); ix = ix + 1
factor = factor * f
if (tree%branch(k1)%has_children .or. tree%branch(k2)%has_children) then
need_L = .true.
if (has_friend) then
if (present (L0)) then
L = LL * L0
else
L = LL
end if
else if (present (L0)) then
L = LT_compose_r3_r2_b3 (cp0, -sp0, ct0, -st0, -bg) * L0
else if (present (phi0)) then
L = LT_compose_r3_r2_b3 (cp0, -sp0, ct0, -st0, -bg)
else if (bg /= 0) then
L = boost(-bg, 3)
else
need_L = .false.
end if
if (need_L) then
if (tree%branch(k1)%has_children) &
call get_angles_x (tree%branch(k1), k1, ct, st, phi, L)
if (tree%branch(k2)%has_children) &
call get_angles_x (tree%branch(k2), k2, ct, st, phi, L)
else
if (tree%branch(k1)%has_children) &
call get_angles_x (tree%branch(k1), k1, ct, st, phi)
if (tree%branch(k2)%has_children) &
call get_angles_x (tree%branch(k2), k2, ct, st, phi)
end if
end if
end subroutine get_angles_x
end subroutine phs_tree_get_angles
@ %def phs_tree_get_angles
@
\subsubsection{Auxiliary stuff}
This calculates all momenta that are not yet known by summing up
daughter particle momenta. The external particles must be known.
Only composite particles not yet known are calculated.
<<PHS trees: public>>=
public :: phs_tree_combine_particles
<<PHS trees: procedures>>=
subroutine phs_tree_combine_particles (tree, prt)
type(phs_tree_t), intent(in) :: tree
type(phs_prt_t), dimension(:), intent(inout) :: prt
call combine_particles_x (tree%mask_out)
contains
recursive subroutine combine_particles_x (k)
integer(TC), intent(in) :: k
integer :: k1, k2
if (tree%branch(k)%has_children) then
k1 = tree%branch(k)%daughter(1); k2 = tree%branch(k)%daughter(2)
call combine_particles_x (k1)
call combine_particles_x (k2)
if (.not. prt(k)%defined) then
call phs_prt_combine (prt(k), prt(k1), prt(k2))
end if
end if
end subroutine combine_particles_x
end subroutine phs_tree_combine_particles
@ %def phs_tree_combine_particles
@ The previous routine is to be evaluated at runtime. Instead of
scanning trees, we can as well set up a multiplication table. This is
generated here. Note that the table is [[intent(out)]].
<<PHS trees: public>>=
public :: phs_tree_setup_prt_combinations
<<PHS trees: procedures>>=
subroutine phs_tree_setup_prt_combinations (tree, comb)
type(phs_tree_t), intent(in) :: tree
integer, dimension(:,:), intent(out) :: comb
comb = 0
call setup_prt_combinations_x (tree%mask_out)
contains
recursive subroutine setup_prt_combinations_x (k)
integer(TC), intent(in) :: k
integer, dimension(2) :: kk
if (tree%branch(k)%has_children) then
kk = tree%branch(k)%daughter
call setup_prt_combinations_x (kk(1))
call setup_prt_combinations_x (kk(2))
comb(:,k) = kk
end if
end subroutine setup_prt_combinations_x
end subroutine phs_tree_setup_prt_combinations
@ %def phs_tree_setup_prt_combinations
@
<<PHS trees: public>>=
public :: phs_tree_reshuffle_mappings
<<PHS trees: procedures>>=
subroutine phs_tree_reshuffle_mappings (tree)
type(phs_tree_t), intent(inout) :: tree
integer(TC) :: k0, k_old, k_new, k2
integer :: i
type(mapping_t) :: mapping_tmp
real(default) :: mass_tmp
do i = 1, size (tree%momentum_link)
if (i /= tree%momentum_link (i)) then
k_old = 2**(i-tree%n_in-1)
k_new = 2**(tree%momentum_link(i)-tree%n_in-1)
k0 = tree%branch(k_old)%mother
k2 = k_new + tree%branch(k_old)%sibling
mapping_tmp = tree%mapping(k0)
mass_tmp = tree%mass_sum(k0)
tree%mapping(k0) = tree%mapping(k2)
tree%mapping(k2) = mapping_tmp
tree%mass_sum(k0) = tree%mass_sum(k2)
tree%mass_sum(k2) = mass_tmp
end if
end do
end subroutine phs_tree_reshuffle_mappings
@ %def phs_tree_reshuffle_mappings
@
<<PHS trees: public>>=
public :: phs_tree_set_momentum_links
<<PHS trees: procedures>>=
subroutine phs_tree_set_momentum_links (tree, list)
type(phs_tree_t), intent(inout) :: tree
integer, dimension(:), allocatable :: list
tree%momentum_link = list
end subroutine phs_tree_set_momentum_links
@ %def phs_tree_set_momentum_links
@
\subsection{Unit tests}
Test module, followed by the corresponding implementation module.
<<[[phs_trees_ut.f90]]>>=
<<File header>>
module phs_trees_ut
use unit_tests
use phs_trees_uti
<<Standard module head>>
<<PHS trees: public test>>
contains
<<PHS trees: test driver>>
end module phs_trees_ut
@ %def phs_trees_ut
@
<<[[phs_trees_uti.f90]]>>=
<<File header>>
module phs_trees_uti
!!!<<Use kinds>>
use kinds, only: TC
<<Use strings>>
use flavors, only: flavor_t
use model_data, only: model_data_t
use resonances, only: resonance_history_t
use mappings, only: mapping_defaults_t
use phs_trees
<<Standard module head>>
<<PHS trees: test declarations>>
contains
<<PHS trees: tests>>
end module phs_trees_uti
@ %def phs_trees_ut
@ API: driver for the unit tests below.
<<PHS trees: public test>>=
public :: phs_trees_test
<<PHS trees: test driver>>=
subroutine phs_trees_test (u, results)
integer, intent(in) :: u
type(test_results_t), intent(inout) :: results
<<PHS trees: execute tests>>
end subroutine phs_trees_test
@ %def phs_trees_test
@
Create a simple $2\to 3$ PHS tree and display it.
<<PHS trees: execute tests>>=
call test (phs_tree_1, "phs_tree_1", &
"check phs tree setup", &
u, results)
<<PHS trees: test declarations>>=
public :: phs_tree_1
<<PHS trees: tests>>=
subroutine phs_tree_1 (u)
integer, intent(in) :: u
type(phs_tree_t) :: tree
type(model_data_t), target :: model
type(flavor_t), dimension(5) :: flv
integer :: i
write (u, "(A)") "* Test output: phs_tree_1"
write (u, "(A)") "* Purpose: test PHS tree routines"
write (u, "(A)")
write (u, "(A)") "* Read model file"
call model%init_sm_test ()
write (u, "(A)")
write (u, "(A)") "* Set up flavors"
write (u, "(A)")
call flv%init ([1, -2, 24, 5, -5], model)
do i = 1, 5
write (u, "(1x)", advance="no")
call flv(i)%write (u)
end do
write (u, *)
write (u, "(A)")
write (u, "(A)") "* Create tree"
write (u, "(A)")
call tree%init (2, 3, 0, 0)
call tree%from_array ([integer(TC) :: 1, 2, 3, 4, 7, 8, 16])
call tree%set_mass_sum (flv)
call tree%set_effective_masses ()
call tree%write (u)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call tree%final ()
call model%final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: phs_tree_1"
end subroutine phs_tree_1
@ %def phs_tree_1
@ The analogous tree with resonance (s-channel) mappings.
<<PHS trees: execute tests>>=
call test (phs_tree_2, "phs_tree_2", &
"check phs tree with resonances", &
u, results)
<<PHS trees: test declarations>>=
public :: phs_tree_2
<<PHS trees: tests>>=
subroutine phs_tree_2 (u)
integer, intent(in) :: u
type(phs_tree_t) :: tree
type(model_data_t), target :: model
type(mapping_defaults_t) :: mapping_defaults
type(flavor_t), dimension(5) :: flv
type(resonance_history_t) :: res_history
integer :: i
write (u, "(A)") "* Test output: phs_tree_2"
write (u, "(A)") "* Purpose: test PHS tree with resonances"
write (u, "(A)")
write (u, "(A)") "* Read model file"
call model%init_sm_test ()
write (u, "(A)")
write (u, "(A)") "* Set up flavors"
write (u, "(A)")
call flv%init ([1, -2, 24, 5, -5], model)
do i = 1, 5
write (u, "(1x)", advance="no")
call flv(i)%write (u)
end do
write (u, *)
write (u, "(A)")
write (u, "(A)") "* Create tree with mappings"
write (u, "(A)")
call tree%init (2, 3, 0, 0)
call tree%from_array ([integer(TC) :: 1, 2, 3, 4, 7, 8, 16])
call tree%set_mass_sum (flv)
call tree%init_mapping (3_TC, var_str ("s_channel"), -24, model)
call tree%init_mapping (7_TC, var_str ("s_channel"), 23, model)
call tree%set_mapping_parameters (mapping_defaults, variable_limits=.false.)
call tree%set_effective_masses ()
call tree%write (u)
write (u, "(A)")
write (u, "(A)") "* Extract resonances from mappings"
write (u, "(A)")
call tree%extract_resonance_history (res_history)
call res_history%write (u)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call tree%final ()
call model%final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: phs_tree_2"
end subroutine phs_tree_2
@ %def phs_tree_2
@
\clearpage
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{The phase-space forest}
Simply stated, a phase-space forest is a collection of phase-space
trees. More precisely, a [[phs_forest]] object contains all
parameterizations of phase space that \whizard\ will use for a single
hard process, prepared in the form of [[phs_tree]] objects. This is
suitable for evaluation by the \vamp\ integration package: each
parameterization (tree) is a valid channel in the multi-channel
adaptive integration, and each variable in a tree corresponds to an
integration dimension, defined by an appropriate mapping of the
$(0,1)$ interval to the allowed range of the integration variable.
The trees are grouped in groves. The trees (integration channels)
within a grove share a common weight, assuming that they are related
by some approximate symmetry.
Trees/channels that are related by an exact symmetry are connected by
an array of equivalences; each equivalence object holds the data that
relate one channel to another.
The phase-space setup, i.e., the detailed structure of trees and
forest, are read from a file. Therefore, this module also contains
the syntax definition and the parser needed for interpreting this
file.
<<[[phs_forests.f90]]>>=
<<File header>>
module phs_forests
<<Use kinds>>
use kinds, only: TC
<<Use strings>>
use io_units
use format_defs, only: FMT_19
use diagnostics
use lorentz
use numeric_utils
use permutations
use ifiles
use syntax_rules
use lexers
use parser
use model_data
use model_data
use flavors
use interactions
use phs_base
use resonances, only: resonance_history_t
use resonances, only: resonance_history_set_t
use mappings
use phs_trees
<<Standard module head>>
<<PHS forests: public>>
<<PHS forests: types>>
<<PHS forests: interfaces>>
<<PHS forests: variables>>
contains
<<PHS forests: procedures>>
end module phs_forests
@ %def phs_forests
@
\subsection{Phase-space setup parameters}
This transparent container holds the parameters that the algorithm
needs for phase-space setup, with reasonable defaults.
The threshold mass (for considering a particle as effectively
massless) is specified separately for s- and t-channel. The default is
to treat $W$ and $Z$ bosons as massive in the s-channel, but as
massless in the t-channel. The $b$-quark is treated always massless,
the $t$-quark always massive.
<<PHS forests: public>>=
public :: phs_parameters_t
<<PHS forests: types>>=
type :: phs_parameters_t
real(default) :: sqrts = 0
real(default) :: m_threshold_s = 50._default
real(default) :: m_threshold_t = 100._default
integer :: off_shell = 1
integer :: t_channel = 2
logical :: keep_nonresonant = .true.
contains
<<PHS forests: phs parameters: TBP>>
end type phs_parameters_t
@ %def phs_parameters_t
@ Write phase-space parameters to file.
<<PHS forests: phs parameters: TBP>>=
procedure :: write => phs_parameters_write
<<PHS forests: procedures>>=
subroutine phs_parameters_write (phs_par, unit)
class(phs_parameters_t), intent(in) :: phs_par
integer, intent(in), optional :: unit
integer :: u
u = given_output_unit (unit)
write (u, "(3x,A," // FMT_19 // ")") "sqrts = ", phs_par%sqrts
write (u, "(3x,A," // FMT_19 // ")") "m_threshold_s = ", phs_par%m_threshold_s
write (u, "(3x,A," // FMT_19 // ")") "m_threshold_t = ", phs_par%m_threshold_t
write (u, "(3x,A,I0)") "off_shell = ", phs_par%off_shell
write (u, "(3x,A,I0)") "t_channel = ", phs_par%t_channel
write (u, "(3x,A,L1)") "keep_nonresonant = ", phs_par%keep_nonresonant
end subroutine phs_parameters_write
@ %def phs_parameters_write
@ Read phase-space parameters from file.
<<PHS forests: public>>=
public :: phs_parameters_read
<<PHS forests: procedures>>=
subroutine phs_parameters_read (phs_par, unit)
type(phs_parameters_t), intent(out) :: phs_par
integer, intent(in) :: unit
character(20) :: dummy
character :: equals
read (unit, *) dummy, equals, phs_par%sqrts
read (unit, *) dummy, equals, phs_par%m_threshold_s
read (unit, *) dummy, equals, phs_par%m_threshold_t
read (unit, *) dummy, equals, phs_par%off_shell
read (unit, *) dummy, equals, phs_par%t_channel
read (unit, *) dummy, equals, phs_par%keep_nonresonant
end subroutine phs_parameters_read
@ %def phs_parameters_write
@ Comparison.
<<PHS forests: interfaces>>=
interface operator(==)
module procedure phs_parameters_eq
end interface
interface operator(/=)
module procedure phs_parameters_ne
end interface
<<PHS forests: procedures>>=
function phs_parameters_eq (phs_par1, phs_par2) result (equal)
logical :: equal
type(phs_parameters_t), intent(in) :: phs_par1, phs_par2
equal = phs_par1%sqrts == phs_par2%sqrts &
.and. phs_par1%m_threshold_s == phs_par2%m_threshold_s &
.and. phs_par1%m_threshold_t == phs_par2%m_threshold_t &
.and. phs_par1%off_shell == phs_par2%off_shell &
.and. phs_par1%t_channel == phs_par2%t_channel &
.and.(phs_par1%keep_nonresonant .eqv. phs_par2%keep_nonresonant)
end function phs_parameters_eq
function phs_parameters_ne (phs_par1, phs_par2) result (ne)
logical :: ne
type(phs_parameters_t), intent(in) :: phs_par1, phs_par2
ne = phs_par1%sqrts /= phs_par2%sqrts &
.or. phs_par1%m_threshold_s /= phs_par2%m_threshold_s &
.or. phs_par1%m_threshold_t /= phs_par2%m_threshold_t &
.or. phs_par1%off_shell /= phs_par2%off_shell &
.or. phs_par1%t_channel /= phs_par2%t_channel &
.or.(phs_par1%keep_nonresonant .neqv. phs_par2%keep_nonresonant)
end function phs_parameters_ne
@ %def phs_parameters_eq phs_parameters_ne
@
\subsection{Equivalences}
This type holds information about equivalences between phase-space
trees. We make a linked list, where each node contains the two
trees which are equivalent and the corresponding permutation of
external particles. Two more arrays are to be filled: The permutation
of mass variables and the permutation of angular variables, where the
signature indicates a necessary exchange of daughter branches.
<<PHS forests: types>>=
type :: equivalence_t
private
integer :: left, right
type(permutation_t) :: perm
type(permutation_t) :: msq_perm, angle_perm
logical, dimension(:), allocatable :: angle_sig
type(equivalence_t), pointer :: next => null ()
end type equivalence_t
@ %def equivalence_t
<<PHS forests: types>>=
type :: equivalence_list_t
private
integer :: length = 0
type(equivalence_t), pointer :: first => null ()
type(equivalence_t), pointer :: last => null ()
end type equivalence_list_t
@ %def equivalence_list_t
@ Append an equivalence to the list
<<PHS forests: procedures>>=
subroutine equivalence_list_add (eql, left, right, perm)
type(equivalence_list_t), intent(inout) :: eql
integer, intent(in) :: left, right
type(permutation_t), intent(in) :: perm
type(equivalence_t), pointer :: eq
allocate (eq)
eq%left = left
eq%right = right
eq%perm = perm
if (associated (eql%last)) then
eql%last%next => eq
else
eql%first => eq
end if
eql%last => eq
eql%length = eql%length + 1
end subroutine equivalence_list_add
@ %def equivalence_list_add
@ Delete the list contents. Has to be pure because it is called from
an elemental subroutine.
<<PHS forests: procedures>>=
pure subroutine equivalence_list_final (eql)
type(equivalence_list_t), intent(inout) :: eql
type(equivalence_t), pointer :: eq
do while (associated (eql%first))
eq => eql%first
eql%first => eql%first%next
deallocate (eq)
end do
eql%last => null ()
eql%length = 0
end subroutine equivalence_list_final
@ %def equivalence_list_final
@ Make a deep copy of the equivalence list. This allows for deep
copies of groves and forests.
<<PHS forests: interfaces>>=
interface assignment(=)
module procedure equivalence_list_assign
end interface
<<PHS forests: procedures>>=
subroutine equivalence_list_assign (eql_out, eql_in)
type(equivalence_list_t), intent(out) :: eql_out
type(equivalence_list_t), intent(in) :: eql_in
type(equivalence_t), pointer :: eq, eq_copy
eq => eql_in%first
do while (associated (eq))
allocate (eq_copy)
eq_copy = eq
eq_copy%next => null ()
if (associated (eql_out%first)) then
eql_out%last%next => eq_copy
else
eql_out%first => eq_copy
end if
eql_out%last => eq_copy
eq => eq%next
end do
end subroutine equivalence_list_assign
@ %def equivalence_list_assign
@ The number of list entries
<<PHS forests: procedures>>=
elemental function equivalence_list_length (eql) result (length)
integer :: length
type(equivalence_list_t), intent(in) :: eql
length = eql%length
end function equivalence_list_length
@ %def equivalence_list_length
@ Recursively write the equivalences list
<<PHS forests: procedures>>=
subroutine equivalence_list_write (eql, unit)
type(equivalence_list_t), intent(in) :: eql
integer, intent(in), optional :: unit
integer :: u
u = given_output_unit (unit); if (u < 0) return
if (associated (eql%first)) then
call equivalence_write_rec (eql%first, u)
else
write (u, *) " [empty]"
end if
contains
recursive subroutine equivalence_write_rec (eq, u)
type(equivalence_t), intent(in) :: eq
integer, intent(in) :: u
integer :: i
write (u, "(3x,A,1x,I0,1x,I0,2x,A)", advance="no") &
"Equivalence:", eq%left, eq%right, "Final state permutation:"
call permutation_write (eq%perm, u)
write (u, "(1x,12x,1x,A,1x)", advance="no") &
" msq permutation: "
call permutation_write (eq%msq_perm, u)
write (u, "(1x,12x,1x,A,1x)", advance="no") &
" angle permutation:"
call permutation_write (eq%angle_perm, u)
write (u, "(1x,12x,1x,26x)", advance="no")
do i = 1, size (eq%angle_sig)
if (eq%angle_sig(i)) then
write (u, "(1x,A)", advance="no") "+"
else
write (u, "(1x,A)", advance="no") "-"
end if
end do
write (u, *)
if (associated (eq%next)) call equivalence_write_rec (eq%next, u)
end subroutine equivalence_write_rec
end subroutine equivalence_list_write
@ %def equivalence_list_write
@
\subsection{Groves}
A grove is a group of trees (phase-space channels) that share a common
weight in the integration. Within a grove, channels can be declared
equivalent, so they also share their integration grids (up to
symmetries). The grove contains a list of equivalences. The
[[tree_count_offset]] is the total number of trees of the preceding
groves; when the trees are counted per forest (integration channels),
the offset has to be added to all tree indices.
<<PHS forests: types>>=
type :: phs_grove_t
private
integer :: tree_count_offset
type(phs_tree_t), dimension(:), allocatable :: tree
type(equivalence_list_t) :: equivalence_list
end type phs_grove_t
@ %def phs_grove_t
@ Call [[phs_tree_init]] which is also elemental:
<<PHS forests: procedures>>=
elemental subroutine phs_grove_init &
(grove, n_trees, n_in, n_out, n_masses, n_angles)
type(phs_grove_t), intent(inout) :: grove
integer, intent(in) :: n_trees, n_in, n_out, n_masses, n_angles
grove%tree_count_offset = 0
allocate (grove%tree (n_trees))
call phs_tree_init (grove%tree, n_in, n_out, n_masses, n_angles)
end subroutine phs_grove_init
@ %def phs_grove_init
@ The trees do not have pointer components, thus no call to
[[phs_tree_final]]:
<<PHS forests: procedures>>=
elemental subroutine phs_grove_final (grove)
type(phs_grove_t), intent(inout) :: grove
deallocate (grove%tree)
call equivalence_list_final (grove%equivalence_list)
end subroutine phs_grove_final
@ %def phs_grove_final
@ Deep copy.
<<PHS forests: interfaces>>=
interface assignment(=)
module procedure phs_grove_assign0
module procedure phs_grove_assign1
end interface
<<PHS forests: procedures>>=
subroutine phs_grove_assign0 (grove_out, grove_in)
type(phs_grove_t), intent(out) :: grove_out
type(phs_grove_t), intent(in) :: grove_in
grove_out%tree_count_offset = grove_in%tree_count_offset
if (allocated (grove_in%tree)) then
allocate (grove_out%tree (size (grove_in%tree)))
grove_out%tree = grove_in%tree
end if
grove_out%equivalence_list = grove_in%equivalence_list
end subroutine phs_grove_assign0
subroutine phs_grove_assign1 (grove_out, grove_in)
type(phs_grove_t), dimension(:), intent(out) :: grove_out
type(phs_grove_t), dimension(:), intent(in) :: grove_in
integer :: i
do i = 1, size (grove_in)
call phs_grove_assign0 (grove_out(i), grove_in(i))
end do
end subroutine phs_grove_assign1
@ %def phs_grove_assign
@ Get the global (s-channel) mappings. Implemented as a subroutine
which returns an array (slice).
<<PHS forests: procedures>>=
subroutine phs_grove_assign_s_mappings (grove, mapping)
type(phs_grove_t), intent(in) :: grove
type(mapping_t), dimension(:), intent(out) :: mapping
integer :: i
if (size (mapping) == size (grove%tree)) then
do i = 1, size (mapping)
call phs_tree_assign_s_mapping (grove%tree(i), mapping(i))
end do
else
call msg_bug ("phs_grove_assign_s_mappings: array size mismatch")
end if
end subroutine phs_grove_assign_s_mappings
@ %def phs_grove_assign_s_mappings
@
\subsection{The forest type}
This is a collection of trees and associated particles. In a given
tree, each branch code corresponds to a particle in the [[prt]] array.
Furthermore, we have an array of mass sums which is independent of the
decay tree and of the particular event. The mappings directly
correspond to the decay trees, and the decay groves collect the trees
in classes. The permutation list consists of all permutations of
outgoing particles that map the decay forest onto itself.
The particle codes [[flv]] (one for each external particle) are needed
for determining masses and such. The trees and associated information
are collected in the [[grove]] array, together with a lookup table
that associates tree indices to groves. Finally, the [[prt]] array
serves as workspace for phase-space evaluation.
The [[prt_combination]] is a list of index pairs, namely the particle
momenta pairs that need to be combined in order to provide all
momentum combinations that the phase-space trees need to know.
<<PHS forests: public>>=
public :: phs_forest_t
<<PHS forests: types>>=
type :: phs_forest_t
private
integer :: n_in, n_out, n_tot
integer :: n_masses, n_angles, n_dimensions
integer :: n_trees, n_equivalences
type(flavor_t), dimension(:), allocatable :: flv
type(phs_grove_t), dimension(:), allocatable :: grove
integer, dimension(:), allocatable :: grove_lookup
type(phs_prt_t), dimension(:), allocatable :: prt_in
type(phs_prt_t), dimension(:), allocatable :: prt_out
type(phs_prt_t), dimension(:), allocatable :: prt
integer(TC), dimension(:,:), allocatable :: prt_combination
type(mapping_t), dimension(:), allocatable :: s_mapping
contains
<<PHS forests: phs forest: TBP>>
end type phs_forest_t
@ %def phs_forest_t
@
The initialization merely allocates memory. We have to know how many
trees there are in each grove, so we can initialize everything. The
number of groves is the size of the [[n_tree]] array.
In the [[grove_lookup]] table we store the grove index that belongs to
each absolute tree index. The difference between the absolute index
and the relative (to the grove) index is stored, for each grove, as
[[tree_count_offset]].
The particle array is allocated according to the total number of
branches each tree has, but not filled.
<<PHS forests: public>>=
public :: phs_forest_init
<<PHS forests: procedures>>=
subroutine phs_forest_init (forest, n_tree, n_in, n_out)
type(phs_forest_t), intent(inout) :: forest
integer, dimension(:), intent(in) :: n_tree
integer, intent(in) :: n_in, n_out
integer :: g, count, k_root
forest%n_in = n_in
forest%n_out = n_out
forest%n_tot = n_in + n_out
forest%n_masses = max (n_out - 2, 0)
forest%n_angles = max (2*n_out - 2, 0)
forest%n_dimensions = forest%n_masses + forest%n_angles
forest%n_trees = sum (n_tree)
forest%n_equivalences = 0
allocate (forest%grove (size (n_tree)))
call phs_grove_init &
(forest%grove, n_tree, n_in, n_out, forest%n_masses, &
forest%n_angles)
allocate (forest%grove_lookup (forest%n_trees))
count = 0
do g = 1, size (forest%grove)
forest%grove(g)%tree_count_offset = count
forest%grove_lookup (count+1:count+n_tree(g)) = g
count = count + n_tree(g)
end do
allocate (forest%prt_in (n_in))
allocate (forest%prt_out (forest%n_out))
k_root = 2**forest%n_tot - 1
allocate (forest%prt (k_root))
allocate (forest%prt_combination (2, k_root))
allocate (forest%s_mapping (forest%n_trees))
end subroutine phs_forest_init
@ %def phs_forest_init
@ Assign the global (s-channel) mappings.
<<PHS forests: public>>=
public :: phs_forest_set_s_mappings
<<PHS forests: procedures>>=
subroutine phs_forest_set_s_mappings (forest)
type(phs_forest_t), intent(inout) :: forest
integer :: g, i0, i1, n
do g = 1, size (forest%grove)
call phs_forest_get_grove_bounds (forest, g, i0, i1, n)
call phs_grove_assign_s_mappings &
(forest%grove(g), forest%s_mapping(i0:i1))
end do
end subroutine phs_forest_set_s_mappings
@ %def phs_forest_set_s_mappings
@ The grove finalizer is called because it contains the equivalence list:
<<PHS forests: public>>=
public :: phs_forest_final
<<PHS forests: procedures>>=
subroutine phs_forest_final (forest)
type(phs_forest_t), intent(inout) :: forest
if (allocated (forest%grove)) then
call phs_grove_final (forest%grove)
deallocate (forest%grove)
end if
if (allocated (forest%grove_lookup)) deallocate (forest%grove_lookup)
if (allocated (forest%prt)) deallocate (forest%prt)
if (allocated (forest%s_mapping)) deallocate (forest%s_mapping)
end subroutine phs_forest_final
@ %def phs_forest_final
@
\subsection{Screen output}
Write the particles that are non-null, then the trees which point to
them:
<<PHS forests: public>>=
public :: phs_forest_write
<<PHS forests: phs forest: TBP>>=
procedure :: write => phs_forest_write
<<PHS forests: procedures>>=
subroutine phs_forest_write (forest, unit)
class(phs_forest_t), intent(in) :: forest
integer, intent(in), optional :: unit
integer :: u
integer :: i, g, k
u = given_output_unit (unit); if (u < 0) return
write (u, "(1x,A)") "Phase space forest:"
write (u, "(3x,A,I0)") "n_in = ", forest%n_in
write (u, "(3x,A,I0)") "n_out = ", forest%n_out
write (u, "(3x,A,I0)") "n_tot = ", forest%n_tot
write (u, "(3x,A,I0)") "n_masses = ", forest%n_masses
write (u, "(3x,A,I0)") "n_angles = ", forest%n_angles
write (u, "(3x,A,I0)") "n_dim = ", forest%n_dimensions
write (u, "(3x,A,I0)") "n_trees = ", forest%n_trees
write (u, "(3x,A,I0)") "n_equiv = ", forest%n_equivalences
write (u, "(3x,A)", advance="no") "flavors ="
if (allocated (forest%flv)) then
do i = 1, size (forest%flv)
write (u, "(1x,I0)", advance="no") forest%flv(i)%get_pdg ()
end do
write (u, "(A)")
else
write (u, "(1x,A)") "[empty]"
end if
write (u, "(1x,A)") "Particle combinations:"
if (allocated (forest%prt_combination)) then
do k = 1, size (forest%prt_combination, 2)
if (forest%prt_combination(1, k) /= 0) then
write (u, "(3x,I0,1x,'<=',1x,I0,1x,'+',1x,I0)") &
k, forest%prt_combination(:,k)
end if
end do
else
write (u, "(3x,A)") " [empty]"
end if
write (u, "(1x,A)") "Groves and trees:"
if (allocated (forest%grove)) then
do g = 1, size (forest%grove)
write (u, "(3x,A,1x,I0)") "Grove ", g
call phs_grove_write (forest%grove(g), unit)
end do
else
write (u, "(3x,A)") " [empty]"
end if
write (u, "(1x,A,I0)") "Total number of equivalences: ", &
forest%n_equivalences
write (u, "(A)")
write (u, "(1x,A)") "Global s-channel mappings:"
if (allocated (forest%s_mapping)) then
do i = 1, size (forest%s_mapping)
associate (mapping => forest%s_mapping(i))
if (mapping_is_s_channel (mapping) &
.or. mapping_is_on_shell (mapping)) then
write (u, "(1x,I0,':',1x)", advance="no") i
call mapping_write (forest%s_mapping(i), unit)
end if
end associate
end do
else
write (u, "(3x,A)") " [empty]"
end if
write (u, "(A)")
write (u, "(1x,A)") "Incoming particles:"
if (allocated (forest%prt_in)) then
if (any (phs_prt_is_defined (forest%prt_in))) then
do i = 1, size (forest%prt_in)
if (phs_prt_is_defined (forest%prt_in(i))) then
write (u, "(1x,A,1x,I0)") "Particle", i
call phs_prt_write (forest%prt_in(i), u)
end if
end do
else
write (u, "(3x,A)") "[all undefined]"
end if
else
write (u, "(3x,A)") " [empty]"
end if
write (u, "(A)")
write (u, "(1x,A)") "Outgoing particles:"
if (allocated (forest%prt_out)) then
if (any (phs_prt_is_defined (forest%prt_out))) then
do i = 1, size (forest%prt_out)
if (phs_prt_is_defined (forest%prt_out(i))) then
write (u, "(1x,A,1x,I0)") "Particle", i
call phs_prt_write (forest%prt_out(i), u)
end if
end do
else
write (u, "(3x,A)") "[all undefined]"
end if
else
write (u, "(1x,A)") " [empty]"
end if
write (u, "(A)")
write (u, "(1x,A)") "Tree particles:"
if (allocated (forest%prt)) then
if (any (phs_prt_is_defined (forest%prt))) then
do i = 1, size (forest%prt)
if (phs_prt_is_defined (forest%prt(i))) then
write (u, "(1x,A,1x,I0)") "Particle", i
call phs_prt_write (forest%prt(i), u)
end if
end do
else
write (u, "(3x,A)") "[all undefined]"
end if
else
write (u, "(3x,A)") " [empty]"
end if
end subroutine phs_forest_write
subroutine phs_grove_write (grove, unit)
type(phs_grove_t), intent(in) :: grove
integer, intent(in), optional :: unit
integer :: u
integer :: t
u = given_output_unit (unit); if (u < 0) return
do t = 1, size (grove%tree)
write (u, "(3x,A,I0)") "Tree ", t
call phs_tree_write (grove%tree(t), unit)
end do
write (u, "(1x,A)") "Equivalence list:"
call equivalence_list_write (grove%equivalence_list, unit)
end subroutine phs_grove_write
@ %def phs_grove_write phs_forest_write
@ Deep copy.
<<PHS forests: public>>=
public :: assignment(=)
<<PHS forests: interfaces>>=
interface assignment(=)
module procedure phs_forest_assign
end interface
<<PHS forests: procedures>>=
subroutine phs_forest_assign (forest_out, forest_in)
type(phs_forest_t), intent(out) :: forest_out
type(phs_forest_t), intent(in) :: forest_in
forest_out%n_in = forest_in%n_in
forest_out%n_out = forest_in%n_out
forest_out%n_tot = forest_in%n_tot
forest_out%n_masses = forest_in%n_masses
forest_out%n_angles = forest_in%n_angles
forest_out%n_dimensions = forest_in%n_dimensions
forest_out%n_trees = forest_in%n_trees
forest_out%n_equivalences = forest_in%n_equivalences
if (allocated (forest_in%flv)) then
allocate (forest_out%flv (size (forest_in%flv)))
forest_out%flv = forest_in%flv
end if
if (allocated (forest_in%grove)) then
allocate (forest_out%grove (size (forest_in%grove)))
forest_out%grove = forest_in%grove
end if
if (allocated (forest_in%grove_lookup)) then
allocate (forest_out%grove_lookup (size (forest_in%grove_lookup)))
forest_out%grove_lookup = forest_in%grove_lookup
end if
if (allocated (forest_in%prt_in)) then
allocate (forest_out%prt_in (size (forest_in%prt_in)))
forest_out%prt_in = forest_in%prt_in
end if
if (allocated (forest_in%prt_out)) then
allocate (forest_out%prt_out (size (forest_in%prt_out)))
forest_out%prt_out = forest_in%prt_out
end if
if (allocated (forest_in%prt)) then
allocate (forest_out%prt (size (forest_in%prt)))
forest_out%prt = forest_in%prt
end if
if (allocated (forest_in%s_mapping)) then
allocate (forest_out%s_mapping (size (forest_in%s_mapping)))
forest_out%s_mapping = forest_in%s_mapping
end if
if (allocated (forest_in%prt_combination)) then
allocate (forest_out%prt_combination &
(2, size (forest_in%prt_combination, 2)))
forest_out%prt_combination = forest_in%prt_combination
end if
end subroutine phs_forest_assign
@ %def phs_forest_assign
@
\subsection{Accessing contents}
Get the number of integration parameters
<<PHS forests: public>>=
public :: phs_forest_get_n_parameters
<<PHS forests: procedures>>=
function phs_forest_get_n_parameters (forest) result (n)
integer :: n
type(phs_forest_t), intent(in) :: forest
n = forest%n_dimensions
end function phs_forest_get_n_parameters
@ %def phs_forest_get_n_parameters
@ Get the number of integration channels
<<PHS forests: public>>=
public :: phs_forest_get_n_channels
<<PHS forests: procedures>>=
function phs_forest_get_n_channels (forest) result (n)
integer :: n
type(phs_forest_t), intent(in) :: forest
n = forest%n_trees
end function phs_forest_get_n_channels
@ %def phs_forest_get_n_channels
@ Get the number of groves
<<PHS forests: public>>=
public :: phs_forest_get_n_groves
<<PHS forests: procedures>>=
function phs_forest_get_n_groves (forest) result (n)
integer :: n
type(phs_forest_t), intent(in) :: forest
n = size (forest%grove)
end function phs_forest_get_n_groves
@ %def phs_forest_get_n_groves
@ Get the index bounds for a specific grove.
<<PHS forests: public>>=
public :: phs_forest_get_grove_bounds
<<PHS forests: procedures>>=
subroutine phs_forest_get_grove_bounds (forest, g, i0, i1, n)
type(phs_forest_t), intent(in) :: forest
integer, intent(in) :: g
integer, intent(out) :: i0, i1, n
n = size (forest%grove(g)%tree)
i0 = forest%grove(g)%tree_count_offset + 1
i1 = forest%grove(g)%tree_count_offset + n
end subroutine phs_forest_get_grove_bounds
@ %def phs_forest_get_grove_bounds
@ Get the number of equivalences
<<PHS forests: public>>=
public :: phs_forest_get_n_equivalences
<<PHS forests: procedures>>=
function phs_forest_get_n_equivalences (forest) result (n)
integer :: n
type(phs_forest_t), intent(in) :: forest
n = forest%n_equivalences
end function phs_forest_get_n_equivalences
@ %def phs_forest_get_n_equivalences
@ Return true if a particular channel has a global (s-channel)
mapping; also return the resonance mass and width for this mapping.
<<PHS forests: public>>=
public :: phs_forest_get_s_mapping
public :: phs_forest_get_on_shell
<<PHS forests: procedures>>=
subroutine phs_forest_get_s_mapping (forest, channel, flag, mass, width)
type(phs_forest_t), intent(in) :: forest
integer, intent(in) :: channel
logical, intent(out) :: flag
real(default), intent(out) :: mass, width
flag = mapping_is_s_channel (forest%s_mapping(channel))
if (flag) then
mass = mapping_get_mass (forest%s_mapping(channel))
width = mapping_get_width (forest%s_mapping(channel))
else
mass = 0
width = 0
end if
end subroutine phs_forest_get_s_mapping
subroutine phs_forest_get_on_shell (forest, channel, flag, mass)
type(phs_forest_t), intent(in) :: forest
integer, intent(in) :: channel
logical, intent(out) :: flag
real(default), intent(out) :: mass
flag = mapping_is_on_shell (forest%s_mapping(channel))
if (flag) then
mass = mapping_get_mass (forest%s_mapping(channel))
else
mass = 0
end if
end subroutine phs_forest_get_on_shell
@ %def phs_forest_get_s_mapping
@ %def phs_forest_get_on_shell
@
Extract the set of unique resonance histories, in form of an array.
<<PHS forests: phs forest: TBP>>=
procedure :: extract_resonance_history_set &
=> phs_forest_extract_resonance_history_set
<<PHS forests: procedures>>=
subroutine phs_forest_extract_resonance_history_set &
(forest, res_set, include_trivial)
class(phs_forest_t), intent(in) :: forest
type(resonance_history_set_t), intent(out) :: res_set
logical, intent(in), optional :: include_trivial
type(resonance_history_t) :: rh
integer :: g, t
logical :: triv
triv = .false.; if (present (include_trivial)) triv = include_trivial
call res_set%init ()
do g = 1, size (forest%grove)
associate (grove => forest%grove(g))
do t = 1, size (grove%tree)
call grove%tree(t)%extract_resonance_history (rh)
call res_set%enter (rh, include_trivial)
end do
end associate
end do
call res_set%freeze ()
end subroutine phs_forest_extract_resonance_history_set
@ %def phs_forest_extract_resonance_history_set
@
\subsection{Read the phase space setup from file}
The phase space setup is stored in a file. The file may be generated
by the [[cascades]] module below, or by other means. This file has to
be read and parsed to create the PHS forest as the internal
phase-space representation.
Create lexer and syntax:
<<PHS forests: procedures>>=
subroutine define_phs_forest_syntax (ifile)
type(ifile_t) :: ifile
call ifile_append (ifile, "SEQ phase_space_list = process_phase_space*")
call ifile_append (ifile, "SEQ process_phase_space = " &
// "process_def process_header phase_space")
call ifile_append (ifile, "SEQ process_def = process process_list")
call ifile_append (ifile, "KEY process")
call ifile_append (ifile, "LIS process_list = process_tag*")
call ifile_append (ifile, "IDE process_tag")
call ifile_append (ifile, "SEQ process_header = " &
// "md5sum_process = md5sum " &
// "md5sum_model_par = md5sum " &
// "md5sum_phs_config = md5sum " &
// "sqrts = real " &
// "m_threshold_s = real " &
// "m_threshold_t = real " &
// "off_shell = integer " &
// "t_channel = integer " &
// "keep_nonresonant = logical")
call ifile_append (ifile, "KEY '='")
call ifile_append (ifile, "KEY '-'")
call ifile_append (ifile, "KEY md5sum_process")
call ifile_append (ifile, "KEY md5sum_model_par")
call ifile_append (ifile, "KEY md5sum_phs_config")
call ifile_append (ifile, "KEY sqrts")
call ifile_append (ifile, "KEY m_threshold_s")
call ifile_append (ifile, "KEY m_threshold_t")
call ifile_append (ifile, "KEY off_shell")
call ifile_append (ifile, "KEY t_channel")
call ifile_append (ifile, "KEY keep_nonresonant")
call ifile_append (ifile, "QUO md5sum = '""' ... '""'")
call ifile_append (ifile, "REA real")
call ifile_append (ifile, "INT integer")
call ifile_append (ifile, "IDE logical")
call ifile_append (ifile, "SEQ phase_space = grove_def+")
call ifile_append (ifile, "SEQ grove_def = grove tree_def+")
call ifile_append (ifile, "KEY grove")
call ifile_append (ifile, "SEQ tree_def = tree bincodes mapping*")
call ifile_append (ifile, "KEY tree")
call ifile_append (ifile, "SEQ bincodes = bincode*")
call ifile_append (ifile, "INT bincode")
call ifile_append (ifile, "SEQ mapping = map bincode channel signed_pdg")
call ifile_append (ifile, "KEY map")
call ifile_append (ifile, "ALT channel = &
&s_channel | t_channel | u_channel | &
&collinear | infrared | radiation | on_shell")
call ifile_append (ifile, "KEY s_channel")
! call ifile_append (ifile, "KEY t_channel") !!! Key already exists
call ifile_append (ifile, "KEY u_channel")
call ifile_append (ifile, "KEY collinear")
call ifile_append (ifile, "KEY infrared")
call ifile_append (ifile, "KEY radiation")
call ifile_append (ifile, "KEY on_shell")
call ifile_append (ifile, "ALT signed_pdg = &
&pdg | negative_pdg")
call ifile_append (ifile, "SEQ negative_pdg = '-' pdg")
call ifile_append (ifile, "INT pdg")
end subroutine define_phs_forest_syntax
@ %def define_phs_forest_syntax
@ The model-file syntax and lexer are fixed, therefore stored as
module variables:
<<PHS forests: variables>>=
type(syntax_t), target, save :: syntax_phs_forest
@ %def syntax_phs_forest
<<PHS forests: public>>=
public :: syntax_phs_forest_init
<<PHS forests: procedures>>=
subroutine syntax_phs_forest_init ()
type(ifile_t) :: ifile
call define_phs_forest_syntax (ifile)
call syntax_init (syntax_phs_forest, ifile)
call ifile_final (ifile)
end subroutine syntax_phs_forest_init
@ %def syntax_phs_forest_init
<<PHS forests: procedures>>=
subroutine lexer_init_phs_forest (lexer)
type(lexer_t), intent(out) :: lexer
call lexer_init (lexer, &
comment_chars = "#!", &
quote_chars = '"', &
quote_match = '"', &
single_chars = "-", &
special_class = ["="] , &
keyword_list = syntax_get_keyword_list_ptr (syntax_phs_forest))
end subroutine lexer_init_phs_forest
@ %def lexer_init_phs_forest
<<PHS forests: public>>=
public :: syntax_phs_forest_final
<<PHS forests: procedures>>=
subroutine syntax_phs_forest_final ()
call syntax_final (syntax_phs_forest)
end subroutine syntax_phs_forest_final
@ %def syntax_phs_forest_final
<<PHS forests: public>>=
public :: syntax_phs_forest_write
<<PHS forests: procedures>>=
subroutine syntax_phs_forest_write (unit)
integer, intent(in), optional :: unit
call syntax_write (syntax_phs_forest, unit)
end subroutine syntax_phs_forest_write
@ %def syntax_phs_forest_write
@ The concrete parser and interpreter. Generate an input stream for
the external [[unit]], read the parse tree (with given [[syntax]] and
[[lexer]]) from this stream, and transfer the contents of the parse
tree to the PHS [[forest]].
We look for the matching [[process]] tag, count groves and trees for
initializing the [[forest]], and fill the trees.
If the optional parameters are set, compare the parameters stored in
the file to those. Set [[match]] true if everything agrees.
<<PHS forests: public>>=
public :: phs_forest_read
<<PHS forests: interfaces>>=
interface phs_forest_read
module procedure phs_forest_read_file
module procedure phs_forest_read_unit
module procedure phs_forest_read_parse_tree
end interface
<<PHS forests: procedures>>=
subroutine phs_forest_read_file &
(forest, filename, process_id, n_in, n_out, model, found, &
md5sum_process, md5sum_model_par, &
md5sum_phs_config, phs_par, match)
type(phs_forest_t), intent(out) :: forest
type(string_t), intent(in) :: filename
type(string_t), intent(in) :: process_id
integer, intent(in) :: n_in, n_out
class(model_data_t), intent(in), target :: model
logical, intent(out) :: found
character(32), intent(in), optional :: &
md5sum_process, md5sum_model_par, md5sum_phs_config
type(phs_parameters_t), intent(in), optional :: phs_par
logical, intent(out), optional :: match
type(parse_tree_t), target :: parse_tree
type(stream_t), target :: stream
type(lexer_t) :: lexer
call lexer_init_phs_forest (lexer)
call stream_init (stream, char (filename))
call lexer_assign_stream (lexer, stream)
call parse_tree_init (parse_tree, syntax_phs_forest, lexer)
call phs_forest_read (forest, parse_tree, &
process_id, n_in, n_out, model, found, &
md5sum_process, md5sum_model_par, md5sum_phs_config, phs_par, match)
call stream_final (stream)
call lexer_final (lexer)
call parse_tree_final (parse_tree)
end subroutine phs_forest_read_file
subroutine phs_forest_read_unit &
(forest, unit, process_id, n_in, n_out, model, found, &
md5sum_process, md5sum_model_par, md5sum_phs_config, &
phs_par, match)
type(phs_forest_t), intent(out) :: forest
integer, intent(in) :: unit
type(string_t), intent(in) :: process_id
integer, intent(in) :: n_in, n_out
class(model_data_t), intent(in), target :: model
logical, intent(out) :: found
character(32), intent(in), optional :: &
md5sum_process, md5sum_model_par, md5sum_phs_config
type(phs_parameters_t), intent(in), optional :: phs_par
logical, intent(out), optional :: match
type(parse_tree_t), target :: parse_tree
type(stream_t), target :: stream
type(lexer_t) :: lexer
call lexer_init_phs_forest (lexer)
call stream_init (stream, unit)
call lexer_assign_stream (lexer, stream)
call parse_tree_init (parse_tree, syntax_phs_forest, lexer)
call phs_forest_read (forest, parse_tree, &
process_id, n_in, n_out, model, found, &
md5sum_process, md5sum_model_par, md5sum_phs_config, &
phs_par, match)
call stream_final (stream)
call lexer_final (lexer)
call parse_tree_final (parse_tree)
end subroutine phs_forest_read_unit
subroutine phs_forest_read_parse_tree &
(forest, parse_tree, process_id, n_in, n_out, model, found, &
md5sum_process, md5sum_model_par, md5sum_phs_config, &
phs_par, match)
type(phs_forest_t), intent(out) :: forest
type(parse_tree_t), intent(in), target :: parse_tree
type(string_t), intent(in) :: process_id
integer, intent(in) :: n_in, n_out
class(model_data_t), intent(in), target :: model
logical, intent(out) :: found
character(32), intent(in), optional :: &
md5sum_process, md5sum_model_par, md5sum_phs_config
type(phs_parameters_t), intent(in), optional :: phs_par
logical, intent(out), optional :: match
type(parse_node_t), pointer :: node_header, node_phs, node_grove
integer :: n_grove, g
integer, dimension(:), allocatable :: n_tree
integer :: t
node_header => parse_tree_get_process_ptr (parse_tree, process_id)
found = associated (node_header); if (.not. found) return
if (present (match)) then
call phs_forest_check_input (node_header, &
md5sum_process, md5sum_model_par, md5sum_phs_config, phs_par, match)
if (.not. match) return
end if
node_phs => parse_node_get_next_ptr (node_header)
n_grove = parse_node_get_n_sub (node_phs)
allocate (n_tree (n_grove))
do g = 1, n_grove
node_grove => parse_node_get_sub_ptr (node_phs, g)
n_tree(g) = parse_node_get_n_sub (node_grove) - 1
end do
call phs_forest_init (forest, n_tree, n_in, n_out)
do g = 1, n_grove
node_grove => parse_node_get_sub_ptr (node_phs, g)
do t = 1, n_tree(g)
call phs_tree_set (forest%grove(g)%tree(t), &
parse_node_get_sub_ptr (node_grove, t+1), model)
end do
end do
end subroutine phs_forest_read_parse_tree
@ %def phs_forest
@ Check the input for consistency. If any MD5 sum or phase-space
parameter disagrees, the phase-space file cannot be used. The MD5
sum checks are skipped if the stored MD5 sum is empty.
<<PHS forests: procedures>>=
subroutine phs_forest_check_input (pn_header, &
md5sum_process, md5sum_model_par, md5sum_phs_config, phs_par, match)
type(parse_node_t), intent(in), target :: pn_header
character(32), intent(in) :: &
md5sum_process, md5sum_model_par, md5sum_phs_config
type(phs_parameters_t), intent(in), optional :: phs_par
logical, intent(out) :: match
type(parse_node_t), pointer :: pn_md5sum, pn_rval, pn_ival, pn_lval
character(32) :: md5sum
type(phs_parameters_t) :: phs_par_old
character(1) :: lstr
pn_md5sum => parse_node_get_sub_ptr (pn_header, 3)
md5sum = parse_node_get_string (pn_md5sum)
if (md5sum /= "" .and. md5sum /= md5sum_process) then
call msg_message ("Phase space: discarding old configuration &
&(process changed)")
match = .false.; return
end if
pn_md5sum => parse_node_get_next_ptr (pn_md5sum, 3)
md5sum = parse_node_get_string (pn_md5sum)
if (md5sum /= "" .and. md5sum /= md5sum_model_par) then
call msg_message ("Phase space: discarding old configuration &
&(model parameters changed)")
match = .false.; return
end if
pn_md5sum => parse_node_get_next_ptr (pn_md5sum, 3)
md5sum = parse_node_get_string (pn_md5sum)
if (md5sum /= "" .and. md5sum /= md5sum_phs_config) then
call msg_message ("Phase space: discarding old configuration &
&(configuration parameters changed)")
match = .false.; return
end if
if (present (phs_par)) then
pn_rval => parse_node_get_next_ptr (pn_md5sum, 3)
phs_par_old%sqrts = parse_node_get_real (pn_rval)
pn_rval => parse_node_get_next_ptr (pn_rval, 3)
phs_par_old%m_threshold_s = parse_node_get_real (pn_rval)
pn_rval => parse_node_get_next_ptr (pn_rval, 3)
phs_par_old%m_threshold_t = parse_node_get_real (pn_rval)
pn_ival => parse_node_get_next_ptr (pn_rval, 3)
phs_par_old%off_shell = parse_node_get_integer (pn_ival)
pn_ival => parse_node_get_next_ptr (pn_ival, 3)
phs_par_old%t_channel = parse_node_get_integer (pn_ival)
pn_lval => parse_node_get_next_ptr (pn_ival, 3)
lstr = parse_node_get_string (pn_lval)
read (lstr, "(L1)") phs_par_old%keep_nonresonant
if (phs_par_old /= phs_par) then
call msg_message &
("Phase space: discarding old configuration &
&(configuration parameters changed)")
match = .false.; return
end if
end if
match = .true.
end subroutine phs_forest_check_input
@ %def phs_forest_check_input
@ Initialize a specific tree in the forest, using the contents of the
'tree' node. First, count the bincodes, allocate an array and read
them in, and make the tree. Each $t$-channel tree is flipped to
$s$-channel. Then, find mappings and initialize them.
<<PHS forests: procedures>>=
subroutine phs_tree_set (tree, node, model)
type(phs_tree_t), intent(inout) :: tree
type(parse_node_t), intent(in), target :: node
class(model_data_t), intent(in), target :: model
type(parse_node_t), pointer :: node_bincodes, node_mapping, pn_pdg
integer :: n_bincodes, offset
integer(TC), dimension(:), allocatable :: bincode
integer :: b, n_mappings, m
integer(TC) :: k
type(string_t) :: type
integer :: pdg
node_bincodes => parse_node_get_sub_ptr (node, 2)
if (associated (node_bincodes)) then
select case (char (parse_node_get_rule_key (node_bincodes)))
case ("bincodes")
n_bincodes = parse_node_get_n_sub (node_bincodes)
offset = 2
case default
n_bincodes = 0
offset = 1
end select
else
n_bincodes = 0
offset = 2
end if
allocate (bincode (n_bincodes))
do b = 1, n_bincodes
bincode(b) = parse_node_get_integer &
(parse_node_get_sub_ptr (node_bincodes, b))
end do
call phs_tree_from_array (tree, bincode)
call phs_tree_flip_t_to_s_channel (tree)
call phs_tree_canonicalize (tree)
n_mappings = parse_node_get_n_sub (node) - offset
do m = 1, n_mappings
node_mapping => parse_node_get_sub_ptr (node, m + offset)
k = parse_node_get_integer &
(parse_node_get_sub_ptr (node_mapping, 2))
type = parse_node_get_key &
(parse_node_get_sub_ptr (node_mapping, 3))
pn_pdg => parse_node_get_sub_ptr (node_mapping, 4)
select case (char (pn_pdg%get_rule_key ()))
case ("pdg")
pdg = pn_pdg%get_integer ()
case ("negative_pdg")
pdg = - parse_node_get_integer (pn_pdg%get_sub_ptr (2))
end select
call phs_tree_init_mapping (tree, k, type, pdg, model)
end do
end subroutine phs_tree_set
@ %def phs_tree_set
@
\subsection{Preparation}
The trees that we read from file do not carry flavor information.
This is set separately:
The flavor list must be unique for a unique set of masses; if a given
particle can have different flavor, the mass must be degenerate, so we
can choose one of the possible flavor combinations.
<<PHS forests: public>>=
public :: phs_forest_set_flavors
<<PHS forests: procedures>>=
subroutine phs_forest_set_flavors (forest, flv, reshuffle, flv_extra)
type(phs_forest_t), intent(inout) :: forest
type(flavor_t), dimension(:), intent(in) :: flv
integer, intent(in), dimension(:), allocatable, optional :: reshuffle
type(flavor_t), intent(in), optional :: flv_extra
integer :: i, n_flv0
if (present (reshuffle) .and. present (flv_extra)) then
n_flv0 = size (flv)
do i = 1, n_flv0
if (reshuffle(i) <= n_flv0) then
forest%flv(i) = flv (reshuffle(i))
else
forest%flv(i) = flv_extra
end if
end do
else
allocate (forest%flv (size (flv)))
forest%flv = flv
end if
end subroutine phs_forest_set_flavors
@ %def phs_forest_set_flavors
@
<<PHS forests: public>>=
public :: phs_forest_set_momentum_links
<<PHS forests: procedures>>=
subroutine phs_forest_set_momentum_links (forest, list)
type(phs_forest_t), intent(inout) :: forest
integer, intent(in), dimension(:), allocatable :: list
integer :: g, t
do g = 1, size (forest%grove)
do t = 1, size (forest%grove(g)%tree)
associate (tree => forest%grove(g)%tree(t))
call phs_tree_set_momentum_links (tree, list)
!!! call phs_tree_reshuffle_mappings (tree)
end associate
end do
end do
end subroutine phs_forest_set_momentum_links
@ %def phs_forest_set_momentum_links
@ Once the parameter set is fixed, the masses and the widths of the
particles are known and the [[mass_sum]] arrays as well as the mapping
parameters can be computed. Note that order is important: we first
compute the mass sums, then the ordinary mappings. The resonances
obtained here determine the effective masses, which in turn are used
to implement step mappings for resonance decay products that are not
mapped otherwise.
<<PHS forests: public>>=
public :: phs_forest_set_parameters
<<PHS forests: procedures>>=
subroutine phs_forest_set_parameters &
(forest, mapping_defaults, variable_limits)
type(phs_forest_t), intent(inout) :: forest
type(mapping_defaults_t), intent(in) :: mapping_defaults
logical, intent(in) :: variable_limits
integer :: g, t
do g = 1, size (forest%grove)
do t = 1, size (forest%grove(g)%tree)
call phs_tree_set_mass_sum &
(forest%grove(g)%tree(t), forest%flv(forest%n_in+1:))
call phs_tree_set_mapping_parameters (forest%grove(g)%tree(t), &
mapping_defaults, variable_limits)
call phs_tree_set_effective_masses (forest%grove(g)%tree(t))
if (mapping_defaults%step_mapping) then
call phs_tree_set_step_mappings (forest%grove(g)%tree(t), &
mapping_defaults%step_mapping_exp, variable_limits)
end if
end do
end do
end subroutine phs_forest_set_parameters
@ %def phs_forest_set_parameters
@ Generate the particle combination table. Scan all trees and merge
their individual combination tables. At the end, valid entries are
non-zero, and they indicate the indices of a pair of particles to be
combined to a new particle. If a particle is accessible by more than
one tree (this is usual), only keep the first possibility.
<<PHS forests: public>>=
public :: phs_forest_setup_prt_combinations
<<PHS forests: procedures>>=
subroutine phs_forest_setup_prt_combinations (forest)
type(phs_forest_t), intent(inout) :: forest
integer :: g, t
integer, dimension(:,:), allocatable :: tree_prt_combination
forest%prt_combination = 0
allocate (tree_prt_combination (2, size (forest%prt_combination, 2)))
do g = 1, size (forest%grove)
do t = 1, size (forest%grove(g)%tree)
call phs_tree_setup_prt_combinations &
(forest%grove(g)%tree(t), tree_prt_combination)
where (tree_prt_combination /= 0 .and. forest%prt_combination == 0)
forest%prt_combination = tree_prt_combination
end where
end do
end do
end subroutine phs_forest_setup_prt_combinations
@ %def phs_forest_setup_prt_combinations
@
\subsection{Accessing the particle arrays}
Set the incoming particles from the contents of an interaction.
<<PHS forests: public>>=
public :: phs_forest_set_prt_in
<<PHS forests: interfaces>>=
interface phs_forest_set_prt_in
module procedure phs_forest_set_prt_in_int, phs_forest_set_prt_in_mom
end interface phs_forest_set_prt_in
<<PHS forests: procedures>>=
subroutine phs_forest_set_prt_in_int (forest, int, lt_cm_to_lab)
type(phs_forest_t), intent(inout) :: forest
type(interaction_t), intent(in) :: int
type(lorentz_transformation_t), intent(in), optional :: lt_cm_to_lab
if (present (lt_cm_to_lab)) then
call phs_prt_set_momentum (forest%prt_in, &
inverse (lt_cm_to_lab) * &
int%get_momenta (outgoing=.false.))
else
call phs_prt_set_momentum (forest%prt_in, &
int%get_momenta (outgoing=.false.))
end if
associate (m_in => forest%flv(:forest%n_in)%get_mass ())
call phs_prt_set_msq (forest%prt_in, m_in ** 2)
end associate
call phs_prt_set_defined (forest%prt_in)
end subroutine phs_forest_set_prt_in_int
subroutine phs_forest_set_prt_in_mom (forest, mom, lt_cm_to_lab)
type(phs_forest_t), intent(inout) :: forest
type(vector4_t), dimension(size (forest%prt_in)), intent(in) :: mom
type(lorentz_transformation_t), intent(in), optional :: lt_cm_to_lab
if (present (lt_cm_to_lab)) then
call phs_prt_set_momentum (forest%prt_in, &
inverse (lt_cm_to_lab) * mom)
else
call phs_prt_set_momentum (forest%prt_in, mom)
end if
associate (m_in => forest%flv(:forest%n_in)%get_mass ())
call phs_prt_set_msq (forest%prt_in, m_in ** 2)
end associate
call phs_prt_set_defined (forest%prt_in)
end subroutine phs_forest_set_prt_in_mom
@ %def phs_forest_set_prt_in
@ Set the outgoing particles from the contents of an interaction.
<<PHS forests: public>>=
public :: phs_forest_set_prt_out
<<PHS forests: interfaces>>=
interface phs_forest_set_prt_out
module procedure phs_forest_set_prt_out_int, phs_forest_set_prt_out_mom
end interface phs_forest_set_prt_out
<<PHS forests: procedures>>=
subroutine phs_forest_set_prt_out_int (forest, int, lt_cm_to_lab)
type(phs_forest_t), intent(inout) :: forest
type(interaction_t), intent(in) :: int
type(lorentz_transformation_t), intent(in), optional :: lt_cm_to_lab
if (present (lt_cm_to_lab)) then
call phs_prt_set_momentum (forest%prt_out, &
inverse (lt_cm_to_lab) * &
int%get_momenta (outgoing=.true.))
else
call phs_prt_set_momentum (forest%prt_out, &
int%get_momenta (outgoing=.true.))
end if
associate (m_out => forest%flv(forest%n_in+1:)%get_mass ())
call phs_prt_set_msq (forest%prt_out, m_out ** 2)
end associate
call phs_prt_set_defined (forest%prt_out)
end subroutine phs_forest_set_prt_out_int
subroutine phs_forest_set_prt_out_mom (forest, mom, lt_cm_to_lab)
type(phs_forest_t), intent(inout) :: forest
type(vector4_t), dimension(size (forest%prt_out)), intent(in) :: mom
type(lorentz_transformation_t), intent(in), optional :: lt_cm_to_lab
if (present (lt_cm_to_lab)) then
call phs_prt_set_momentum (forest%prt_out, &
inverse (lt_cm_to_lab) * mom)
else
call phs_prt_set_momentum (forest%prt_out, mom)
end if
associate (m_out => forest%flv(forest%n_in+1:)%get_mass ())
call phs_prt_set_msq (forest%prt_out, m_out ** 2)
end associate
call phs_prt_set_defined (forest%prt_out)
end subroutine phs_forest_set_prt_out_mom
@ %def phs_forest_set_prt_out
@ Combine particles as described by the particle combination table.
Particle momentum sums will be calculated only if the resulting
particle is contained in at least one of the trees in the current
forest. The others are kept undefined.
<<PHS forests: public>>=
public :: phs_forest_combine_particles
<<PHS forests: procedures>>=
subroutine phs_forest_combine_particles (forest)
type(phs_forest_t), intent(inout) :: forest
integer :: k
integer, dimension(2) :: kk
do k = 1, size (forest%prt_combination, 2)
kk = forest%prt_combination(:,k)
if (kk(1) /= 0) then
call phs_prt_combine (forest%prt(k), &
forest%prt(kk(1)), forest%prt(kk(2)))
end if
end do
end subroutine phs_forest_combine_particles
@ %def phs_forest_combine_particles
@ Extract the outgoing particles and insert into an interaction.
<<PHS forests: public>>=
public :: phs_forest_get_prt_out
<<PHS forests: procedures>>=
subroutine phs_forest_get_prt_out (forest, int, lt_cm_to_lab)
type(phs_forest_t), intent(in) :: forest
type(interaction_t), intent(inout) :: int
type(lorentz_transformation_t), intent(in), optional :: lt_cm_to_lab
if (present (lt_cm_to_lab)) then
call int%set_momenta (lt_cm_to_lab * &
phs_prt_get_momentum (forest%prt_out), outgoing=.true.)
else
call int%set_momenta (phs_prt_get_momentum (forest%prt_out), &
outgoing=.true.)
end if
end subroutine phs_forest_get_prt_out
@ %def phs_forest_get_prt_out
@ Extract the outgoing particle momenta
<<PHS forests: public>>=
public :: phs_forest_get_momenta_out
<<PHS forests: procedures>>=
function phs_forest_get_momenta_out (forest, lt_cm_to_lab) result (p)
type(phs_forest_t), intent(in) :: forest
type(lorentz_transformation_t), intent(in), optional :: lt_cm_to_lab
type(vector4_t), dimension(size (forest%prt_out)) :: p
p = phs_prt_get_momentum (forest%prt_out)
if (present (lt_cm_to_lab)) p = p * lt_cm_to_lab
end function phs_forest_get_momenta_out
@ %def phs_forest_get_momenta_out
@
\subsection{Find equivalences among phase-space trees}
Scan phase space for equivalences. We generate the complete set of
unique permutations for the given list of outgoing particles, and use
this for scanning equivalences within each grove.
@ We scan all pairs of trees, using all permutations. This implies
that trivial equivalences are included, and equivalences between
different trees are recorded twice. This is intentional.
<<PHS forests: procedures>>=
subroutine phs_grove_set_equivalences (grove, perm_array)
type(phs_grove_t), intent(inout) :: grove
type(permutation_t), dimension(:), intent(in) :: perm_array
type(equivalence_t), pointer :: eq
integer :: t1, t2, i
do t1 = 1, size (grove%tree)
do t2 = 1, size (grove%tree)
SCAN_PERM: do i = 1, size (perm_array)
if (phs_tree_equivalent &
(grove%tree(t1), grove%tree(t2), perm_array(i))) then
call equivalence_list_add &
(grove%equivalence_list, t1, t2, perm_array(i))
eq => grove%equivalence_list%last
call phs_tree_find_msq_permutation &
(grove%tree(t1), grove%tree(t2), eq%perm, &
eq%msq_perm)
call phs_tree_find_angle_permutation &
(grove%tree(t1), grove%tree(t2), eq%perm, &
eq%angle_perm, eq%angle_sig)
end if
end do SCAN_PERM
end do
end do
end subroutine phs_grove_set_equivalences
@ %def phs_grove_set_equivalences
<<PHS forests: public>>=
public :: phs_forest_set_equivalences
<<PHS forests: procedures>>=
subroutine phs_forest_set_equivalences (forest)
type(phs_forest_t), intent(inout) :: forest
type(permutation_t), dimension(:), allocatable :: perm_array
integer :: i
call permutation_array_make &
(perm_array, forest%flv(forest%n_in+1:)%get_pdg ())
do i = 1, size (forest%grove)
call phs_grove_set_equivalences (forest%grove(i), perm_array)
end do
forest%n_equivalences = sum (forest%grove%equivalence_list%length)
end subroutine phs_forest_set_equivalences
@ %def phs_forest_set_equivalences
@
\subsection{Interface for channel equivalences}
Here, we store the equivalence list in the appropriate containers that
the [[phs_base]] module provides. There is one separate list for each
channel.
<<PHS forests: public>>=
public :: phs_forest_get_equivalences
<<PHS forests: procedures>>=
subroutine phs_forest_get_equivalences (forest, channel, azimuthal_dependence)
type(phs_forest_t), intent(in) :: forest
type(phs_channel_t), dimension(:), intent(out) :: channel
logical, intent(in) :: azimuthal_dependence
integer :: n_masses, n_angles
integer :: mode_azimuthal_angle
integer, dimension(:), allocatable :: n_eq
type(equivalence_t), pointer :: eq
integer, dimension(:), allocatable :: perm, mode
integer :: g, c, j, left, right
n_masses = forest%n_masses
n_angles = forest%n_angles
allocate (n_eq (forest%n_trees), source = 0)
allocate (perm (forest%n_dimensions))
allocate (mode (forest%n_dimensions), source = EQ_IDENTITY)
do g = 1, size (forest%grove)
eq => forest%grove(g)%equivalence_list%first
do while (associated (eq))
left = eq%left + forest%grove(g)%tree_count_offset
n_eq(left) = n_eq(left) + 1
eq => eq%next
end do
end do
do c = 1, size (channel)
allocate (channel(c)%eq (n_eq(c)))
do j = 1, n_eq(c)
call channel(c)%eq(j)%init (forest%n_dimensions)
end do
end do
n_eq = 0
if (azimuthal_dependence) then
mode_azimuthal_angle = EQ_IDENTITY
else
mode_azimuthal_angle = EQ_INVARIANT
end if
do g = 1, size (forest%grove)
eq => forest%grove(g)%equivalence_list%first
do while (associated (eq))
left = eq%left + forest%grove(g)%tree_count_offset
right = eq%right + forest%grove(g)%tree_count_offset
do j = 1, n_masses
perm(j) = permute (j, eq%msq_perm)
mode(j) = EQ_IDENTITY
end do
do j = 1, n_angles
perm(n_masses+j) = n_masses + permute (j, eq%angle_perm)
if (j == 1) then
mode(n_masses+j) = mode_azimuthal_angle ! first az. angle
else if (mod(j,2) == 1) then
mode(n_masses+j) = EQ_SYMMETRIC ! other az. angles
else if (eq%angle_sig(j)) then
mode(n_masses+j) = EQ_IDENTITY ! polar angle +
else
mode(n_masses+j) = EQ_INVERT ! polar angle -
end if
end do
n_eq(left) = n_eq(left) + 1
associate (eq_cur => channel(left)%eq(n_eq(left)))
eq_cur%c = right
eq_cur%perm = perm
eq_cur%mode = mode
end associate
eq => eq%next
end do
end do
end subroutine phs_forest_get_equivalences
@ %def phs_forest_get_equivalences
@
\subsection{Phase-space evaluation}
Given one row of the [[x]] parameter array and the corresponding
channel index, compute first all relevant momenta and then recover the
remainder of the [[x]] array, the Jacobians [[phs_factor]], and the
phase-space [[volume]].
The output argument [[ok]] indicates whether this was successful.
<<PHS forests: public>>=
public :: phs_forest_evaluate_selected_channel
<<PHS forests: procedures>>=
subroutine phs_forest_evaluate_selected_channel &
(forest, channel, active, sqrts, x, phs_factor, volume, ok)
type(phs_forest_t), intent(inout) :: forest
integer, intent(in) :: channel
logical, dimension(:), intent(in) :: active
real(default), intent(in) :: sqrts
real(default), dimension(:,:), intent(inout) :: x
real(default), dimension(:), intent(out) :: phs_factor
real(default), intent(out) :: volume
logical, intent(out) :: ok
integer :: g, t
integer(TC) :: k, k_root, k_in
g = forest%grove_lookup (channel)
t = channel - forest%grove(g)%tree_count_offset
call phs_prt_set_undefined (forest%prt)
call phs_prt_set_undefined (forest%prt_out)
k_in = forest%n_tot
do k = 1,forest%n_in
forest%prt(ibset(0,k_in-k)) = forest%prt_in(k)
end do
do k = 1, forest%n_out
call phs_prt_set_msq (forest%prt(ibset(0,k-1)), &
forest%flv(forest%n_in+k)%get_mass () ** 2)
end do
k_root = 2**forest%n_out - 1
select case (forest%n_in)
case (1)
forest%prt(k_root) = forest%prt_in(1)
case (2)
call phs_prt_combine &
(forest%prt(k_root), forest%prt_in(1), forest%prt_in(2))
end select
call phs_tree_compute_momenta_from_x (forest%grove(g)%tree(t), &
forest%prt, phs_factor(channel), volume, sqrts, x(:,channel), ok)
if (ok) then
do k = 1, forest%n_out
forest%prt_out(k) = forest%prt(ibset(0,k-1))
end do
end if
end subroutine phs_forest_evaluate_selected_channel
@ %def phs_forest_evaluate_selected_channel
@ The remainder: recover $x$ values for all channels except for the current
channel.
NOTE: OpenMP not used for the first loop. [[combine_particles]] is not a
channel-local operation.
<<PHS forests: public>>=
public :: phs_forest_evaluate_other_channels
<<PHS forests: procedures>>=
subroutine phs_forest_evaluate_other_channels &
(forest, channel, active, sqrts, x, phs_factor, combine)
type(phs_forest_t), intent(inout) :: forest
integer, intent(in) :: channel
logical, dimension(:), intent(in) :: active
real(default), intent(in) :: sqrts
real(default), dimension(:,:), intent(inout) :: x
real(default), dimension(:), intent(inout) :: phs_factor
logical, intent(in) :: combine
integer :: g, t, ch, n_channel
g = forest%grove_lookup (channel)
t = channel - forest%grove(g)%tree_count_offset
n_channel = forest%n_trees
if (combine) then
do ch = 1, n_channel
if (ch == channel) cycle
if (active(ch)) then
g = forest%grove_lookup(ch)
t = ch - forest%grove(g)%tree_count_offset
call phs_tree_combine_particles &
(forest%grove(g)%tree(t), forest%prt)
end if
end do
end if
!OMP PARALLEL PRIVATE (g,t,ch) SHARED(active,forest,sqrts,x,channel)
!OMP DO SCHEDULE(STATIC)
do ch = 1, n_channel
if (ch == channel) cycle
if (active(ch)) then
g = forest%grove_lookup(ch)
t = ch - forest%grove(g)%tree_count_offset
call phs_tree_compute_x_from_momenta &
(forest%grove(g)%tree(t), &
forest%prt, phs_factor(ch), sqrts, x(:,ch))
end if
end do
!OMP END DO
!OMP END PARALLEL
end subroutine phs_forest_evaluate_other_channels
@ %def phs_forest_evaluate_other_channels
@ The complement: recover one row of the [[x]] array and the
associated Jacobian entry, corresponding to
[[channel]], from incoming and outgoing momenta. Also compute the
phase-space volume.
<<PHS forests: public>>=
public :: phs_forest_recover_channel
<<PHS forests: procedures>>=
subroutine phs_forest_recover_channel &
(forest, channel, sqrts, x, phs_factor, volume)
type(phs_forest_t), intent(inout) :: forest
integer, intent(in) :: channel
real(default), intent(in) :: sqrts
real(default), dimension(:,:), intent(inout) :: x
real(default), dimension(:), intent(inout) :: phs_factor
real(default), intent(out) :: volume
integer :: g, t
integer(TC) :: k, k_in
g = forest%grove_lookup (channel)
t = channel - forest%grove(g)%tree_count_offset
call phs_prt_set_undefined (forest%prt)
k_in = forest%n_tot
forall (k = 1:forest%n_in)
forest%prt(ibset(0,k_in-k)) = forest%prt_in(k)
end forall
forall (k = 1:forest%n_out)
forest%prt(ibset(0,k-1)) = forest%prt_out(k)
end forall
call phs_forest_combine_particles (forest)
call phs_tree_compute_volume &
(forest%grove(g)%tree(t), sqrts, volume)
call phs_tree_compute_x_from_momenta &
(forest%grove(g)%tree(t), &
forest%prt, phs_factor(channel), sqrts, x(:,channel))
end subroutine phs_forest_recover_channel
@ %def phs_forest_recover_channel
@
\subsection{Unit tests}
Test module, followed by the corresponding implementation module.
<<[[phs_forests_ut.f90]]>>=
<<File header>>
module phs_forests_ut
use unit_tests
use phs_forests_uti
<<Standard module head>>
<<PHS forests: public test>>
contains
<<PHS forests: test driver>>
end module phs_forests_ut
@ %def phs_forests_ut
@
<<[[phs_forests_uti.f90]]>>=
<<File header>>
module phs_forests_uti
<<Use kinds>>
<<Use strings>>
use io_units
use format_defs, only: FMT_12
use lorentz
use flavors
use interactions
use model_data
use mappings
use phs_base
use resonances, only: resonance_history_set_t
use phs_forests
<<Standard module head>>
<<PHS forests: test declarations>>
contains
<<PHS forests: tests>>
end module phs_forests_uti
@ %def phs_forests_ut
@ API: driver for the unit tests below.
<<PHS forests: public test>>=
public :: phs_forests_test
<<PHS forests: test driver>>=
subroutine phs_forests_test (u, results)
integer, intent(in) :: u
type(test_results_t), intent(inout) :: results
<<PHS forests: execute tests>>
end subroutine phs_forests_test
@ %def phs_forests_test
@
\subsubsection{Basic universal test}
Write a possible phase-space file for a $2\to 3$ process and make the
corresponding forest, print the forest. Choose some in-particle
momenta and a random-number array and evaluate out-particles and
phase-space factors.
<<PHS forests: execute tests>>=
call test (phs_forest_1, "phs_forest_1", &
"check phs forest setup", &
u, results)
<<PHS forests: test declarations>>=
public :: phs_forest_1
<<PHS forests: tests>>=
subroutine phs_forest_1 (u)
use os_interface
integer, intent(in) :: u
type(phs_forest_t) :: forest
type(phs_channel_t), dimension(:), allocatable :: channel
type(model_data_t), target :: model
type(string_t) :: process_id
type(flavor_t), dimension(5) :: flv
type(string_t) :: filename
type(interaction_t) :: int
integer :: unit_fix
type(mapping_defaults_t) :: mapping_defaults
logical :: found_process, ok
integer :: n_channel, ch, i
logical, dimension(4) :: active = .true.
real(default) :: sqrts = 1000
real(default), dimension(5,4) :: x
real(default), dimension(4) :: factor
real(default) :: volume
write (u, "(A)") "* Test output: PHS forest"
write (u, "(A)") "* Purpose: test PHS forest routines"
write (u, "(A)")
write (u, "(A)") "* Reading model file"
call model%init_sm_test ()
write (u, "(A)")
write (u, "(A)") "* Create phase-space file 'phs_forest_test.phs'"
write (u, "(A)")
call flv%init ([11, -11, 11, -11, 22], model)
unit_fix = free_unit ()
open (file="phs_forest_test.phs", unit=unit_fix, action="write")
write (unit_fix, *) "process foo"
write (unit_fix, *) 'md5sum_process = "6ABA33BC2927925D0F073B1C1170780A"'
write (unit_fix, *) 'md5sum_model_par = "1A0B151EE6E2DEB92D880320355A3EAB"'
write (unit_fix, *) 'md5sum_phs_config = "B6A8877058809A8BDD54753CDAB83ACE"'
write (unit_fix, *) "sqrts = 100.00000000000000"
write (unit_fix, *) "m_threshold_s = 50.000000000000000"
write (unit_fix, *) "m_threshold_t = 100.00000000000000"
write (unit_fix, *) "off_shell = 2"
write (unit_fix, *) "t_channel = 6"
write (unit_fix, *) "keep_nonresonant = F"
write (unit_fix, *) ""
write (unit_fix, *) " grove"
write (unit_fix, *) " tree 3 7"
write (unit_fix, *) " map 3 s_channel 23"
write (unit_fix, *) " tree 5 7"
write (unit_fix, *) " tree 6 7"
write (unit_fix, *) " grove"
write (unit_fix, *) " tree 9 11"
write (unit_fix, *) " map 9 t_channel 22"
close (unit_fix)
write (u, "(A)")
write (u, "(A)") "* Read phase-space file 'phs_forest_test.phs'"
call syntax_phs_forest_init ()
process_id = "foo"
filename = "phs_forest_test.phs"
call phs_forest_read &
(forest, filename, process_id, 2, 3, model, found_process)
write (u, "(A)")
write (u, "(A)") "* Set parameters, flavors, equiv, momenta"
write (u, "(A)")
call phs_forest_set_flavors (forest, flv)
call phs_forest_set_parameters (forest, mapping_defaults, .false.)
call phs_forest_setup_prt_combinations (forest)
call phs_forest_set_equivalences (forest)
call int%basic_init (2, 0, 3)
call int%set_momentum &
(vector4_moving (500._default, 500._default, 3), 1)
call int%set_momentum &
(vector4_moving (500._default,-500._default, 3), 2)
call phs_forest_set_prt_in (forest, int)
n_channel = 2
x = 0
x(:,n_channel) = [0.3, 0.4, 0.1, 0.9, 0.6]
write (u, "(A)") " Input values:"
write (u, "(3x,5(1x," // FMT_12 // "))") x(:,n_channel)
write (u, "(A)")
write (u, "(A)") "* Evaluating phase space"
call phs_forest_evaluate_selected_channel (forest, &
n_channel, active, sqrts, x, factor, volume, ok)
call phs_forest_evaluate_other_channels (forest, &
n_channel, active, sqrts, x, factor, combine=.true.)
call phs_forest_get_prt_out (forest, int)
write (u, "(A)") " Output values:"
do ch = 1, 4
write (u, "(3x,5(1x," // FMT_12 // "))") x(:,ch)
end do
call int%basic_write (u)
write (u, "(A)") " Factors:"
write (u, "(3x,5(1x," // FMT_12 // "))") factor
write (u, "(A)") " Volume:"
write (u, "(3x,5(1x," // FMT_12 // "))") volume
call phs_forest_write (forest, u)
write (u, "(A)")
write (u, "(A)") "* Compute equivalences"
n_channel = 4
allocate (channel (n_channel))
call phs_forest_get_equivalences (forest, &
channel, .true.)
do i = 1, n_channel
write (u, "(1x,I0,':')", advance = "no") ch
call channel(i)%write (u)
end do
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call model%final ()
call phs_forest_final (forest)
call syntax_phs_forest_final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: phs_forest_1"
end subroutine phs_forest_1
@ %def phs_forest_1
@
\subsubsection{Resonance histories}
Read a suitably nontrivial forest from file and recover the set of
resonance histories.
<<PHS forests: execute tests>>=
call test (phs_forest_2, "phs_forest_2", &
"handle phs forest resonance content", &
u, results)
<<PHS forests: test declarations>>=
public :: phs_forest_2
<<PHS forests: tests>>=
subroutine phs_forest_2 (u)
use os_interface
integer, intent(in) :: u
integer :: unit_fix
type(phs_forest_t) :: forest
type(model_data_t), target :: model
type(string_t) :: process_id
type(string_t) :: filename
logical :: found_process
type(resonance_history_set_t) :: res_set
integer :: i
write (u, "(A)") "* Test output: phs_forest_2"
write (u, "(A)") "* Purpose: test PHS forest routines"
write (u, "(A)")
write (u, "(A)") "* Reading model file"
call model%init_sm_test ()
write (u, "(A)")
write (u, "(A)") "* Create phase-space file 'phs_forest_2.phs'"
write (u, "(A)")
unit_fix = free_unit ()
open (file="phs_forest_2.phs", unit=unit_fix, action="write")
write (unit_fix, *) "process foo"
write (unit_fix, *) 'md5sum_process = "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"'
write (unit_fix, *) 'md5sum_model_par = "1A0B151EE6E2DEB92D880320355A3EAB"'
write (unit_fix, *) 'md5sum_phs_config = "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"'
write (unit_fix, *) "sqrts = 100.00000000000000"
write (unit_fix, *) "m_threshold_s = 50.000000000000000"
write (unit_fix, *) "m_threshold_t = 100.00000000000000"
write (unit_fix, *) "off_shell = 2"
write (unit_fix, *) "t_channel = 6"
write (unit_fix, *) "keep_nonresonant = F"
write (unit_fix, *) ""
write (unit_fix, *) " grove"
write (unit_fix, *) " tree 3 7"
write (unit_fix, *) " tree 3 7"
write (unit_fix, *) " map 3 s_channel -24"
write (unit_fix, *) " tree 5 7"
write (unit_fix, *) " tree 3 7"
write (unit_fix, *) " map 3 s_channel -24"
write (unit_fix, *) " map 7 s_channel 23"
write (unit_fix, *) " tree 5 7"
write (unit_fix, *) " map 7 s_channel 25"
write (unit_fix, *) " tree 3 11"
write (unit_fix, *) " map 3 s_channel -24"
close (unit_fix)
write (u, "(A)") "* Read phase-space file 'phs_forest_2.phs'"
call syntax_phs_forest_init ()
process_id = "foo"
filename = "phs_forest_2.phs"
call phs_forest_read &
(forest, filename, process_id, 2, 3, model, found_process)
write (u, "(A)")
write (u, "(A)") "* Extract resonance history set"
write (u, "(A)")
call forest%extract_resonance_history_set (res_set)
call res_set%write (u)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call model%final ()
call phs_forest_final (forest)
call syntax_phs_forest_final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: phs_forest_2"
end subroutine phs_forest_2
@ %def phs_forest_2
@
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{Finding phase space parameterizations}
If the phase space configuration is not found in the appropriate file,
we should generate one.
The idea is to construct all Feynman diagrams subject to certain
constraints which eliminate everything that is probably irrelevant for
the integration. These Feynman diagrams (cascades) are grouped in
groves by finding equivalence classes related by symmetry and ordered
with respect to their importance (resonances). Finally, the result
(or part of it) is written to file and used for the integration.
This module may eventually disappear and be replaced by CAML code.
In particular, we need here a set of Feynman rules (vertices with
particle codes, but not the factors). Thus, the module works for the
Standard Model only.
Note that this module is stand-alone, it communicates to the main
program only via the generated ASCII phase-space configuration file.
<<[[cascades.f90]]>>=
<<File header>>
module cascades
<<Use kinds>>
use kinds, only: TC, i8, i32
<<Use strings>>
<<Use debug>>
use io_units
use constants, only: one
use format_defs, only: FMT_12, FMT_19
use numeric_utils
use diagnostics
use hashes
use sorting
use physics_defs, only: SCALAR, SPINOR, VECTOR, VECTORSPINOR, TENSOR
use physics_defs, only: UNDEFINED
use model_data
use flavors
use lorentz
use resonances, only: resonance_info_t
use resonances, only: resonance_history_t
use resonances, only: resonance_history_set_t
use phs_forests
<<Standard module head>>
<<Cascades: public>>
<<Cascades: parameters>>
<<Cascades: types>>
<<Cascades: interfaces>>
contains
<<Cascades: procedures>>
end module cascades
@ %def cascades
@
\subsection{The mapping modes}
The valid mapping modes, to be used below. We will make use of the convention
that mappings of internal particles have a positive value. Only for positive
values, the flavor code is propagated when combining cascades.
<<Mapping modes>>=
integer, parameter :: &
& EXTERNAL_PRT = -1, &
& NO_MAPPING = 0, S_CHANNEL = 1, T_CHANNEL = 2, U_CHANNEL = 3, &
& RADIATION = 4, COLLINEAR = 5, INFRARED = 6, &
& STEP_MAPPING_E = 11, STEP_MAPPING_H = 12, &
& ON_SHELL = 99
@ %def EXTERNAL_PRT
@ %def NO_MAPPING S_CHANNEL T_CHANNEL U_CHANNEL
@ %def RADIATION COLLINEAR INFRARED
@ %def STEP_MAPPING_E STEP_MAPPING_H
@ %def ON_SHELL
<<Cascades: parameters>>=
<<Mapping modes>>
@
\subsection{The cascade type}
A cascade is essentially the same as a decay tree (both definitions
may be merged in a later version). It contains a linked tree of
nodes, each of which representing an internal particle. In contrast
to decay trees, each node has a definite particle code. These nodes
need not be modified, therefore we can use pointers and do not have to
copy them. Thus, physically each cascades has only a single node, the
mother particle. However, to be able to compare trees quickly, we
store in addition an array of binary codes which is always sorted in
ascending order. This is accompanied by a corresponding list of
particle codes. The index is the location of the corresponding
cascade in the cascade set, this may be used to access the daughters
directly.
The real mass is the particle mass belonging to the particle code.
The minimal mass is the sum of the real masses of all its daughters;
this is the kinematical cutoff. The effective mass may be zero if the
particle mass is below a certain threshold; it may be the real mass if
the particle is resonant; or it may be some other value.
The logical [[t_channel]] is set if this a $t$-channel line, while
[[initial]] is true only for an initial particle. Note that both
initial particles are also [[t_channel]] by definition, and that they
are distinguished by the direction of the tree: One of them decays
and is the root of the tree, while the other one is one of the leaves.
The cascade is a list of nodes (particles) which are linked via the
[[daughter]] entries. The node is the mother particle of
the decay cascade. Much of the information in the nodes is repeated
in arrays, to be accessible more easily. The arrays will be kept
sorted by binary codes.
The counter [[n_off_shell]] is increased for each internal line that
is neither resonant nor log-enhanced. It is set to zero if the
current line is resonant, since this implies on-shell particle production
and subsequent decay.
The counter [[n_t_channel]] is non-negative once an initial particle
is included in the tree: then, it counts the number of $t$-channel lines.
The [[multiplicity]] is the number of branchings to follow until all
daughters are on-shell. A resonant or non-decaying particle has
multiplicity one. Merging nodes, the multiplicities add unless the
mother is a resonance. An initial or final node has multiplicity
zero.
The arrays correspond to the subnode tree [[tree]] of the current
cascade. PDG codes are stored only for those positions which are
resonant, with the exception of the last entry, i.e., the current node.
Other positions, in particular external legs, are assigned undefined
PDG code.
A cascade is uniquely identified by its tree, the tree of PDG codes,
and the tree of mappings. The tree of resonances is kept only to mask
the PDG tree as described above.
<<Cascades: types>>=
type :: cascade_t
private
! counters
integer :: index = 0
integer :: grove = 0
! status
logical :: active = .false.
logical :: complete = .false.
logical :: incoming = .false.
! this node
integer(TC) :: bincode = 0
type(flavor_t) :: flv
integer :: pdg = UNDEFINED
logical :: is_vector = .false.
real(default) :: m_min = 0
real(default) :: m_rea = 0
real(default) :: m_eff = 0
integer :: mapping = NO_MAPPING
logical :: on_shell = .false.
logical :: resonant = .false.
logical :: log_enhanced = .false.
logical :: t_channel = .false.
! global tree properties
integer :: multiplicity = 0
integer :: internal = 0
integer :: n_off_shell = 0
integer :: n_resonances = 0
integer :: n_log_enhanced = 0
integer :: n_t_channel = 0
integer :: res_hash = 0
! the sub-node tree
integer :: depth = 0
integer(TC), dimension(:), allocatable :: tree
integer, dimension(:), allocatable :: tree_pdg
integer, dimension(:), allocatable :: tree_mapping
logical, dimension(:), allocatable :: tree_resonant
! branch connections
logical :: has_children = .false.
type(cascade_t), pointer :: daughter1 => null ()
type(cascade_t), pointer :: daughter2 => null ()
type(cascade_t), pointer :: mother => null ()
! next in list
type(cascade_t), pointer :: next => null ()
contains
<<Cascades: cascade: TBP>>
end type cascade_t
@ %def cascade_t
<<Cascades: procedures>>=
subroutine cascade_init (cascade, depth)
type(cascade_t), intent(out) :: cascade
integer, intent(in) :: depth
integer, save :: index = 0
index = cascade_index ()
cascade%index = index
cascade%depth = depth
cascade%active = .true.
allocate (cascade%tree (depth))
allocate (cascade%tree_pdg (depth))
allocate (cascade%tree_mapping (depth))
allocate (cascade%tree_resonant (depth))
end subroutine cascade_init
@ %def cascade_init
@ Keep and increment a global index
<<Cascades: procedures>>=
function cascade_index (seed) result (index)
integer :: index
integer, intent(in), optional :: seed
integer, save :: i = 0
if (present (seed)) i = seed
i = i + 1
index = i
end function cascade_index
@ %def cascade_index
@ We need three versions of writing cascades. This goes to the
phase-space file.
For t/u channel mappings, we use the absolute value of the PDG code.
<<Cascades: procedures>>=
subroutine cascade_write_file_format (cascade, model, unit)
type(cascade_t), intent(in) :: cascade
class(model_data_t), intent(in), target :: model
integer, intent(in), optional :: unit
type(flavor_t) :: flv
integer :: u, i
2 format(3x,A,1x,I3,1x,A,1x,I9,1x,'!',1x,A)
u = given_output_unit (unit); if (u < 0) return
call write_reduced (cascade%tree, u)
write (u, "(A)")
do i = 1, cascade%depth
call flv%init (cascade%tree_pdg(i), model)
select case (cascade%tree_mapping(i))
case (NO_MAPPING, EXTERNAL_PRT)
case (S_CHANNEL)
write(u,2) 'map', &
cascade%tree(i), 's_channel', cascade%tree_pdg(i), &
char (flv%get_name ())
case (T_CHANNEL)
write(u,2) 'map', &
cascade%tree(i), 't_channel', abs (cascade%tree_pdg(i)), &
char (flv%get_name ())
case (U_CHANNEL)
write(u,2) 'map', &
cascade%tree(i), 'u_channel', abs (cascade%tree_pdg(i)), &
char (flv%get_name ())
case (RADIATION)
write(u,2) 'map', &
cascade%tree(i), 'radiation', cascade%tree_pdg(i), &
char (flv%get_name ())
case (COLLINEAR)
write(u,2) 'map', &
cascade%tree(i), 'collinear', cascade%tree_pdg(i), &
char (flv%get_name ())
case (INFRARED)
write(u,2) 'map', &
cascade%tree(i), 'infrared ', cascade%tree_pdg(i), &
char (flv%get_name ())
case (ON_SHELL)
write(u,2) 'map', &
cascade%tree(i), 'on_shell ', cascade%tree_pdg(i), &
char (flv%get_name ())
case default
call msg_bug (" Impossible mapping mode encountered")
end select
end do
contains
subroutine write_reduced (array, unit)
integer(TC), dimension(:), intent(in) :: array
integer, intent(in) :: unit
integer :: i
write (u, "(3x,A,1x)", advance="no") "tree"
do i = 1, size (array)
if (decay_level (array(i)) > 1) then
write (u, "(1x,I0)", advance="no") array(i)
end if
end do
end subroutine write_reduced
elemental function decay_level (k) result (l)
integer(TC), intent(in) :: k
integer :: l
integer :: i
l = 0
do i = 0, bit_size(k) - 1
if (btest(k,i)) l = l + 1
end do
end function decay_level
subroutine start_comment (u)
integer, intent(in) :: u
write(u, '(1x,A)', advance='no') '!'
end subroutine start_comment
end subroutine cascade_write_file_format
@ %def cascade_write_file_format
@ This creates metapost source for graphical display:
<<Cascades: procedures>>=
subroutine cascade_write_graph_format (cascade, count, unit)
type(cascade_t), intent(in) :: cascade
integer, intent(in) :: count
integer, intent(in), optional :: unit
integer :: u
integer(TC) :: mask
type(string_t) :: left_str, right_str
u = given_output_unit (unit); if (u < 0) return
mask = 2**((cascade%depth+3)/2) - 1
left_str = ""
right_str = ""
write (u, '(A)') "\begin{minipage}{105pt}"
write (u, '(A)') "\vspace{30pt}"
write (u, '(A)') "\begin{center}"
write (u, '(A)') "\begin{fmfgraph*}(55,55)"
call graph_write (cascade, mask)
write (u, '(A)') "\fmfleft{" // char (extract (left_str, 2)) // "}"
write (u, '(A)') "\fmfright{" // char (extract (right_str, 2)) // "}"
write (u, '(A)') "\end{fmfgraph*}\\"
write (u, '(A,I5,A)') "\fbox{$", count, "$}"
write (u, '(A)') "\end{center}"
write (u, '(A)') "\end{minipage}"
write (u, '(A)') "%"
contains
recursive subroutine graph_write (cascade, mask, reverse)
type(cascade_t), intent(in) :: cascade
integer(TC), intent(in) :: mask
logical, intent(in), optional :: reverse
type(flavor_t) :: anti
logical :: rev
rev = .false.; if (present(reverse)) rev = reverse
if (cascade%has_children) then
if (.not.rev) then
call vertex_write (cascade, cascade%daughter1, mask)
call vertex_write (cascade, cascade%daughter2, mask)
else
call vertex_write (cascade, cascade%daughter2, mask, .true.)
call vertex_write (cascade, cascade%daughter1, mask, .true.)
end if
if (cascade%complete) then
call vertex_write (cascade, cascade%mother, mask, .true.)
write (u, '(A,I0,A)') "\fmfv{d.shape=square}{v0}"
end if
else
if (cascade%incoming) then
anti = cascade%flv%anti ()
call external_write (cascade%bincode, anti%get_tex_name (), &
left_str)
else
call external_write (cascade%bincode, cascade%flv%get_tex_name (), &
right_str)
end if
end if
end subroutine graph_write
recursive subroutine vertex_write (cascade, daughter, mask, reverse)
type(cascade_t), intent(in) :: cascade, daughter
integer(TC), intent(in) :: mask
logical, intent(in), optional :: reverse
integer :: bincode
if (cascade%complete) then
bincode = 0
else
bincode = cascade%bincode
end if
call graph_write (daughter, mask, reverse)
if (daughter%has_children) then
call line_write (bincode, daughter%bincode, daughter%flv, &
mapping=daughter%mapping)
else
call line_write (bincode, daughter%bincode, daughter%flv)
end if
end subroutine vertex_write
subroutine line_write (i1, i2, flv, mapping)
integer(TC), intent(in) :: i1, i2
type(flavor_t), intent(in) :: flv
integer, intent(in), optional :: mapping
integer :: k1, k2
type(string_t) :: prt_type
select case (flv%get_spin_type ())
case (SCALAR); prt_type = "plain"
case (SPINOR); prt_type = "fermion"
case (VECTOR); prt_type = "boson"
case (VECTORSPINOR); prt_type = "fermion"
case (TENSOR); prt_type = "dbl_wiggly"
case default; prt_type = "dashes"
end select
if (flv%is_antiparticle ()) then
k1 = i2; k2 = i1
else
k1 = i1; k2 = i2
end if
if (present (mapping)) then
select case (mapping)
case (S_CHANNEL)
write (u, '(A,I0,A,I0,A)') "\fmf{" // char (prt_type) // &
& ",f=blue,lab=\sm\blue$" // &
& char (flv%get_tex_name ()) // "$}" // &
& "{v", k1, ",v", k2, "}"
case (T_CHANNEL, U_CHANNEL)
write (u, '(A,I0,A,I0,A)') "\fmf{" // char (prt_type) // &
& ",f=cyan,lab=\sm\cyan$" // &
& char (flv%get_tex_name ()) // "$}" // &
& "{v", k1, ",v", k2, "}"
case (RADIATION)
write (u, '(A,I0,A,I0,A)') "\fmf{" // char (prt_type) // &
& ",f=green,lab=\sm\green$" // &
& char (flv%get_tex_name ()) // "$}" // &
& "{v", k1, ",v", k2, "}"
case (COLLINEAR)
write (u, '(A,I0,A,I0,A)') "\fmf{" // char (prt_type) // &
& ",f=magenta,lab=\sm\magenta$" // &
& char (flv%get_tex_name ()) // "$}" // &
& "{v", k1, ",v", k2, "}"
case (INFRARED)
write (u, '(A,I0,A,I0,A)') "\fmf{" // char (prt_type) // &
& ",f=red,lab=\sm\red$" // &
& char (flv%get_tex_name ()) // "$}" // &
& "{v", k1, ",v", k2, "}"
case default
write (u, '(A,I0,A,I0,A)') "\fmf{" // char (prt_type) // &
& ",f=black}" // &
& "{v", k1, ",v", k2, "}"
end select
else
write (u, '(A,I0,A,I0,A)') "\fmf{" // char (prt_type) // &
& "}" // &
& "{v", k1, ",v", k2, "}"
end if
end subroutine line_write
subroutine external_write (bincode, name, ext_str)
integer(TC), intent(in) :: bincode
type(string_t), intent(in) :: name
type(string_t), intent(inout) :: ext_str
character(len=20) :: str
write (str, '(A2,I0)') ",v", bincode
ext_str = ext_str // trim (str)
write (u, '(A,I0,A,I0,A)') "\fmflabel{\sm$" &
// char (name) &
// "\,(", bincode, ")" &
// "$}{v", bincode, "}"
end subroutine external_write
end subroutine cascade_write_graph_format
@ %def cascade_write_graph_format
@ This is for screen/debugging output:
<<Cascades: procedures>>=
subroutine cascade_write (cascade, unit)
type(cascade_t), intent(in) :: cascade
integer, intent(in), optional :: unit
integer :: u
character(9) :: depth
u = given_output_unit (unit); if (u < 0) return
write (u, "(A,(1x,I7))") 'Cascade #', cascade%index
write (u, "(A,(1x,I7))") ' Grove: #', cascade%grove
write (u, "(A,3(1x,L1))") ' act/cmp/inc: ', &
cascade%active, cascade%complete, cascade%incoming
write (u, "(A,I0)") ' Bincode: ', cascade%bincode
write (u, "(A)", advance="no") ' Flavor: '
call cascade%flv%write (unit)
write (u, "(A,I9)") ' Active flavor:', cascade%pdg
write (u, "(A,L1)") ' Is vector: ', cascade%is_vector
write (u, "(A,3(1x," // FMT_19 // "))") ' Mass (m/r/e): ', &
cascade%m_min, cascade%m_rea, cascade%m_eff
write (u, "(A,I1)") ' Mapping: ', cascade%mapping
write (u, "(A,3(1x,L1))") ' res/log/tch: ', &
cascade%resonant, cascade%log_enhanced, cascade%t_channel
write (u, "(A,(1x,I7))") ' Multiplicity: ', cascade%multiplicity
write (u, "(A,2(1x,I7))") ' n intern/off: ', &
cascade%internal, cascade%n_off_shell
write (u, "(A,3(1x,I7))") ' n res/log/tch:', &
cascade%n_resonances, cascade%n_log_enhanced, cascade%n_t_channel
write (u, "(A,I7)") ' Depth: ', cascade%depth
write (depth, "(I7)") cascade%depth
write (u, "(A," // depth // "(1x,I7))") &
' Tree: ', cascade%tree
write (u, "(A," // depth // "(1x,I7))") &
' Tree(PDG): ', cascade%tree_pdg
write (u, "(A," // depth // "(1x,I7))") &
' Tree(mapping):', cascade%tree_mapping
write (u, "(A," // depth // "(1x,L1))") &
' Tree(res): ', cascade%tree_resonant
if (cascade%has_children) then
write (u, "(A,I7,1x,I7)") ' Daughter1/2: ', &
cascade%daughter1%index, cascade%daughter2%index
end if
if (associated (cascade%mother)) then
write (u, "(A,I7)") ' Mother: ', cascade%mother%index
end if
end subroutine cascade_write
@ %def cascade_write
@
\subsection{Creating new cascades}
This initializes a single-particle cascade (external, final state).
The PDG entry in the tree is set undefined because the cascade is not
resonant. However, the flavor entry is set, so the cascade flavor
is identified nevertheless.
<<Cascades: procedures>>=
subroutine cascade_init_outgoing (cascade, flv, pos, m_thr)
type(cascade_t), intent(out) :: cascade
type(flavor_t), intent(in) :: flv
integer, intent(in) :: pos
real(default), intent(in) :: m_thr
call cascade_init (cascade, 1)
cascade%bincode = ibset (0_TC, pos-1)
cascade%flv = flv
cascade%pdg = cascade%flv%get_pdg ()
cascade%is_vector = flv%get_spin_type () == VECTOR
cascade%m_min = flv%get_mass ()
cascade%m_rea = cascade%m_min
if (cascade%m_rea >= m_thr) then
cascade%m_eff = cascade%m_rea
end if
cascade%on_shell = .true.
cascade%multiplicity = 1
cascade%tree(1) = cascade%bincode
cascade%tree_pdg(1) = cascade%pdg
cascade%tree_mapping(1) = EXTERNAL_PRT
cascade%tree_resonant(1) = .false.
end subroutine cascade_init_outgoing
@ %def cascade_init_outgoing
@ The same for an incoming line:
<<Cascades: procedures>>=
subroutine cascade_init_incoming (cascade, flv, pos, m_thr)
type(cascade_t), intent(out) :: cascade
type(flavor_t), intent(in) :: flv
integer, intent(in) :: pos
real(default), intent(in) :: m_thr
call cascade_init (cascade, 1)
cascade%incoming = .true.
cascade%bincode = ibset (0_TC, pos-1)
cascade%flv = flv%anti ()
cascade%pdg = cascade%flv%get_pdg ()
cascade%is_vector = flv%get_spin_type () == VECTOR
cascade%m_min = flv%get_mass ()
cascade%m_rea = cascade%m_min
if (cascade%m_rea >= m_thr) then
cascade%m_eff = cascade%m_rea
end if
cascade%on_shell = .true.
cascade%n_t_channel = 0
cascade%n_off_shell = 0
cascade%tree(1) = cascade%bincode
cascade%tree_pdg(1) = cascade%pdg
cascade%tree_mapping(1) = EXTERNAL_PRT
cascade%tree_resonant(1) = .false.
end subroutine cascade_init_incoming
@ %def cascade_init_outgoing
@
\subsection{Tools}
This function returns true if the two cascades share no common
external particle. This is a requirement for joining them.
<<Cascades: interfaces>>=
interface operator(.disjunct.)
module procedure cascade_disjunct
end interface
<<Cascades: procedures>>=
function cascade_disjunct (cascade1, cascade2) result (flag)
logical :: flag
type(cascade_t), intent(in) :: cascade1, cascade2
flag = iand (cascade1%bincode, cascade2%bincode) == 0
end function cascade_disjunct
@ %def cascade_disjunct
@ %def .disjunct.
@ Compute a hash code for the resonance pattern of a cascade. We count the
number of times each particle appears as a resonance.
We pack the PDG codes of the resonances in two arrays (s-channel and
t-channel), sort them both, concatenate the results, transfer to
[[i8]] integers, and compute the hash code from this byte stream.
For t/u-channel, we remove the sign for antiparticles since this is not
well-defined.
<<Cascades: procedures>>=
subroutine cascade_assign_resonance_hash (cascade)
type(cascade_t), intent(inout) :: cascade
integer(i8), dimension(1) :: mold
cascade%res_hash = hash (transfer &
([sort (pack (cascade%tree_pdg, &
cascade%tree_resonant)), &
sort (pack (abs (cascade%tree_pdg), &
cascade%tree_mapping == T_CHANNEL .or. &
cascade%tree_mapping == U_CHANNEL))], &
mold))
end subroutine cascade_assign_resonance_hash
@ %def cascade_assign_resonance_hash
@
\subsection{Hash entries for cascades}
We will set up a hash array which contains keys of and pointers to
cascades. We hold a list of cascade (pointers) within each bucket.
This is not for collision resolution, but for keeping similar, but
unequal cascades together.
<<Cascades: types>>=
type :: cascade_p
type(cascade_t), pointer :: cascade => null ()
type(cascade_p), pointer :: next => null ()
end type cascade_p
@ %def cascade_p
@ Here is the bucket or hash entry type:
<<Cascades: types>>=
type :: hash_entry_t
integer(i32) :: hashval = 0
integer(i8), dimension(:), allocatable :: key
type(cascade_p), pointer :: first => null ()
type(cascade_p), pointer :: last => null ()
end type hash_entry_t
@ %def hash_entry_t
<<Cascades: public>>=
public :: hash_entry_init
<<Cascades: procedures>>=
subroutine hash_entry_init (entry, entry_in)
type(hash_entry_t), intent(out) :: entry
type(hash_entry_t), intent(in) :: entry_in
type(cascade_p), pointer :: casc_iter, casc_copy
entry%hashval = entry_in%hashval
entry%key = entry_in%key
casc_iter => entry_in%first
do while (associated (casc_iter))
allocate (casc_copy)
casc_copy = casc_iter
casc_copy%next => null ()
if (associated (entry%first)) then
entry%last%next => casc_copy
else
entry%first => casc_copy
end if
entry%last => casc_copy
casc_iter => casc_iter%next
end do
end subroutine hash_entry_init
@ %def hash_entry_init
@ Finalize: just deallocate the list; the contents are just pointers.
<<Cascades: procedures>>=
subroutine hash_entry_final (hash_entry)
type(hash_entry_t), intent(inout) :: hash_entry
type(cascade_p), pointer :: current
do while (associated (hash_entry%first))
current => hash_entry%first
hash_entry%first => current%next
deallocate (current)
end do
end subroutine hash_entry_final
@ %def hash_entry_final
@ Output: concise format for debugging, just list cascade indices.
<<Cascades: procedures>>=
subroutine hash_entry_write (hash_entry, unit)
type(hash_entry_t), intent(in) :: hash_entry
integer, intent(in), optional :: unit
type(cascade_p), pointer :: current
integer :: u, i
u = given_output_unit (unit); if (u < 0) return
write (u, "(1x,A)", advance="no") "Entry:"
do i = 1, size (hash_entry%key)
write (u, "(1x,I0)", advance="no") hash_entry%key(i)
end do
write (u, "(1x,A)", advance="no") "->"
current => hash_entry%first
do while (associated (current))
write (u, "(1x,I7)", advance="no") current%cascade%index
current => current%next
end do
write (u, *)
end subroutine hash_entry_write
@ %def hash_entry_write
@ This function adds a cascade pointer to the bucket. If [[ok]] is
present, check first if it is already there and return failure if yes.
If [[cascade_ptr]] is also present, set it to the current cascade if
successful. If not, set it to the cascade that is already there.
<<Cascades: procedures>>=
subroutine hash_entry_add_cascade_ptr (hash_entry, cascade, ok, cascade_ptr)
type(hash_entry_t), intent(inout) :: hash_entry
type(cascade_t), intent(in), target :: cascade
logical, intent(out), optional :: ok
type(cascade_t), optional, pointer :: cascade_ptr
type(cascade_p), pointer :: current
if (present (ok)) then
call hash_entry_check_cascade (hash_entry, cascade, ok, cascade_ptr)
if (.not. ok) return
end if
allocate (current)
current%cascade => cascade
if (associated (hash_entry%last)) then
hash_entry%last%next => current
else
hash_entry%first => current
end if
hash_entry%last => current
end subroutine hash_entry_add_cascade_ptr
@ %def hash_entry_add_cascade_ptr
@ This function checks whether a cascade is already in the bucket.
For incomplete cascades, we look for an exact match. It should suffice
to verify the tree, the PDG codes, and the mapping modes. This is the
information that is written to the phase space file.
For complete cascades, we ignore the PDG code at positions with
mappings infrared, collinear, or t/u-channel. Thus a cascade which is
distinguished only by PDG code at such places, is flagged existent.
If the convention is followed that light particles come before heavier
ones (in the model definition), this ensures that the lightest
particle is kept in the appropriate place, corresponding to the
strongest peak.
For external cascades (incoming/outgoing) we take the PDG code into
account even though it is zeroed in the PDG-code tree.
<<Cascades: procedures>>=
subroutine hash_entry_check_cascade (hash_entry, cascade, ok, cascade_ptr)
type(hash_entry_t), intent(in), target :: hash_entry
type(cascade_t), intent(in), target :: cascade
logical, intent(out) :: ok
type(cascade_t), optional, pointer :: cascade_ptr
type(cascade_p), pointer :: current
integer, dimension(:), allocatable :: tree_pdg
ok = .true.
allocate (tree_pdg (size (cascade%tree_pdg)))
if (cascade%complete) then
where (cascade%tree_mapping == INFRARED .or. &
cascade%tree_mapping == COLLINEAR .or. &
cascade%tree_mapping == T_CHANNEL .or. &
cascade%tree_mapping == U_CHANNEL)
tree_pdg = 0
elsewhere
tree_pdg = cascade%tree_pdg
end where
else
tree_pdg = cascade%tree_pdg
end if
current => hash_entry%first
do while (associated (current))
if (current%cascade%depth == cascade%depth) then
if (all (current%cascade%tree == cascade%tree)) then
if (all (current%cascade%tree_mapping == cascade%tree_mapping)) &
then
if (all (current%cascade%tree_pdg .match. tree_pdg)) then
if (present (cascade_ptr)) cascade_ptr => current%cascade
ok = .false.; return
end if
end if
end if
end if
current => current%next
end do
if (present (cascade_ptr)) cascade_ptr => cascade
end subroutine hash_entry_check_cascade
@ %def hash_entry_check_cascade
@ For PDG codes, we specify that the undefined code matches any code.
This is already defined for flavor objects, but here we need it for
the codes themselves.
<<Cascades: interfaces>>=
interface operator(.match.)
module procedure pdg_match
end interface
<<Cascades: procedures>>=
elemental function pdg_match (pdg1, pdg2) result (flag)
logical :: flag
integer(TC), intent(in) :: pdg1, pdg2
select case (pdg1)
case (0)
flag = .true.
case default
select case (pdg2)
case (0)
flag = .true.
case default
flag = pdg1 == pdg2
end select
end select
end function pdg_match
@ %def .match.
@
\subsection{The cascade set}
The cascade set will later be transformed into the decay forest. It
is set up as a linked list. In addition to the usual [[first]] and
[[last]] pointers, there is a [[first_t]] pointer which points to the
first t-channel cascade (after all s-channel cascades), and a
[[first_k]] pointer which points to the first final cascade (with a
keystone).
As an auxiliary device, the object contains a hash array with
associated parameters where an additional pointer is stored for each
cascade. The keys are made from the relevant cascade data. This hash
is used for fast detection (and thus avoidance) of double entries in
the cascade list.
<<Cascades: public>>=
public :: cascade_set_t
<<Cascades: types>>=
type :: cascade_set_t
private
class(model_data_t), pointer :: model
integer :: n_in, n_out, n_tot
type(flavor_t), dimension(:,:), allocatable :: flv
integer :: depth_out, depth_tot
real(default) :: sqrts = 0
real(default) :: m_threshold_s = 0
real(default) :: m_threshold_t = 0
integer :: off_shell = 0
integer :: t_channel = 0
logical :: keep_nonresonant
integer :: n_groves = 0
! The cascade list
type(cascade_t), pointer :: first => null ()
type(cascade_t), pointer :: last => null ()
type(cascade_t), pointer :: first_t => null ()
type(cascade_t), pointer :: first_k => null ()
! The hashtable
integer :: n_entries = 0
real :: fill_ratio = 0
integer :: n_entries_max = 0
integer(i32) :: mask = 0
logical :: fatal_beam_decay = .true.
type(hash_entry_t), dimension(:), allocatable :: entry
end type cascade_set_t
@ %def cascade_set_t
@
<<Cascades: public>>=
interface cascade_set_init
module procedure cascade_set_init_base
module procedure cascade_set_init_from_cascade
end interface
@ %def cascade_set_init
@ This might be broken. Test before using.
<<Cascades: procedures>>=
subroutine cascade_set_init_from_cascade (cascade_set, cascade_set_in)
type(cascade_set_t), intent(out) :: cascade_set
type(cascade_set_t), intent(in), target :: cascade_set_in
type(cascade_t), pointer :: casc_iter, casc_copy
cascade_set%model => cascade_set_in%model
cascade_set%n_in = cascade_set_in%n_in
cascade_set%n_out = cascade_set_in%n_out
cascade_set%n_tot = cascade_set_in%n_tot
cascade_set%flv = cascade_set_in%flv
cascade_set%depth_out = cascade_set_in%depth_out
cascade_set%depth_tot = cascade_set_in%depth_tot
cascade_set%sqrts = cascade_set_in%sqrts
cascade_set%m_threshold_s = cascade_set_in%m_threshold_s
cascade_set%m_threshold_t = cascade_set_in%m_threshold_t
cascade_set%off_shell = cascade_set_in%off_shell
cascade_set%t_channel = cascade_set_in%t_channel
cascade_set%keep_nonresonant = cascade_set_in%keep_nonresonant
cascade_set%n_groves = cascade_set_in%n_groves
casc_iter => cascade_set_in%first
do while (associated (casc_iter))
allocate (casc_copy)
casc_copy = casc_iter
casc_copy%next => null ()
if (associated (cascade_set%first)) then
cascade_set%last%next => casc_copy
else
cascade_set%first => casc_copy
end if
cascade_set%last => casc_copy
casc_iter => casc_iter%next
end do
cascade_set%n_entries = cascade_set_in%n_entries
cascade_set%fill_ratio = cascade_set_in%fill_ratio
cascade_set%n_entries_max = cascade_set_in%n_entries_max
cascade_set%mask = cascade_set_in%mask
cascade_set%fatal_beam_decay = cascade_set_in%fatal_beam_decay
allocate (cascade_set%entry (0:cascade_set%mask))
cascade_set%entry = cascade_set_in%entry
end subroutine cascade_set_init_from_cascade
@ %def cascade_set_init_from_cascade
@ Return true if there are cascades which are active and complete, so
the phase space file would be nonempty.
<<Cascades: public>>=
public :: cascade_set_is_valid
<<Cascades: procedures>>=
function cascade_set_is_valid (cascade_set) result (flag)
logical :: flag
type(cascade_set_t), intent(in) :: cascade_set
type(cascade_t), pointer :: cascade
flag = .false.
cascade => cascade_set%first_k
do while (associated (cascade))
if (cascade%active .and. cascade%complete) then
flag = .true.
return
end if
cascade => cascade%next
end do
end function cascade_set_is_valid
@ %def cascade_set_is_valid
@ The initializer sets up the hash table with some initial size
guessed by looking at the number of external particles. We choose 256
for 3 external particles and a factor of 4 for each additional
particle, limited at $2^{30}$=1G.
<<Cascades: parameters>>=
real, parameter, public :: CASCADE_SET_FILL_RATIO = 0.1
<<Cascades: procedures>>=
subroutine cascade_set_init_base (cascade_set, model, n_in, n_out, phs_par, &
fatal_beam_decay, flv)
type(cascade_set_t), intent(out) :: cascade_set
class(model_data_t), intent(in), target :: model
integer, intent(in) :: n_in, n_out
type(phs_parameters_t), intent(in) :: phs_par
logical, intent(in) :: fatal_beam_decay
type(flavor_t), dimension(:,:), intent(in), optional :: flv
integer :: size_guess
integer :: i, j
cascade_set%model => model
cascade_set%n_in = n_in
cascade_set%n_out = n_out
cascade_set%n_tot = n_in + n_out
if (present (flv)) then
allocate (cascade_set%flv (size (flv, 1), size (flv, 2)))
do i = 1, size (flv, 2)
do j = 1, size (flv, 1)
call cascade_set%flv(j,i)%init (flv(j,i)%get_pdg (), model)
end do
end do
end if
select case (n_in)
case (1); cascade_set%depth_out = 2 * n_out - 3
case (2); cascade_set%depth_out = 2 * n_out - 1
end select
cascade_set%depth_tot = 2 * cascade_set%n_tot - 3
cascade_set%sqrts = phs_par%sqrts
cascade_set%m_threshold_s = phs_par%m_threshold_s
cascade_set%m_threshold_t = phs_par%m_threshold_t
cascade_set%off_shell = phs_par%off_shell
cascade_set%t_channel = phs_par%t_channel
cascade_set%keep_nonresonant = phs_par%keep_nonresonant
cascade_set%fill_ratio = CASCADE_SET_FILL_RATIO
size_guess = ishft (256, min (2 * (cascade_set%n_tot - 3), 22))
cascade_set%n_entries_max = size_guess * cascade_set%fill_ratio
cascade_set%mask = size_guess - 1
allocate (cascade_set%entry (0:cascade_set%mask))
cascade_set%fatal_beam_decay = fatal_beam_decay
end subroutine cascade_set_init_base
@ %def cascade_set_init_base
@ The finalizer has to delete both the hash and the list.
<<Cascades: public>>=
public :: cascade_set_final
<<Cascades: procedures>>=
subroutine cascade_set_final (cascade_set)
type(cascade_set_t), intent(inout), target :: cascade_set
type(cascade_t), pointer :: current
integer :: i
if (allocated (cascade_set%entry)) then
do i = 0, cascade_set%mask
call hash_entry_final (cascade_set%entry(i))
end do
deallocate (cascade_set%entry)
end if
do while (associated (cascade_set%first))
current => cascade_set%first
cascade_set%first => cascade_set%first%next
deallocate (current)
end do
end subroutine cascade_set_final
@ %def cascade_set_final
@ Write the process in ASCII format, in columns that are headed by the
corresponding bincode.
<<Cascades: public>>=
public :: cascade_set_write_process_bincode_format
<<Cascades: procedures>>=
subroutine cascade_set_write_process_bincode_format (cascade_set, unit)
type(cascade_set_t), intent(in), target :: cascade_set
integer, intent(in), optional :: unit
integer, dimension(:), allocatable :: bincode, field_width
integer :: n_in, n_out, n_tot, n_flv
integer :: u, f, i, bc
character(20) :: str
type(string_t) :: fmt_head
type(string_t), dimension(:), allocatable :: fmt_proc
u = given_output_unit (unit); if (u < 0) return
if (.not. allocated (cascade_set%flv)) return
write (u, "('!',1x,A)") "List of subprocesses with particle bincodes:"
n_in = cascade_set%n_in
n_out = cascade_set%n_out
n_tot = cascade_set%n_tot
n_flv = size (cascade_set%flv, 2)
allocate (bincode (n_tot), field_width (n_tot), fmt_proc (n_tot))
bc = 1
do i = 1, n_out
bincode(n_in + i) = bc
bc = 2 * bc
end do
do i = n_in, 1, -1
bincode(i) = bc
bc = 2 * bc
end do
do i = 1, n_tot
write (str, "(I0)") bincode(i)
field_width(i) = len_trim (str)
do f = 1, n_flv
field_width(i) = max (field_width(i), &
len (cascade_set%flv(i,f)%get_name ()))
end do
end do
fmt_head = "('!'"
do i = 1, n_tot
fmt_head = fmt_head // ",1x,"
fmt_proc(i) = "(1x,"
write (str, "(I0)") field_width(i)
fmt_head = fmt_head // "I" // trim(str)
fmt_proc(i) = fmt_proc(i) // "A" // trim(str)
if (i == n_in) then
fmt_head = fmt_head // ",1x,' '"
end if
end do
do i = 1, n_tot
fmt_proc(i) = fmt_proc(i) // ")"
end do
fmt_head = fmt_head // ")"
write (u, char (fmt_head)) bincode
do f = 1, n_flv
write (u, "('!')", advance="no")
do i = 1, n_tot
write (u, char (fmt_proc(i)), advance="no") &
char (cascade_set%flv(i,f)%get_name ())
if (i == n_in) write (u, "(1x,'=>')", advance="no")
end do
write (u, *)
end do
write (u, char (fmt_head)) bincode
end subroutine cascade_set_write_process_bincode_format
@ %def cascade_set_write_process_tex_format
@ Write the process as a \LaTeX\ expression.
<<Cascades: procedures>>=
subroutine cascade_set_write_process_tex_format (cascade_set, unit)
type(cascade_set_t), intent(in), target :: cascade_set
integer, intent(in), optional :: unit
integer :: u, f, i
u = given_output_unit (unit); if (u < 0) return
if (.not. allocated (cascade_set%flv)) return
write (u, "(A)") "\begin{align*}"
do f = 1, size (cascade_set%flv, 2)
do i = 1, cascade_set%n_in
if (i > 1) write (u, "(A)", advance="no") "\quad "
write (u, "(A)", advance="no") &
char (cascade_set%flv(i,f)%get_tex_name ())
end do
write (u, "(A)", advance="no") "\quad &\to\quad "
do i = cascade_set%n_in + 1, cascade_set%n_tot
if (i > cascade_set%n_in + 1) write (u, "(A)", advance="no") "\quad "
write (u, "(A)", advance="no") &
char (cascade_set%flv(i,f)%get_tex_name ())
end do
if (f < size (cascade_set%flv, 2)) then
write (u, "(A)") "\\"
else
write (u, "(A)") ""
end if
end do
write (u, "(A)") "\end{align*}"
end subroutine cascade_set_write_process_tex_format
@ %def cascade_set_write_process_tex_format
@ Three output routines: phase-space file, graph source code, and
screen output.
This version generates the phase space file. It deals only with
complete cascades.
<<Cascades: public>>=
public :: cascade_set_write_file_format
<<Cascades: procedures>>=
subroutine cascade_set_write_file_format (cascade_set, unit)
type(cascade_set_t), intent(in), target :: cascade_set
integer, intent(in), optional :: unit
type(cascade_t), pointer :: cascade
integer :: u, grove, count
logical :: first_in_grove
u = given_output_unit (unit); if (u < 0) return
count = 0
do grove = 1, cascade_set%n_groves
first_in_grove = .true.
cascade => cascade_set%first_k
do while (associated (cascade))
if (cascade%active .and. cascade%complete) then
if (cascade%grove == grove) then
if (first_in_grove) then
first_in_grove = .false.
write (u, "(A)")
write (u, "(1x,'!',1x,A,1x,I0,A)", advance='no') &
'Multiplicity =', cascade%multiplicity, ","
select case (cascade%n_resonances)
case (0)
write (u, '(1x,A)', advance='no') 'no resonances, '
case (1)
write (u, '(1x,A)', advance='no') '1 resonance, '
case default
write (u, '(1x,I0,1x,A)', advance='no') &
cascade%n_resonances, 'resonances, '
end select
write (u, '(1x,I0,1x,A)', advance='no') &
cascade%n_log_enhanced, 'logs, '
write (u, '(1x,I0,1x,A)', advance='no') &
cascade%n_off_shell, 'off-shell, '
select case (cascade%n_t_channel)
case (0); write (u, '(1x,A)') 's-channel graph'
case (1); write (u, '(1x,A)') '1 t-channel line'
case default
write(u,'(1x,I0,1x,A)') &
cascade%n_t_channel, 't-channel lines'
end select
write (u, '(1x,A,I0)') 'grove #', grove
end if
count = count + 1
write (u, "(1x,'!',1x,A,I0)") "Channel #", count
call cascade_write_file_format (cascade, cascade_set%model, u)
end if
end if
cascade => cascade%next
end do
end do
end subroutine cascade_set_write_file_format
@ %def cascade_set_write_file_format
@ This is the graph output format, the driver-file
<<Cascades: public>>=
public :: cascade_set_write_graph_format
<<Cascades: procedures>>=
subroutine cascade_set_write_graph_format &
(cascade_set, filename, process_id, unit)
type(cascade_set_t), intent(in), target :: cascade_set
type(string_t), intent(in) :: filename, process_id
integer, intent(in), optional :: unit
type(cascade_t), pointer :: cascade
integer :: u, grove, count, pgcount
logical :: first_in_grove
u = given_output_unit (unit); if (u < 0) return
write (u, '(A)') "\documentclass[10pt]{article}"
write (u, '(A)') "\usepackage{amsmath}"
write (u, '(A)') "\usepackage{feynmp}"
write (u, '(A)') "\usepackage{url}"
write (u, '(A)') "\usepackage{color}"
write (u, *)
write (u, '(A)') "\textwidth 18.5cm"
write (u, '(A)') "\evensidemargin -1.5cm"
write (u, '(A)') "\oddsidemargin -1.5cm"
write (u, *)
write (u, '(A)') "\newcommand{\blue}{\color{blue}}"
write (u, '(A)') "\newcommand{\green}{\color{green}}"
write (u, '(A)') "\newcommand{\red}{\color{red}}"
write (u, '(A)') "\newcommand{\magenta}{\color{magenta}}"
write (u, '(A)') "\newcommand{\cyan}{\color{cyan}}"
write (u, '(A)') "\newcommand{\sm}{\footnotesize}"
write (u, '(A)') "\setlength{\parindent}{0pt}"
write (u, '(A)') "\setlength{\parsep}{20pt}"
write (u, *)
write (u, '(A)') "\begin{document}"
write (u, '(A)') "\begin{fmffile}{" // char (filename) // "}"
write (u, '(A)') "\fmfcmd{color magenta; magenta = red + blue;}"
write (u, '(A)') "\fmfcmd{color cyan; cyan = green + blue;}"
write (u, '(A)') "\begin{fmfshrink}{0.5}"
write (u, '(A)') "\begin{flushleft}"
write (u, *)
write (u, '(A)') "\noindent" // &
& "\textbf{\large\texttt{WHIZARD} phase space channels}" // &
& "\hfill\today"
write (u, *)
write (u, '(A)') "\vspace{10pt}"
write (u, '(A)') "\noindent" // &
& "\textbf{Process:} \url{" // char (process_id) // "}"
call cascade_set_write_process_tex_format (cascade_set, u)
write (u, *)
write (u, '(A)') "\noindent" // &
& "\textbf{Note:} These are pseudo Feynman graphs that "
write (u, '(A)') "visualize phase-space parameterizations " // &
& "(``integration channels''). "
write (u, '(A)') "They do \emph{not} indicate Feynman graphs used for the " // &
& "matrix element."
write (u, *)
write (u, '(A)') "\textbf{Color code:} " // &
& "{\blue resonance,} " // &
& "{\cyan t-channel,} " // &
& "{\green radiation,} "
write (u, '(A)') "{\red infrared,} " // &
& "{\magenta collinear,} " // &
& "external/off-shell"
write (u, *)
write (u, '(A)') "\noindent" // &
& "\textbf{Black square:} Keystone, indicates ordering of " // &
& "phase space parameters."
write (u, *)
write (u, '(A)') "\vspace{-20pt}"
count = 0
pgcount = 0
do grove = 1, cascade_set%n_groves
first_in_grove = .true.
cascade => cascade_set%first
do while (associated (cascade))
if (cascade%active .and. cascade%complete) then
if (cascade%grove == grove) then
if (first_in_grove) then
first_in_grove = .false.
write (u, *)
write (u, '(A)') "\vspace{20pt}"
write (u, '(A)') "\begin{tabular}{l}"
write (u, '(A,I5,A)') &
& "\fbox{\bf Grove \boldmath$", grove, "$} \\[10pt]"
write (u, '(A,I1,A)') "Multiplicity: ", &
cascade%multiplicity, "\\"
write (u, '(A,I1,A)') "Resonances: ", &
cascade%n_resonances, "\\"
write (u, '(A,I1,A)') "Log-enhanced: ", &
cascade%n_log_enhanced, "\\"
write (u, '(A,I1,A)') "Off-shell: ", &
cascade%n_off_shell, "\\"
write (u, '(A,I1,A)') "t-channel: ", &
cascade%n_t_channel, ""
write (u, '(A)') "\end{tabular}"
end if
count = count + 1
call cascade_write_graph_format (cascade, count, unit)
if (pgcount >= 250) then
write (u, '(A)') "\clearpage"
pgcount = 0
end if
end if
end if
cascade => cascade%next
end do
end do
write (u, '(A)') "\end{flushleft}"
write (u, '(A)') "\end{fmfshrink}"
write (u, '(A)') "\end{fmffile}"
write (u, '(A)') "\end{document}"
end subroutine cascade_set_write_graph_format
@ %def cascade_set_write_graph_format
@ This is for screen output and debugging:
<<Cascades: public>>=
public :: cascade_set_write
<<Cascades: procedures>>=
subroutine cascade_set_write (cascade_set, unit, active_only, complete_only)
type(cascade_set_t), intent(in), target :: cascade_set
integer, intent(in), optional :: unit
logical, intent(in), optional :: active_only, complete_only
logical :: active, complete
type(cascade_t), pointer :: cascade
integer :: u, i
u = given_output_unit (unit); if (u < 0) return
active = .true.; if (present (active_only)) active = active_only
complete = .false.; if (present (complete_only)) complete = complete_only
write (u, "(A)") "Cascade set:"
write (u, "(3x,A)", advance="no") "Model:"
if (associated (cascade_set%model)) then
write (u, "(1x,A)") char (cascade_set%model%get_name ())
else
write (u, "(1x,A)") "[none]"
end if
write (u, "(3x,A)", advance="no") "n_in/out/tot ="
write (u, "(3(1x,I7))") &
cascade_set%n_in, cascade_set%n_out, cascade_set%n_tot
write (u, "(3x,A)", advance="no") "depth_out/tot ="
write (u, "(2(1x,I7))") cascade_set%depth_out, cascade_set%depth_tot
write (u, "(3x,A)", advance="no") "mass thr(s/t) ="
write (u, "(2(1x," // FMT_19 // "))") &
cascade_set%m_threshold_s, cascade_set%m_threshold_t
write (u, "(3x,A)", advance="no") "off shell ="
write (u, "(1x,I7)") cascade_set%off_shell
write (u, "(3x,A)", advance="no") "keep_nonreson ="
write (u, "(1x,L1)") cascade_set%keep_nonresonant
write (u, "(3x,A)", advance="no") "n_groves ="
write (u, "(1x,I7)") cascade_set%n_groves
write (u, "(A)")
write (u, "(A)") "Cascade list:"
if (associated (cascade_set%first)) then
cascade => cascade_set%first
do while (associated (cascade))
if (active .and. .not. cascade%active) cycle
if (complete .and. .not. cascade%complete) cycle
call cascade_write (cascade, unit)
cascade => cascade%next
end do
else
write (u, "(A)") "[empty]"
end if
write (u, "(A)") "Hash array"
write (u, "(3x,A)", advance="no") "n_entries ="
write (u, "(1x,I7)") cascade_set%n_entries
write (u, "(3x,A)", advance="no") "fill_ratio ="
write (u, "(1x," // FMT_12 // ")") cascade_set%fill_ratio
write (u, "(3x,A)", advance="no") "n_entries_max ="
write (u, "(1x,I7)") cascade_set%n_entries_max
write (u, "(3x,A)", advance="no") "mask ="
write (u, "(1x,I0)") cascade_set%mask
do i = 0, ubound (cascade_set%entry, 1)
if (allocated (cascade_set%entry(i)%key)) then
write (u, "(1x,I7)") i
call hash_entry_write (cascade_set%entry(i), u)
end if
end do
end subroutine cascade_set_write
@ %def cascade_set_write
@
\subsection{Adding cascades}
Add a deep copy of a cascade to the set. The copy has all content of the
original, but the pointers are nullified. We do not care whether insertion
was successful or not. The pointer argument, if present, is assigned to the
input cascade, or to the hash entry if it is already present.
The procedure is recursive: any daughter or mother entries are also
deep-copied and added to the cascade set before the current copy is added.
<<Cascades: procedures>>=
recursive subroutine cascade_set_add_copy &
(cascade_set, cascade_in, cascade_ptr)
type(cascade_set_t), intent(inout), target :: cascade_set
type(cascade_t), intent(in) :: cascade_in
type(cascade_t), optional, pointer :: cascade_ptr
type(cascade_t), pointer :: cascade
logical :: ok
allocate (cascade)
cascade = cascade_in
if (associated (cascade_in%daughter1)) call cascade_set_add_copy &
(cascade_set, cascade_in%daughter1, cascade%daughter1)
if (associated (cascade_in%daughter2)) call cascade_set_add_copy &
(cascade_set, cascade_in%daughter2, cascade%daughter2)
if (associated (cascade_in%mother)) call cascade_set_add_copy &
(cascade_set, cascade_in%mother, cascade%mother)
cascade%next => null ()
call cascade_set_add (cascade_set, cascade, ok, cascade_ptr)
if (.not. ok) deallocate (cascade)
end subroutine cascade_set_add_copy
@ %def cascade_set_add_copy
@ Add a cascade to the set. This does not deep-copy. We first try to insert
it in the hash array. If successful, add it to the list. Failure indicates
that it is already present, and we drop it.
The hash key is built solely from the tree array, so neither particle
codes nor resonances count, just topology.
Technically, hash and list receive only pointers, so the cascade can
be considered as being in either of both. We treat it as part of the
list.
<<Cascades: procedures>>=
subroutine cascade_set_add (cascade_set, cascade, ok, cascade_ptr)
type(cascade_set_t), intent(inout), target :: cascade_set
type(cascade_t), intent(in), target :: cascade
logical, intent(out) :: ok
type(cascade_t), optional, pointer :: cascade_ptr
integer(i8), dimension(1) :: mold
call cascade_set_hash_insert &
(cascade_set, transfer (cascade%tree, mold), cascade, ok, cascade_ptr)
if (ok) call cascade_set_list_add (cascade_set, cascade)
end subroutine cascade_set_add
@ %def cascade_set_add
@ Add a new cascade to the list:
<<Cascades: procedures>>=
subroutine cascade_set_list_add (cascade_set, cascade)
type(cascade_set_t), intent(inout) :: cascade_set
type(cascade_t), intent(in), target :: cascade
if (associated (cascade_set%last)) then
cascade_set%last%next => cascade
else
cascade_set%first => cascade
end if
cascade_set%last => cascade
end subroutine cascade_set_list_add
@ %def cascade_set_list_add
@ Add a cascade entry to the hash array:
<<Cascades: procedures>>=
subroutine cascade_set_hash_insert &
(cascade_set, key, cascade, ok, cascade_ptr)
type(cascade_set_t), intent(inout), target :: cascade_set
integer(i8), dimension(:), intent(in) :: key
type(cascade_t), intent(in), target :: cascade
logical, intent(out) :: ok
type(cascade_t), optional, pointer :: cascade_ptr
integer(i32) :: h
if (cascade_set%n_entries >= cascade_set%n_entries_max) &
call cascade_set_hash_expand (cascade_set)
h = hash (key)
call cascade_set_hash_insert_rec &
(cascade_set, h, h, key, cascade, ok, cascade_ptr)
end subroutine cascade_set_hash_insert
@ %def cascade_set_hash_insert
@ Double the hashtable size when necesssary:
<<Cascades: procedures>>=
subroutine cascade_set_hash_expand (cascade_set)
type(cascade_set_t), intent(inout), target :: cascade_set
type(hash_entry_t), dimension(:), allocatable, target :: table_tmp
type(cascade_p), pointer :: current
integer :: i, s
allocate (table_tmp (0:cascade_set%mask))
table_tmp = cascade_set%entry
deallocate (cascade_set%entry)
s = 2 * size (table_tmp)
cascade_set%n_entries = 0
cascade_set%n_entries_max = s * cascade_set%fill_ratio
cascade_set%mask = s - 1
allocate (cascade_set%entry (0:cascade_set%mask))
do i = 0, ubound (table_tmp, 1)
current => table_tmp(i)%first
do while (associated (current))
call cascade_set_hash_insert_rec &
(cascade_set, table_tmp(i)%hashval, table_tmp(i)%hashval, &
table_tmp(i)%key, current%cascade)
current => current%next
end do
end do
end subroutine cascade_set_hash_expand
@ %def cascade_set_hash_expand
@ Insert the cascade at the bucket determined by the hash value. If
the bucket is filled, check first for a collision (unequal keys). In
that case, choose the following bucket and repeat. Otherwise, add the
cascade to the bucket.
If the bucket is empty, record the hash value, allocate and store the
key, and then add the cascade to the bucket.
If [[ok]] is present, before insertion we check whether the cascade is
already stored, and return failure if yes.
<<Cascades: procedures>>=
recursive subroutine cascade_set_hash_insert_rec &
(cascade_set, h, hashval, key, cascade, ok, cascade_ptr)
type(cascade_set_t), intent(inout) :: cascade_set
integer(i32), intent(in) :: h, hashval
integer(i8), dimension(:), intent(in) :: key
type(cascade_t), intent(in), target :: cascade
logical, intent(out), optional :: ok
type(cascade_t), optional, pointer :: cascade_ptr
integer(i32) :: i
i = iand (h, cascade_set%mask)
if (allocated (cascade_set%entry(i)%key)) then
if (size (cascade_set%entry(i)%key) /= size (key)) then
call cascade_set_hash_insert_rec &
(cascade_set, h + 1, hashval, key, cascade, ok, cascade_ptr)
else if (any (cascade_set%entry(i)%key /= key)) then
call cascade_set_hash_insert_rec &
(cascade_set, h + 1, hashval, key, cascade, ok, cascade_ptr)
else
call hash_entry_add_cascade_ptr &
(cascade_set%entry(i), cascade, ok, cascade_ptr)
end if
else
cascade_set%entry(i)%hashval = hashval
allocate (cascade_set%entry(i)%key (size (key)))
cascade_set%entry(i)%key = key
call hash_entry_add_cascade_ptr &
(cascade_set%entry(i), cascade, ok, cascade_ptr)
cascade_set%n_entries = cascade_set%n_entries + 1
end if
end subroutine cascade_set_hash_insert_rec
@ %def cascade_set_hash_insert_rec
@
\subsection{External particles}
We want to initialize the cascade set with the outgoing particles. In
case of multiple processes, initial cascades are prepared for all of
them. The hash array check ensures that no particle appears more than
once at the same place.
<<Cascades: interfaces>>=
interface cascade_set_add_outgoing
module procedure cascade_set_add_outgoing1
module procedure cascade_set_add_outgoing2
end interface
<<Cascades: procedures>>=
subroutine cascade_set_add_outgoing2 (cascade_set, flv)
type(cascade_set_t), intent(inout), target :: cascade_set
type(flavor_t), dimension(:,:), intent(in) :: flv
integer :: pos, prc, n_out, n_prc
type(cascade_t), pointer :: cascade
logical :: ok
n_out = size (flv, dim=1)
n_prc = size (flv, dim=2)
do prc = 1, n_prc
do pos = 1, n_out
allocate (cascade)
call cascade_init_outgoing &
(cascade, flv(pos,prc), pos, cascade_set%m_threshold_s)
call cascade_set_add (cascade_set, cascade, ok)
if (.not. ok) then
deallocate (cascade)
end if
end do
end do
end subroutine cascade_set_add_outgoing2
subroutine cascade_set_add_outgoing1 (cascade_set, flv)
type(cascade_set_t), intent(inout), target :: cascade_set
type(flavor_t), dimension(:), intent(in) :: flv
integer :: pos, n_out
type(cascade_t), pointer :: cascade
logical :: ok
n_out = size (flv, dim=1)
do pos = 1, n_out
allocate (cascade)
call cascade_init_outgoing &
(cascade, flv(pos), pos, cascade_set%m_threshold_s)
call cascade_set_add (cascade_set, cascade, ok)
if (.not. ok) then
deallocate (cascade)
end if
end do
end subroutine cascade_set_add_outgoing1
@ %def cascade_set_add_outgoing
@ The incoming particles are added one at a time. Nevertheless, we
may have several processes which are looped over. At the first
opportunity, we set the pointer [[first_t]] in the cascade set which
should point to the first t-channel cascade.
Return the indices of the first and last cascade generated.
<<Cascades: interfaces>>=
interface cascade_set_add_incoming
module procedure cascade_set_add_incoming0
module procedure cascade_set_add_incoming1
end interface
<<Cascades: procedures>>=
subroutine cascade_set_add_incoming1 (cascade_set, n1, n2, pos, flv)
type(cascade_set_t), intent(inout), target :: cascade_set
integer, intent(out) :: n1, n2
integer, intent(in) :: pos
type(flavor_t), dimension(:), intent(in) :: flv
integer :: prc, n_prc
type(cascade_t), pointer :: cascade
logical :: ok
n1 = 0
n2 = 0
n_prc = size (flv)
do prc = 1, n_prc
allocate (cascade)
call cascade_init_incoming &
(cascade, flv(prc), pos, cascade_set%m_threshold_t)
call cascade_set_add (cascade_set, cascade, ok)
if (ok) then
if (n1 == 0) n1 = cascade%index
n2 = cascade%index
if (.not. associated (cascade_set%first_t)) then
cascade_set%first_t => cascade
end if
else
deallocate (cascade)
end if
end do
end subroutine cascade_set_add_incoming1
subroutine cascade_set_add_incoming0 (cascade_set, n1, n2, pos, flv)
type(cascade_set_t), intent(inout), target :: cascade_set
integer, intent(out) :: n1, n2
integer, intent(in) :: pos
type(flavor_t), intent(in) :: flv
type(cascade_t), pointer :: cascade
logical :: ok
n1 = 0
n2 = 0
allocate (cascade)
call cascade_init_incoming &
(cascade, flv, pos, cascade_set%m_threshold_t)
call cascade_set_add (cascade_set, cascade, ok)
if (ok) then
if (n1 == 0) n1 = cascade%index
n2 = cascade%index
if (.not. associated (cascade_set%first_t)) then
cascade_set%first_t => cascade
end if
else
deallocate (cascade)
end if
end subroutine cascade_set_add_incoming0
@ %def cascade_set_add_incoming
@
\subsection{Cascade combination I: flavor assignment}
We have two disjunct cascades, now use the vertex table to determine
the possible flavors of the combination cascade. For each
possibility, try to generate a new cascade. The total cascade depth
has to be one less than the limit, because this is reached by setting
the keystone.
<<Cascades: procedures>>=
subroutine cascade_match_pair (cascade_set, cascade1, cascade2, s_channel)
type(cascade_set_t), intent(inout), target :: cascade_set
type(cascade_t), intent(in), target :: cascade1, cascade2
logical, intent(in) :: s_channel
integer, dimension(:), allocatable :: pdg3
integer :: i, depth_max
type(flavor_t) :: flv
if (s_channel) then
depth_max = cascade_set%depth_out
else
depth_max = cascade_set%depth_tot
end if
if (cascade1%depth + cascade2%depth < depth_max) then
call cascade_set%model%match_vertex ( &
cascade1%flv%get_pdg (), &
cascade2%flv%get_pdg (), &
pdg3)
do i = 1, size (pdg3)
call flv%init (pdg3(i), cascade_set%model)
if (s_channel) then
call cascade_combine_s (cascade_set, cascade1, cascade2, flv)
else
call cascade_combine_t (cascade_set, cascade1, cascade2, flv)
end if
end do
deallocate (pdg3)
end if
end subroutine cascade_match_pair
@ %def cascade_match_pair
@ The triplet version takes a third cascade, and we check whether this
triplet has a matching vertex in the database. If yes, we make a
keystone cascade.
<<Cascades: procedures>>=
subroutine cascade_match_triplet &
(cascade_set, cascade1, cascade2, cascade3, s_channel)
type(cascade_set_t), intent(inout), target :: cascade_set
type(cascade_t), intent(in), target :: cascade1, cascade2, cascade3
logical, intent(in) :: s_channel
integer :: depth_max
depth_max = cascade_set%depth_tot
if (cascade1%depth + cascade2%depth + cascade3%depth == depth_max) then
if (cascade_set%model%check_vertex ( &
cascade1%flv%get_pdg (), &
cascade2%flv%get_pdg (), &
cascade3%flv%get_pdg ())) then
call cascade_combine_keystone &
(cascade_set, cascade1, cascade2, cascade3, s_channel)
end if
end if
end subroutine cascade_match_triplet
@ %def cascade_match_triplet
@
\subsection{Cascade combination II: kinematics setup and check}
Having three matching flavors, we start constructing the combination
cascade. We look at the mass hierarchies and determine whether the
cascade is to be kept. In passing we set mapping modes, resonance
properties and such.
If successful, the cascade is finalized. For a resonant cascade, we
prepare in addition a copy without the resonance.
<<Cascades: procedures>>=
subroutine cascade_combine_s (cascade_set, cascade1, cascade2, flv)
type(cascade_set_t), intent(inout), target :: cascade_set
type(cascade_t), intent(in), target :: cascade1, cascade2
type(flavor_t), intent(in) :: flv
type(cascade_t), pointer :: cascade3, cascade4
logical :: keep
keep = .false.
allocate (cascade3)
call cascade_init (cascade3, cascade1%depth + cascade2%depth + 1)
cascade3%bincode = ior (cascade1%bincode, cascade2%bincode)
cascade3%flv = flv%anti ()
cascade3%pdg = cascade3%flv%get_pdg ()
cascade3%is_vector = flv%get_spin_type () == VECTOR
cascade3%m_min = cascade1%m_min + cascade2%m_min
cascade3%m_rea = flv%get_mass ()
if (cascade3%m_rea > cascade_set%m_threshold_s) then
cascade3%m_eff = cascade3%m_rea
end if
! Potentially resonant cases [sqrts = m_rea for on-shell decay]
if (cascade3%m_rea > cascade3%m_min &
.and. cascade3%m_rea <= cascade_set%sqrts) then
if (flv%get_width () /= 0) then
if (cascade1%on_shell .or. cascade2%on_shell) then
keep = .true.
cascade3%mapping = S_CHANNEL
cascade3%resonant = .true.
end if
else
call warn_decay (flv)
end if
! Collinear and IR singular cases
else if (cascade3%m_rea < cascade_set%sqrts) then
! Massless splitting
if (cascade1%m_eff == 0 .and. cascade2%m_eff == 0 &
.and. cascade3%depth <= 3) then
keep = .true.
cascade3%log_enhanced = .true.
if (cascade3%is_vector) then
if (cascade1%is_vector .and. cascade2%is_vector) then
cascade3%mapping = COLLINEAR ! three-vector-vertex
else
cascade3%mapping = INFRARED ! vector splitting into matter
end if
else
if (cascade1%is_vector .or. cascade2%is_vector) then
cascade3%mapping = COLLINEAR ! vector radiation off matter
else
cascade3%mapping = INFRARED ! scalar radiation/splitting
end if
end if
! IR radiation off massive particle
else if (cascade3%m_eff > 0 .and. cascade1%m_eff > 0 &
.and. cascade2%m_eff == 0 &
.and. (cascade1%on_shell .or. cascade1%mapping == RADIATION) &
.and. abs (cascade3%m_eff - cascade1%m_eff) &
< cascade_set%m_threshold_s) &
then
keep = .true.
cascade3%log_enhanced = .true.
cascade3%mapping = RADIATION
else if (cascade3%m_eff > 0 .and. cascade2%m_eff > 0 &
.and. cascade1%m_eff == 0 &
.and. (cascade2%on_shell .or. cascade2%mapping == RADIATION) &
.and. abs (cascade3%m_eff - cascade2%m_eff) &
< cascade_set%m_threshold_s) &
then
keep = .true.
cascade3%log_enhanced = .true.
cascade3%mapping = RADIATION
end if
end if
! Non-singular cases, including failed resonances
if (.not. keep) then
! Two on-shell particles from a virtual mother
if (cascade1%on_shell .or. cascade2%on_shell) then
keep = .true.
cascade3%m_eff = max (cascade3%m_min, &
cascade1%m_eff + cascade2%m_eff)
if (cascade3%m_eff < cascade_set%m_threshold_s) then
cascade3%m_eff = 0
end if
end if
end if
! Complete and register the cascade (two in case of resonance)
if (keep) then
cascade3%on_shell = cascade3%resonant .or. cascade3%log_enhanced
if (cascade3%resonant) then
cascade3%pdg = cascade3%flv%get_pdg ()
if (cascade_set%keep_nonresonant) then
allocate (cascade4)
cascade4 = cascade3
cascade4%index = cascade_index ()
cascade4%pdg = UNDEFINED
cascade4%mapping = NO_MAPPING
cascade4%resonant = .false.
cascade4%on_shell = .false.
end if
cascade3%m_min = cascade3%m_rea
call cascade_fusion (cascade_set, cascade1, cascade2, cascade3)
if (cascade_set%keep_nonresonant) then
call cascade_fusion (cascade_set, cascade1, cascade2, cascade4)
end if
else
call cascade_fusion (cascade_set, cascade1, cascade2, cascade3)
end if
else
deallocate (cascade3)
end if
contains
subroutine warn_decay (flv)
type(flavor_t), intent(in) :: flv
integer :: i
integer, dimension(MAX_WARN_RESONANCE), save :: warned_code = 0
LOOP_WARNED: do i = 1, MAX_WARN_RESONANCE
if (warned_code(i) == 0) then
warned_code(i) = flv%get_pdg ()
write (msg_buffer, "(A)") &
& " Intermediate decay of zero-width particle " &
& // char (flv%get_name ()) &
& // " may be possible."
call msg_warning
exit LOOP_WARNED
else if (warned_code(i) == flv%get_pdg ()) then
exit LOOP_WARNED
end if
end do LOOP_WARNED
end subroutine warn_decay
end subroutine cascade_combine_s
@ %def cascade_combine_s
<<Cascades: parameters>>=
integer, parameter, public :: MAX_WARN_RESONANCE = 50
@ %def MAX_WARN_RESONANCE
@ This is the t-channel version. [[cascade1]] is t-channel and
contains the seed, [[cascade2]] is s-channel. We check for
kinematically allowed beam decay (which is a fatal error), or massless
splitting / soft radiation. The cascade is kept in all remaining
cases and submitted for registration.
<<Cascades: procedures>>=
subroutine cascade_combine_t (cascade_set, cascade1, cascade2, flv)
type(cascade_set_t), intent(inout), target :: cascade_set
type(cascade_t), intent(in), target :: cascade1, cascade2
type(flavor_t), intent(in) :: flv
type(cascade_t), pointer :: cascade3
allocate (cascade3)
call cascade_init (cascade3, cascade1%depth + cascade2%depth + 1)
cascade3%bincode = ior (cascade1%bincode, cascade2%bincode)
cascade3%flv = flv%anti ()
cascade3%pdg = abs (cascade3%flv%get_pdg ())
cascade3%is_vector = flv%get_spin_type () == VECTOR
if (cascade1%incoming) then
cascade3%m_min = cascade2%m_min
else
cascade3%m_min = cascade1%m_min + cascade2%m_min
end if
cascade3%m_rea = flv%get_mass ()
if (cascade3%m_rea > cascade_set%m_threshold_t) then
cascade3%m_eff = max (cascade3%m_rea, cascade2%m_eff)
else if (cascade2%m_eff > cascade_set%m_threshold_t) then
cascade3%m_eff = cascade2%m_eff
else
cascade3%m_eff = 0
end if
! Allowed decay of beam particle
if (cascade1%incoming &
.and. cascade1%m_rea > cascade2%m_rea + cascade3%m_rea) then
call beam_decay (cascade_set%fatal_beam_decay)
! Massless splitting
else if (cascade1%m_eff == 0 &
.and. cascade2%m_eff < cascade_set%m_threshold_t &
.and. cascade3%m_eff == 0) then
cascade3%mapping = U_CHANNEL
cascade3%log_enhanced = .true.
! IR radiation off massive particle
else if (cascade1%m_eff /= 0 .and. cascade2%m_eff == 0 &
.and. cascade3%m_eff /= 0 &
.and. (cascade1%on_shell .or. cascade1%mapping == RADIATION) &
.and. abs (cascade1%m_eff - cascade3%m_eff) &
< cascade_set%m_threshold_t) &
then
cascade3%pdg = flv%get_pdg ()
cascade3%log_enhanced = .true.
cascade3%mapping = RADIATION
end if
cascade3%t_channel = .true.
call cascade_fusion (cascade_set, cascade1, cascade2, cascade3)
contains
subroutine beam_decay (fatal_beam_decay)
logical, intent(in) :: fatal_beam_decay
write (msg_buffer, "(1x,A,1x,'->',1x,A,1x,A)") &
char (cascade1%flv%get_name ()), &
char (cascade3%flv%get_name ()), &
char (cascade2%flv%get_name ())
call msg_message
write (msg_buffer, "(1x,'mass(',A,') =',1x,E17.10)") &
char (cascade1%flv%get_name ()), cascade1%m_rea
call msg_message
write (msg_buffer, "(1x,'mass(',A,') =',1x,E17.10)") &
char (cascade3%flv%get_name ()), cascade3%m_rea
call msg_message
write (msg_buffer, "(1x,'mass(',A,') =',1x,E17.10)") &
char (cascade2%flv%get_name ()), cascade2%m_rea
call msg_message
if (fatal_beam_decay) then
call msg_fatal (" Phase space: Initial beam particle can decay")
else
call msg_warning (" Phase space: Initial beam particle can decay")
end if
end subroutine beam_decay
end subroutine cascade_combine_t
@ %def cascade_combine_t
@ Here we complete a decay cascade. The third input is the
single-particle cascade for the initial particle. There is no
resonance or mapping assignment. The only condition for keeping the
cascade is the mass sum of the final state, which must be less than
the available energy.
Two modifications are necessary for scattering cascades: a pure
s-channel diagram (cascade1 is the incoming particle) do not have a
logarithmic mapping at top-level. And in a t-channel diagram, the
last line exchanged is mapped t-channel, not u-channel. Finally, we
can encounter the case of a $2\to 1$ process, where cascade1 is
incoming, and cascade2 is the outgoing particle. In all three cases
we register a new cascade with the modified mapping.
<<Cascades: procedures>>=
subroutine cascade_combine_keystone &
(cascade_set, cascade1, cascade2, cascade3, s_channel)
type(cascade_set_t), intent(inout), target :: cascade_set
type(cascade_t), intent(in), target :: cascade1, cascade2, cascade3
logical, intent(in) :: s_channel
type(cascade_t), pointer :: cascade4, cascade0
logical :: keep, ok
keep = .false.
allocate (cascade4)
call cascade_init &
(cascade4, cascade1%depth + cascade2%depth + cascade3%depth)
cascade4%complete = .true.
if (s_channel) then
cascade4%bincode = ior (cascade1%bincode, cascade2%bincode)
else
cascade4%bincode = cascade3%bincode
end if
cascade4%flv = cascade3%flv
cascade4%pdg = cascade3%pdg
cascade4%mapping = EXTERNAL_PRT
cascade4%is_vector = cascade3%is_vector
cascade4%m_min = cascade1%m_min + cascade2%m_min
cascade4%m_rea = cascade3%m_rea
cascade4%m_eff = cascade3%m_rea
if (cascade4%m_min < cascade_set%sqrts) then
keep = .true.
end if
if (keep) then
if (cascade1%incoming .and. cascade2%log_enhanced) then
allocate (cascade0)
cascade0 = cascade2
cascade0%next => null ()
cascade0%index = cascade_index ()
cascade0%mapping = NO_MAPPING
cascade0%log_enhanced = .false.
cascade0%n_log_enhanced = cascade0%n_log_enhanced - 1
cascade0%tree_mapping(cascade0%depth) = NO_MAPPING
call cascade_keystone &
(cascade_set, cascade1, cascade0, cascade3, cascade4, ok)
if (ok) then
call cascade_set_add (cascade_set, cascade0, ok)
else
deallocate (cascade0)
end if
else if (cascade1%t_channel .and. cascade1%mapping == U_CHANNEL) then
allocate (cascade0)
cascade0 = cascade1
cascade0%next => null ()
cascade0%index = cascade_index ()
cascade0%mapping = T_CHANNEL
cascade0%tree_mapping(cascade0%depth) = T_CHANNEL
call cascade_keystone &
(cascade_set, cascade0, cascade2, cascade3, cascade4, ok)
if (ok) then
call cascade_set_add (cascade_set, cascade0, ok)
else
deallocate (cascade0)
end if
else if (cascade1%incoming .and. cascade2%depth == 1) then
allocate (cascade0)
cascade0 = cascade2
cascade0%next => null ()
cascade0%index = cascade_index ()
cascade0%mapping = ON_SHELL
cascade0%tree_mapping(cascade0%depth) = ON_SHELL
call cascade_keystone &
(cascade_set, cascade1, cascade0, cascade3, cascade4, ok)
if (ok) then
call cascade_set_add (cascade_set, cascade0, ok)
else
deallocate (cascade0)
end if
else
call cascade_keystone &
(cascade_set, cascade1, cascade2, cascade3, cascade4, ok)
end if
else
deallocate (cascade4)
end if
end subroutine cascade_combine_keystone
@ %def cascade_combine_keystone
@
\subsection{Cascade combination III: node connections and tree fusion}
Here we assign global tree properties. If the allowed number of
off-shell lines is exceeded, discard the new cascade. Otherwise,
assign the trees, sort them, and assign connections. Finally, append
the cascade to the list. This may fail (because in the hash array
there is already an equivalent cascade). On failure, discard the
cascade.
<<Cascades: procedures>>=
subroutine cascade_fusion (cascade_set, cascade1, cascade2, cascade3)
type(cascade_set_t), intent(inout), target :: cascade_set
type(cascade_t), intent(in), target :: cascade1, cascade2
type(cascade_t), pointer :: cascade3
integer :: i1, i2, i3, i4
logical :: ok
cascade3%internal = (cascade3%depth - 3) / 2
if (cascade3%resonant) then
cascade3%multiplicity = 1
cascade3%n_resonances = &
cascade1%n_resonances + cascade2%n_resonances + 1
else
cascade3%multiplicity = cascade1%multiplicity + cascade2%multiplicity
cascade3%n_resonances = cascade1%n_resonances + cascade2%n_resonances
end if
if (cascade3%log_enhanced) then
cascade3%n_log_enhanced = &
cascade1%n_log_enhanced + cascade2%n_log_enhanced + 1
else
cascade3%n_log_enhanced = &
cascade1%n_log_enhanced + cascade2%n_log_enhanced
end if
if (cascade3%resonant) then
cascade3%n_off_shell = 0
else if (cascade3%log_enhanced) then
cascade3%n_off_shell = cascade1%n_off_shell + cascade2%n_off_shell
else
cascade3%n_off_shell = cascade1%n_off_shell + cascade2%n_off_shell + 1
end if
if (cascade3%t_channel) then
cascade3%n_t_channel = cascade1%n_t_channel + 1
end if
if (cascade3%n_off_shell > cascade_set%off_shell) then
deallocate (cascade3)
else if (cascade3%n_t_channel > cascade_set%t_channel) then
deallocate (cascade3)
else
i1 = cascade1%depth
i2 = i1 + 1
i3 = i1 + cascade2%depth
i4 = cascade3%depth
cascade3%tree(:i1) = cascade1%tree
where (cascade1%tree_mapping > NO_MAPPING)
cascade3%tree_pdg(:i1) = cascade1%tree_pdg
elsewhere
cascade3%tree_pdg(:i1) = UNDEFINED
end where
cascade3%tree_mapping(:i1) = cascade1%tree_mapping
cascade3%tree_resonant(:i1) = cascade1%tree_resonant
cascade3%tree(i2:i3) = cascade2%tree
where (cascade2%tree_mapping > NO_MAPPING)
cascade3%tree_pdg(i2:i3) = cascade2%tree_pdg
elsewhere
cascade3%tree_pdg(i2:i3) = UNDEFINED
end where
cascade3%tree_mapping(i2:i3) = cascade2%tree_mapping
cascade3%tree_resonant(i2:i3) = cascade2%tree_resonant
cascade3%tree(i4) = cascade3%bincode
cascade3%tree_pdg(i4) = cascade3%pdg
cascade3%tree_mapping(i4) = cascade3%mapping
cascade3%tree_resonant(i4) = cascade3%resonant
call tree_sort (cascade3%tree, &
cascade3%tree_pdg, cascade3%tree_mapping, cascade3%tree_resonant)
cascade3%has_children = .true.
cascade3%daughter1 => cascade1
cascade3%daughter2 => cascade2
call cascade_set_add (cascade_set, cascade3, ok)
if (.not. ok) deallocate (cascade3)
end if
end subroutine cascade_fusion
@ %def cascade_fusion
@ Here we combine a cascade pair with an incoming particle, i.e., we
set a keystone. Otherwise, this is similar. On the first
opportunity, we set the [[first_k]] pointer in the cascade set.
<<Cascades: procedures>>=
subroutine cascade_keystone &
(cascade_set, cascade1, cascade2, cascade3, cascade4, ok)
type(cascade_set_t), intent(inout), target :: cascade_set
type(cascade_t), intent(in), target :: cascade1, cascade2, cascade3
type(cascade_t), pointer :: cascade4
logical, intent(out) :: ok
integer :: i1, i2, i3, i4
cascade4%internal = (cascade4%depth - 3) / 2
cascade4%multiplicity = cascade1%multiplicity + cascade2%multiplicity
cascade4%n_resonances = cascade1%n_resonances + cascade2%n_resonances
cascade4%n_off_shell = cascade1%n_off_shell + cascade2%n_off_shell
cascade4%n_log_enhanced = &
cascade1%n_log_enhanced + cascade2%n_log_enhanced
cascade4%n_t_channel = cascade1%n_t_channel + cascade2%n_t_channel
if (cascade4%n_off_shell > cascade_set%off_shell) then
deallocate (cascade4)
ok = .false.
else if (cascade4%n_t_channel > cascade_set%t_channel) then
deallocate (cascade4)
ok = .false.
else
i1 = cascade1%depth
i2 = i1 + 1
i3 = i1 + cascade2%depth
i4 = cascade4%depth
cascade4%tree(:i1) = cascade1%tree
where (cascade1%tree_mapping > NO_MAPPING)
cascade4%tree_pdg(:i1) = cascade1%tree_pdg
elsewhere
cascade4%tree_pdg(:i1) = UNDEFINED
end where
cascade4%tree_mapping(:i1) = cascade1%tree_mapping
cascade4%tree_resonant(:i1) = cascade1%tree_resonant
cascade4%tree(i2:i3) = cascade2%tree
where (cascade2%tree_mapping > NO_MAPPING)
cascade4%tree_pdg(i2:i3) = cascade2%tree_pdg
elsewhere
cascade4%tree_pdg(i2:i3) = UNDEFINED
end where
cascade4%tree_mapping(i2:i3) = cascade2%tree_mapping
cascade4%tree_resonant(i2:i3) = cascade2%tree_resonant
cascade4%tree(i4) = cascade4%bincode
cascade4%tree_pdg(i4) = UNDEFINED
cascade4%tree_mapping(i4) = cascade4%mapping
cascade4%tree_resonant(i4) = .false.
call tree_sort (cascade4%tree, &
cascade4%tree_pdg, cascade4%tree_mapping, cascade4%tree_resonant)
cascade4%has_children = .true.
cascade4%daughter1 => cascade1
cascade4%daughter2 => cascade2
cascade4%mother => cascade3
call cascade_set_add (cascade_set, cascade4, ok)
if (ok) then
if (.not. associated (cascade_set%first_k)) then
cascade_set%first_k => cascade4
end if
else
deallocate (cascade4)
end if
end if
end subroutine cascade_keystone
@ %def cascade_keystone
@
Sort a tree (array of binary codes) and particle code array
simultaneously, by ascending binary codes. A convenient method is to
use the [[maxloc]] function iteratively, to find and remove the
largest entry in the tree array one by one.
<<Cascades: procedures>>=
subroutine tree_sort (tree, pdg, mapping, resonant)
integer(TC), dimension(:), intent(inout) :: tree
integer, dimension(:), intent(inout) :: pdg, mapping
logical, dimension(:), intent(inout) :: resonant
integer(TC), dimension(size(tree)) :: tree_tmp
integer, dimension(size(pdg)) :: pdg_tmp, mapping_tmp
logical, dimension(size(resonant)) :: resonant_tmp
integer, dimension(1) :: pos
integer :: i
tree_tmp = tree
pdg_tmp = pdg
mapping_tmp = mapping
resonant_tmp = resonant
do i = size(tree),1,-1
pos = maxloc (tree_tmp)
tree(i) = tree_tmp (pos(1))
pdg(i) = pdg_tmp (pos(1))
mapping(i) = mapping_tmp (pos(1))
resonant(i) = resonant_tmp (pos(1))
tree_tmp(pos(1)) = 0
end do
end subroutine tree_sort
@ %def tree_sort
@
\subsection{Cascade set generation}
These procedures loop over cascades and build up the cascade set. After each
iteration of the innermost loop, we set a breakpoint.
s-channel: We use a nested scan to combine all cascades with all other
cascades.
<<Cascades: procedures>>=
subroutine cascade_set_generate_s (cascade_set)
type(cascade_set_t), intent(inout), target :: cascade_set
type(cascade_t), pointer :: cascade1, cascade2
cascade1 => cascade_set%first
LOOP1: do while (associated (cascade1))
cascade2 => cascade_set%first
LOOP2: do while (associated (cascade2))
if (cascade2%index >= cascade1%index) exit LOOP2
if (cascade1 .disjunct. cascade2) then
call cascade_match_pair (cascade_set, cascade1, cascade2, .true.)
end if
call terminate_now_if_signal ()
cascade2 => cascade2%next
end do LOOP2
cascade1 => cascade1%next
end do LOOP1
end subroutine cascade_set_generate_s
@ %def cascade_set_generate_s
@ The t-channel cascades are directed and have a seed (one of the
incoming particles) and a target (the other one). We loop over all
possible seeds and targets. Inside this, we loop over all t-channel
cascades ([[cascade1]]) and s-channel cascades ([[cascade2]]) and try
to combine them.
<<Cascades: procedures>>=
subroutine cascade_set_generate_t (cascade_set, pos_seed, pos_target)
type(cascade_set_t), intent(inout), target :: cascade_set
integer, intent(in) :: pos_seed, pos_target
type(cascade_t), pointer :: cascade_seed, cascade_target
type(cascade_t), pointer :: cascade1, cascade2
integer(TC) :: bc_seed, bc_target
bc_seed = ibset (0_TC, pos_seed-1)
bc_target = ibset (0_TC, pos_target-1)
cascade_seed => cascade_set%first_t
LOOP_SEED: do while (associated (cascade_seed))
if (cascade_seed%bincode == bc_seed) then
cascade_target => cascade_set%first_t
LOOP_TARGET: do while (associated (cascade_target))
if (cascade_target%bincode == bc_target) then
cascade1 => cascade_set%first_t
LOOP_T: do while (associated (cascade1))
if ((cascade1 .disjunct. cascade_target) &
.and. .not. (cascade1 .disjunct. cascade_seed)) then
cascade2 => cascade_set%first
LOOP_S: do while (associated (cascade2))
if ((cascade2 .disjunct. cascade_target) &
.and. (cascade2 .disjunct. cascade1)) then
call cascade_match_pair &
(cascade_set, cascade1, cascade2, .false.)
end if
call terminate_now_if_signal ()
cascade2 => cascade2%next
end do LOOP_S
end if
call terminate_now_if_signal ()
cascade1 => cascade1%next
end do LOOP_T
end if
call terminate_now_if_signal ()
cascade_target => cascade_target%next
end do LOOP_TARGET
end if
call terminate_now_if_signal ()
cascade_seed => cascade_seed%next
end do LOOP_SEED
end subroutine cascade_set_generate_t
@ %def cascade_set_generate_t
@ This part completes the phase space for decay processes. It is
similar to s-channel cascade generation, but combines two cascade with
the particular cascade of the incoming particle. This particular
cascade is expected to be pointed at by [[first_t]].
<<Cascades: procedures>>=
subroutine cascade_set_generate_decay (cascade_set)
type(cascade_set_t), intent(inout), target :: cascade_set
type(cascade_t), pointer :: cascade1, cascade2
type(cascade_t), pointer :: cascade_in
cascade_in => cascade_set%first_t
cascade1 => cascade_set%first
do while (associated (cascade1))
if (cascade1 .disjunct. cascade_in) then
cascade2 => cascade1%next
do while (associated (cascade2))
if ((cascade2 .disjunct. cascade1) &
.and. (cascade2 .disjunct. cascade_in)) then
call cascade_match_triplet (cascade_set, &
cascade1, cascade2, cascade_in, .true.)
end if
call terminate_now_if_signal ()
cascade2 => cascade2%next
end do
end if
call terminate_now_if_signal ()
cascade1 => cascade1%next
end do
end subroutine cascade_set_generate_decay
@ %def cascade_set_generate_decay
@ This part completes the phase space for scattering processes. We
combine a t-channel cascade (containing the seed) with a s-channel
cascade and the target.
<<Cascades: procedures>>=
subroutine cascade_set_generate_scattering &
(cascade_set, ns1, ns2, nt1, nt2, pos_seed, pos_target)
type(cascade_set_t), intent(inout), target :: cascade_set
integer, intent(in) :: pos_seed, pos_target
integer, intent(in) :: ns1, ns2, nt1, nt2
type(cascade_t), pointer :: cascade_seed, cascade_target
type(cascade_t), pointer :: cascade1, cascade2
integer(TC) :: bc_seed, bc_target
bc_seed = ibset (0_TC, pos_seed-1)
bc_target = ibset (0_TC, pos_target-1)
cascade_seed => cascade_set%first_t
LOOP_SEED: do while (associated (cascade_seed))
if (cascade_seed%index < ns1) then
cascade_seed => cascade_seed%next
cycle LOOP_SEED
else if (cascade_seed%index > ns2) then
exit LOOP_SEED
else if (cascade_seed%bincode == bc_seed) then
cascade_target => cascade_set%first_t
LOOP_TARGET: do while (associated (cascade_target))
if (cascade_target%index < nt1) then
cascade_target => cascade_target%next
cycle LOOP_TARGET
else if (cascade_target%index > nt2) then
exit LOOP_TARGET
else if (cascade_target%bincode == bc_target) then
cascade1 => cascade_set%first_t
LOOP_T: do while (associated (cascade1))
if ((cascade1 .disjunct. cascade_target) &
.and. .not. (cascade1 .disjunct. cascade_seed)) then
cascade2 => cascade_set%first
LOOP_S: do while (associated (cascade2))
if ((cascade2 .disjunct. cascade_target) &
.and. (cascade2 .disjunct. cascade1)) then
call cascade_match_triplet (cascade_set, &
cascade1, cascade2, cascade_target, .false.)
end if
call terminate_now_if_signal ()
cascade2 => cascade2%next
end do LOOP_S
end if
call terminate_now_if_signal ()
cascade1 => cascade1%next
end do LOOP_T
end if
call terminate_now_if_signal ()
cascade_target => cascade_target%next
end do LOOP_TARGET
end if
call terminate_now_if_signal ()
cascade_seed => cascade_seed%next
end do LOOP_SEED
end subroutine cascade_set_generate_scattering
@ %def cascade_set_generate_scattering
@
\subsection{Groves}
Before assigning groves, assign hashcodes to the resonance patterns, so they
can easily be compared.
<<Cascades: procedures>>=
subroutine cascade_set_assign_resonance_hash (cascade_set)
type(cascade_set_t), intent(inout) :: cascade_set
type(cascade_t), pointer :: cascade
cascade => cascade_set%first_k
do while (associated (cascade))
call cascade_assign_resonance_hash (cascade)
cascade => cascade%next
end do
end subroutine cascade_set_assign_resonance_hash
@ %def cascade_assign_resonance_hash
@ After all cascades are recorded, we group the complete cascades in
groves. A grove consists of cascades with identical multiplicity,
number of resonances, log-enhanced, t-channel lines, and resonance flavors.
<<Cascades: procedures>>=
subroutine cascade_set_assign_groves (cascade_set)
type(cascade_set_t), intent(inout), target :: cascade_set
type(cascade_t), pointer :: cascade1, cascade2
integer :: multiplicity
integer :: n_resonances, n_log_enhanced, n_t_channel, n_off_shell
integer :: res_hash
integer :: grove
grove = 0
cascade1 => cascade_set%first_k
do while (associated (cascade1))
if (cascade1%active .and. cascade1%complete &
.and. cascade1%grove == 0) then
grove = grove + 1
cascade1%grove = grove
multiplicity = cascade1%multiplicity
n_resonances = cascade1%n_resonances
n_log_enhanced = cascade1%n_log_enhanced
n_off_shell = cascade1%n_off_shell
n_t_channel = cascade1%n_t_channel
res_hash = cascade1%res_hash
cascade2 => cascade1%next
do while (associated (cascade2))
if (cascade2%grove == 0) then
if (cascade2%multiplicity == multiplicity &
.and. cascade2%n_resonances == n_resonances &
.and. cascade2%n_log_enhanced == n_log_enhanced &
.and. cascade2%n_off_shell == n_off_shell &
.and. cascade2%n_t_channel == n_t_channel &
.and. cascade2%res_hash == res_hash) then
cascade2%grove = grove
end if
end if
call terminate_now_if_signal ()
cascade2 => cascade2%next
end do
end if
call terminate_now_if_signal ()
cascade1 => cascade1%next
end do
cascade_set%n_groves = grove
end subroutine cascade_set_assign_groves
@ %def cascade_set_assign_groves
@
\subsection{Generate the phase space file}
Generate a complete phase space configuration.
For each flavor assignment: First, all s-channel
graphs that can be built up from the outgoing particles. Then we
distinguish (1) decay, where we complete the s-channel graphs by
connecting to the input line, and (2) scattering, where we now
generate t-channel graphs by introducing an incoming particle, and
complete this by connecting to the other incoming particle.
After all cascade sets have been generated, merge them into a common set.
This eliminates redunancies between flavor assignments.
<<Cascades: public>>=
public :: cascade_set_generate
<<Cascades: procedures>>=
subroutine cascade_set_generate &
(cascade_set, model, n_in, n_out, flv, phs_par, fatal_beam_decay)
type(cascade_set_t), intent(out) :: cascade_set
class(model_data_t), intent(in), target :: model
integer, intent(in) :: n_in, n_out
type(flavor_t), dimension(:,:), intent(in) :: flv
type(phs_parameters_t), intent(in) :: phs_par
logical, intent(in) :: fatal_beam_decay
type(cascade_set_t), dimension(:), allocatable :: cset
type(cascade_t), pointer :: cascade
integer :: i
if (phase_space_vanishes (phs_par%sqrts, n_in, flv)) return
call cascade_set_init (cascade_set, model, n_in, n_out, phs_par, &
fatal_beam_decay, flv)
allocate (cset (size (flv, 2)))
do i = 1, size (cset)
call cascade_set_generate_single (cset(i), &
model, n_in, n_out, flv(:,i), phs_par, fatal_beam_decay)
cascade => cset(i)%first_k
do while (associated (cascade))
if (cascade%active .and. cascade%complete) then
call cascade_set_add_copy (cascade_set, cascade)
end if
cascade => cascade%next
end do
call cascade_set_final (cset(i))
end do
cascade_set%first_k => cascade_set%first
call cascade_set_assign_resonance_hash (cascade_set)
call cascade_set_assign_groves (cascade_set)
end subroutine cascade_set_generate
@ %def cascade_set_generate
@ This generates phase space for a single channel, without assigning groves.
<<Cascades: procedures>>=
subroutine cascade_set_generate_single (cascade_set, &
model, n_in, n_out, flv, phs_par, fatal_beam_decay)
type(cascade_set_t), intent(out) :: cascade_set
class(model_data_t), intent(in), target :: model
integer, intent(in) :: n_in, n_out
type(flavor_t), dimension(:), intent(in) :: flv
type(phs_parameters_t), intent(in) :: phs_par
logical, intent(in) :: fatal_beam_decay
integer :: n11, n12, n21, n22
call cascade_set_init (cascade_set, model, n_in, n_out, phs_par, &
fatal_beam_decay)
call cascade_set_add_outgoing (cascade_set, flv(n_in+1:))
call cascade_set_generate_s (cascade_set)
select case (n_in)
case(1)
call cascade_set_add_incoming &
(cascade_set, n11, n12, n_out + 1, flv(1))
call cascade_set_generate_decay (cascade_set)
case(2)
call cascade_set_add_incoming &
(cascade_set, n11, n12, n_out + 1, flv(2))
call cascade_set_add_incoming &
(cascade_set, n21, n22, n_out + 2, flv(1))
call cascade_set_generate_t (cascade_set, n_out + 1, n_out + 2)
call cascade_set_generate_t (cascade_set, n_out + 2, n_out + 1)
call cascade_set_generate_scattering &
(cascade_set, n11, n12, n21, n22, n_out + 1, n_out + 2)
call cascade_set_generate_scattering &
(cascade_set, n21, n22, n11, n12, n_out + 2, n_out + 1)
end select
end subroutine cascade_set_generate_single
@ %def cascade_set_generate_single
@ Sanity check: Before anything else is done, check if there could
possibly be any phase space.
<<Cascades: public>>=
public :: phase_space_vanishes
<<Cascades: procedures>>=
function phase_space_vanishes (sqrts, n_in, flv) result (flag)
logical :: flag
real(default), intent(in) :: sqrts
integer, intent(in) :: n_in
type(flavor_t), dimension(:,:), intent(in) :: flv
real(default), dimension(:,:), allocatable :: mass
real(default), dimension(:), allocatable :: mass_in, mass_out
integer :: n_prt, n_flv, i, j
flag = .false.
if (sqrts <= 0) then
call msg_error ("Phase space vanishes (sqrts must be positive)")
flag = .true.; return
end if
n_prt = size (flv, 1)
n_flv = size (flv, 2)
allocate (mass (n_prt, n_flv), mass_in (n_flv), mass_out (n_flv))
mass = flv%get_mass ()
mass_in = sum (mass(:n_in,:), 1)
mass_out = sum (mass(n_in+1:,:), 1)
if (any (mass_in > sqrts)) then
call msg_error ("Mass sum of incoming particles " &
// "is more than available energy")
flag = .true.; return
end if
if (any (mass_out > sqrts)) then
call msg_error ("Mass sum of outgoing particles " &
// "is more than available energy")
flag = .true.; return
end if
end function phase_space_vanishes
@ %def phase_space_vanishes
@
\subsection{Return the resonance histories for subtraction}
This appears to be essential (re-export of some imported assignment?)!
<<Cascades: public>>=
public :: assignment(=)
@
Extract the resonance set from a complete cascade.
<<Cascades: cascade: TBP>>=
procedure :: extract_resonance_history => cascade_extract_resonance_history
<<Cascades: procedures>>=
subroutine cascade_extract_resonance_history &
(cascade, res_hist, model, n_out)
class(cascade_t), intent(in), target :: cascade
type(resonance_history_t), intent(out) :: res_hist
class(model_data_t), intent(in), target :: model
integer, intent(in) :: n_out
type(resonance_info_t) :: resonance
integer :: i, mom_id, pdg
if (debug_on) call msg_debug2 (D_PHASESPACE, "cascade_extract_resonance_history")
if (cascade%n_resonances > 0) then
if (cascade%has_children) then
if (debug_on) call msg_debug2 (D_PHASESPACE, "cascade has resonances and children")
do i = 1, size(cascade%tree_resonant)
if (cascade%tree_resonant (i)) then
mom_id = cascade%tree (i)
pdg = cascade%tree_pdg (i)
call resonance%init (mom_id, pdg, model, n_out)
if (debug2_active (D_PHASESPACE)) then
print *, 'D: Adding resonance'
call resonance%write ()
end if
call res_hist%add_resonance (resonance)
end if
end do
end if
end if
end subroutine cascade_extract_resonance_history
@ %def cascade_extract_resonance_history
@
<<Cascades: public>>=
public :: cascade_set_get_n_trees
<<Cascades: procedures>>=
function cascade_set_get_n_trees (cascade_set) result (n)
type(cascade_set_t), intent(in), target :: cascade_set
integer :: n
type(cascade_t), pointer :: cascade
integer :: grove
if (debug_on) call msg_debug (D_PHASESPACE, "cascade_set_get_n_trees")
n = 0
do grove = 1, cascade_set%n_groves
cascade => cascade_set%first_k
do while (associated (cascade))
if (cascade%active .and. cascade%complete) then
if (cascade%grove == grove) then
n = n + 1
end if
end if
cascade => cascade%next
end do
end do
if (debug_on) call msg_debug (D_PHASESPACE, "n", n)
end function cascade_set_get_n_trees
@ %def cascade_set_get_n_trees
@ Distill the set of resonance histories from the cascade set. The
result is an array which contains each valid history exactly once.
<<Cascades: public>>=
public :: cascade_set_get_resonance_histories
<<Cascades: procedures>>=
subroutine cascade_set_get_resonance_histories (cascade_set, n_filter, res_hists)
type(cascade_set_t), intent(in), target :: cascade_set
integer, intent(in), optional :: n_filter
type(resonance_history_t), dimension(:), allocatable, intent(out) :: res_hists
type(resonance_history_t), dimension(:), allocatable :: tmp
type(cascade_t), pointer :: cascade
type(resonance_history_t) :: res_hist
type(resonance_history_set_t) :: res_hist_set
integer :: grove, i, n_hists
logical :: included, add_to_list
if (debug_on) call msg_debug (D_PHASESPACE, "cascade_set_get_resonance_histories")
call res_hist_set%init (n_filter = n_filter)
do grove = 1, cascade_set%n_groves
cascade => cascade_set%first_k
do while (associated (cascade))
if (cascade%active .and. cascade%complete) then
if (cascade%grove == grove) then
if (debug_on) call msg_debug2 (D_PHASESPACE, "grove", grove)
call cascade%extract_resonance_history &
(res_hist, cascade_set%model, cascade_set%n_out)
call res_hist_set%enter (res_hist)
end if
end if
cascade => cascade%next
end do
end do
call res_hist_set%freeze ()
call res_hist_set%to_array (res_hists)
end subroutine cascade_set_get_resonance_histories
@ %def cascade_set_get_resonance_histories
@
\subsection{Unit tests}
Test module, followed by the corresponding implementation module.
<<[[cascades_ut.f90]]>>=
<<File header>>
module cascades_ut
use unit_tests
use cascades_uti
<<Standard module head>>
<<Cascades: public test>>
contains
<<Cascades: test driver>>
end module cascades_ut
@ %def cascades_ut
@
<<[[cascades_uti.f90]]>>=
<<File header>>
module cascades_uti
<<Use kinds>>
<<Use strings>>
use numeric_utils
use flavors
use model_data
use phs_forests, only: phs_parameters_t
use resonances, only: resonance_history_t
use cascades
<<Standard module head>>
<<Cascades: test declarations>>
contains
<<Cascades: tests>>
end module cascades_uti
@ %def cascades_ut
@ API: driver for the unit tests below.
<<Cascades: public test>>=
public :: cascades_test
<<Cascades: test driver>>=
subroutine cascades_test (u, results)
integer, intent(in) :: u
type(test_results_t), intent(inout) :: results
<<Cascades: execute tests>>
end subroutine cascades_test
@ %def cascades_test
\subsubsection{Check cascade setup}
@ Checking the basic setup up of the phase space cascade parameterizations.
<<Cascades: execute tests>>=
call test (cascades_1, "cascades_1", &
"check cascade setup", &
u, results)
<<Cascades: test declarations>>=
public :: cascades_1
<<Cascades: tests>>=
subroutine cascades_1 (u)
integer, intent(in) :: u
type(model_data_t), target :: model
type(flavor_t), dimension(5,2) :: flv
type(cascade_set_t) :: cascade_set
type(phs_parameters_t) :: phs_par
write (u, "(A)") "* Test output: cascades_1"
write (u, "(A)") "* Purpose: test cascade phase space functions"
write (u, "(A)")
write (u, "(A)") "* Initializing"
write (u, "(A)")
call model%init_sm_test ()
call flv(1,1)%init ( 2, model)
call flv(2,1)%init (-2, model)
call flv(3,1)%init ( 1, model)
call flv(4,1)%init (-1, model)
call flv(5,1)%init (21, model)
call flv(1,2)%init ( 2, model)
call flv(2,2)%init (-2, model)
call flv(3,2)%init ( 2, model)
call flv(4,2)%init (-2, model)
call flv(5,2)%init (21, model)
phs_par%sqrts = 1000._default
phs_par%off_shell = 2
write (u, "(A)")
write (u, "(A)") "* Generating the cascades"
write (u, "(A)")
call cascade_set_generate (cascade_set, model, 2, 3, flv, phs_par,.true.)
call cascade_set_write (cascade_set, u)
call cascade_set_write_file_format (cascade_set, u)
write (u, "(A)") "* Cleanup"
write (u, "(A)")
call cascade_set_final (cascade_set)
call model%final ()
write (u, *)
write (u, "(A)") "* Test output end: cascades_1"
end subroutine cascades_1
@ %def cascades_1
@
\subsubsection{Check resonance history}
<<Cascades: execute tests>>=
call test(cascades_2, "cascades_2", &
"Check resonance history", u, results)
<<Cascades: test declarations>>=
public :: cascades_2
<<Cascades: tests>>=
subroutine cascades_2 (u)
integer, intent(in) :: u
type(model_data_t), target :: model
type(flavor_t), dimension(5,1) :: flv
type(cascade_set_t) :: cascade_set
type(phs_parameters_t) :: phs_par
type(resonance_history_t), dimension(:), allocatable :: res_hists
integer :: n, i
write (u, "(A)") "* Test output: cascades_2"
write (u, "(A)") "* Purpose: Check resonance history"
write (u, "(A)")
write (u, "(A)") "* Initializing"
write (u, "(A)")
call model%init_sm_test ()
call flv(1,1)%init ( 2, model)
call flv(2,1)%init (-2, model)
call flv(3,1)%init ( 1, model)
call flv(4,1)%init (-1, model)
call flv(5,1)%init (22, model)
phs_par%sqrts = 1000._default
phs_par%off_shell = 2
write (u, "(A)")
write (u, "(A)") "* Generating the cascades"
write (u, "(A)")
call cascade_set_generate (cascade_set, model, 2, 3, flv, phs_par,.true.)
call cascade_set_get_resonance_histories (cascade_set, res_hists = res_hists)
n = cascade_set_get_n_trees (cascade_set)
call assert_equal (u, n, 24, "Number of trees")
do i = 1, size(res_hists)
call res_hists(i)%write (u)
write (u, "(A)")
end do
write (u, "(A)") "* Cleanup"
write (u, "(A)")
call cascade_set_final (cascade_set)
call model%final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: cascades_2"
end subroutine cascades_2
@ %def cascades_2
@
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{WOOD phase space}
This is the module that interfaces the [[phs_forests]] phase-space
treatment and the [[cascades]] module for generating phase-space
channels. As an extension of the [[phs_base]] abstract type,
the phase-space configuration and instance implement the standard API.
(Currently, this is the only generic phase-space implementation of
\whizard. For trivial two-particle phase space, there is
[[phs_wood]] as an alternative.)
<<[[phs_wood.f90]]>>=
<<File header>>
module phs_wood
<<Use kinds>>
<<Use strings>>
use io_units
use constants
use numeric_utils
use diagnostics
use os_interface
use md5
use physics_defs
use lorentz
use model_data
use flavors
use process_constants
use sf_mappings
use sf_base
use phs_base
use mappings
use resonances, only: resonance_history_set_t
use phs_forests
use cascades
use cascades2
<<Standard module head>>
<<PHS wood: public>>
<<PHS wood: types>>
contains
<<PHS wood: procedures>>
end module phs_wood
@ %def phs_wood
@
\subsection{Configuration}
<<PHS wood: public>>=
public :: phs_wood_config_t
<<PHS wood: types>>=
type, extends (phs_config_t) :: phs_wood_config_t
character(32) :: md5sum_forest = ""
type(string_t) :: phs_path
integer :: io_unit = 0
logical :: io_unit_keep_open = .false.
logical :: use_equivalences = .false.
logical :: fatal_beam_decay = .true.
type(mapping_defaults_t) :: mapping_defaults
type(phs_parameters_t) :: par
type(string_t) :: run_id
type(cascade_set_t), allocatable :: cascade_set
logical :: use_cascades2 = .false.
type(feyngraph_set_t), allocatable :: feyngraph_set
type(phs_forest_t) :: forest
type(os_data_t) :: os_data
logical :: is_combined_integration = .false.
contains
<<PHS wood: phs wood config: TBP>>
end type phs_wood_config_t
@ %def phs_wood_config_t
@ Finalizer. We should delete the cascade set and the forest subobject.
Also close the I/O unit, just in case. (We assume that [[io_unit]] is
not standard input/output.)
<<PHS wood: phs wood config: TBP>>=
procedure :: final => phs_wood_config_final
<<PHS wood: procedures>>=
subroutine phs_wood_config_final (object)
class(phs_wood_config_t), intent(inout) :: object
logical :: opened
if (object%io_unit /= 0) then
inquire (unit = object%io_unit, opened = opened)
if (opened) close (object%io_unit)
end if
call object%clear_phase_space ()
call phs_forest_final (object%forest)
end subroutine phs_wood_config_final
@ %def phs_wood_config_final
@
<<PHS wood: phs wood config: TBP>>=
procedure :: increase_n_par => phs_wood_config_increase_n_par
<<PHS wood: procedures>>=
subroutine phs_wood_config_increase_n_par (phs_config)
class(phs_wood_config_t), intent(inout) :: phs_config
if (phs_config%is_combined_integration) then
phs_config%n_par = phs_config%n_par + 3
end if
end subroutine phs_wood_config_increase_n_par
@ %def phs_wood_config_increase_n_par
@ Output. The contents of the PHS forest are not printed explicitly.
<<PHS wood: phs wood config: TBP>>=
procedure :: write => phs_wood_config_write
<<PHS wood: procedures>>=
subroutine phs_wood_config_write (object, unit, include_id)
class(phs_wood_config_t), intent(in) :: object
integer, intent(in), optional :: unit
logical, intent(in), optional :: include_id
integer :: u
u = given_output_unit (unit)
write (u, "(1x,A)") &
"Partonic phase-space configuration (phase-space forest):"
call object%base_write (unit)
write (u, "(1x,A)") "Phase-space configuration parameters:"
call object%par%write (u)
call object%mapping_defaults%write (u)
write (u, "(3x,A,A,A)") "Run ID: '", char (object%run_id), "'"
end subroutine phs_wood_config_write
@ %def phs_wood_config_write
@ Print the PHS forest contents.
<<PHS wood: phs wood config: TBP>>=
procedure :: write_forest => phs_wood_config_write_forest
<<PHS wood: procedures>>=
subroutine phs_wood_config_write_forest (object, unit)
class(phs_wood_config_t), intent(in) :: object
integer, intent(in), optional :: unit
integer :: u
u = given_output_unit (unit)
call phs_forest_write (object%forest, u)
end subroutine phs_wood_config_write_forest
@ %def phs_wood_config_write_forest
@ Set the phase-space parameters that the configuration generator requests.
<<PHS wood: phs wood config: TBP>>=
procedure :: set_parameters => phs_wood_config_set_parameters
<<PHS wood: procedures>>=
subroutine phs_wood_config_set_parameters (phs_config, par)
class(phs_wood_config_t), intent(inout) :: phs_config
type(phs_parameters_t), intent(in) :: par
phs_config%par = par
end subroutine phs_wood_config_set_parameters
@ %def phs_wood_config_set_parameters
@ Enable the generation of channel equivalences (when calling [[configure]]).
<<PHS wood: phs wood config: TBP>>=
procedure :: enable_equivalences => phs_wood_config_enable_equivalences
<<PHS wood: procedures>>=
subroutine phs_wood_config_enable_equivalences (phs_config)
class(phs_wood_config_t), intent(inout) :: phs_config
phs_config%use_equivalences = .true.
end subroutine phs_wood_config_enable_equivalences
@ %def phs_wood_config_enable_equivalences
@ Set the phase-space mapping parameters that the configuration generator
requests.g
<<PHS wood: phs wood config: TBP>>=
procedure :: set_mapping_defaults => phs_wood_config_set_mapping_defaults
<<PHS wood: procedures>>=
subroutine phs_wood_config_set_mapping_defaults (phs_config, mapping_defaults)
class(phs_wood_config_t), intent(inout) :: phs_config
type(mapping_defaults_t), intent(in) :: mapping_defaults
phs_config%mapping_defaults = mapping_defaults
end subroutine phs_wood_config_set_mapping_defaults
@ %def phs_wood_config_set_mapping_defaults
@ Define the input stream for the phase-space file as an open logical unit.
The unit must be connected.
<<PHS wood: phs wood config: TBP>>=
procedure :: set_input => phs_wood_config_set_input
<<PHS wood: procedures>>=
subroutine phs_wood_config_set_input (phs_config, unit)
class(phs_wood_config_t), intent(inout) :: phs_config
integer, intent(in) :: unit
phs_config%io_unit = unit
rewind (unit)
end subroutine phs_wood_config_set_input
@ %def phs_wood_config_set_input
@
\subsection{Phase-space generation}
This subroutine generates a phase space configuration using the
[[cascades]] module. Note that this may take time, and the
[[cascade_set]] subobject may consume a large amount of memory.
<<PHS wood: phs wood config: TBP>>=
procedure :: generate_phase_space => phs_wood_config_generate_phase_space
<<PHS wood: procedures>>=
subroutine phs_wood_config_generate_phase_space (phs_config)
class(phs_wood_config_t), intent(inout) :: phs_config
integer :: off_shell, extra_off_shell
logical :: valid
integer :: unit_fds
type(string_t) :: file_name
logical :: file_exists
call msg_message ("Phase space: generating configuration ...")
off_shell = phs_config%par%off_shell
if (phs_config%use_cascades2) then
file_name = char (phs_config%id) // ".fds"
inquire (file=char (file_name), exist=file_exists)
if (.not. file_exists) call msg_fatal &
("The O'Mega input file " // char (file_name) // &
" does not exist. " // "Please make sure that the " // &
"variable ?omega_write_phs_output has been set correctly.")
unit_fds = free_unit ()
open (unit=unit_fds, file=char(file_name), status='old', action='read')
do extra_off_shell = 0, max (phs_config%n_tot - 3, 0)
phs_config%par%off_shell = off_shell + extra_off_shell
allocate (phs_config%feyngraph_set)
call feyngraph_set_generate (phs_config%feyngraph_set, &
phs_config%model, phs_config%n_in, phs_config%n_out, &
phs_config%flv, &
phs_config%par, phs_config%fatal_beam_decay, unit_fds, &
phs_config%vis_channels)
if (feyngraph_set_is_valid (phs_config%feyngraph_set)) then
exit
else
call msg_message ("Phase space: ... failed. &
&Increasing phs_off_shell ...")
call phs_config%feyngraph_set%final ()
deallocate (phs_config%feyngraph_set)
end if
end do
close (unit_fds)
else
allocate (phs_config%cascade_set)
do extra_off_shell = 0, max (phs_config%n_tot - 3, 0)
phs_config%par%off_shell = off_shell + extra_off_shell
call cascade_set_generate (phs_config%cascade_set, &
phs_config%model, phs_config%n_in, phs_config%n_out, &
phs_config%flv, &
phs_config%par, phs_config%fatal_beam_decay)
if (cascade_set_is_valid (phs_config%cascade_set)) then
exit
else
call msg_message ("Phase space: ... failed. &
&Increasing phs_off_shell ...")
end if
end do
end if
if (phs_config%use_cascades2) then
valid = feyngraph_set_is_valid (phs_config%feyngraph_set)
else
valid = cascade_set_is_valid (phs_config%cascade_set)
end if
if (valid) then
call msg_message ("Phase space: ... success.")
else
call msg_fatal ("Phase-space: generation failed")
end if
end subroutine phs_wood_config_generate_phase_space
@ %def phs_wood_config_generate_phase_space
@ Using the generated phase-space configuration, write an appropriate
phase-space file to the stored (or explicitly specified) I/O unit.
<<PHS wood: phs wood config: TBP>>=
procedure :: write_phase_space => phs_wood_config_write_phase_space
<<PHS wood: procedures>>=
subroutine phs_wood_config_write_phase_space (phs_config, &
filename_vis, unit)
class(phs_wood_config_t), intent(in) :: phs_config
integer, intent(in), optional :: unit
type(string_t), intent(in), optional :: filename_vis
type(string_t) :: setenv_tex, setenv_mp, pipe, pipe_dvi
integer :: u, unit_tex, unit_dev, status
if (allocated (phs_config%cascade_set) .or. allocated (phs_config%feyngraph_set)) then
if (present (unit)) then
u = unit
else
u = phs_config%io_unit
end if
write (u, "(1x,A,A)") "process ", char (phs_config%id)
write (u, "(A)")
if (phs_config%use_cascades2) then
call feyngraph_set_write_process_bincode_format (phs_config%feyngraph_set, u)
else
call cascade_set_write_process_bincode_format (phs_config%cascade_set, u)
end if
write (u, "(A)")
write (u, "(3x,A,A,A32,A)") "md5sum_process = ", &
'"', phs_config%md5sum_process, '"'
write (u, "(3x,A,A,A32,A)") "md5sum_model_par = ", &
'"', phs_config%md5sum_model_par, '"'
write (u, "(3x,A,A,A32,A)") "md5sum_phs_config = ", &
'"', phs_config%md5sum_phs_config, '"'
call phs_config%par%write (u)
if (phs_config%use_cascades2) then
call feyngraph_set_write_file_format (phs_config%feyngraph_set, u)
else
call cascade_set_write_file_format (phs_config%cascade_set, u)
end if
if (phs_config%vis_channels) then
unit_tex = free_unit ()
open (unit=unit_tex, file=char(filename_vis // ".tex"), &
action="write", status="replace")
if (phs_config%use_cascades2) then
call feyngraph_set_write_graph_format (phs_config%feyngraph_set, &
filename_vis // "-graphs", phs_config%id, unit_tex)
else
call cascade_set_write_graph_format (phs_config%cascade_set, &
filename_vis // "-graphs", phs_config%id, unit_tex)
end if
close (unit_tex)
call msg_message ("Phase space: visualizing channels in file " &
// char(trim(filename_vis)) // "...")
if (phs_config%os_data%event_analysis_ps) then
BLOCK: do
unit_dev = free_unit ()
open (file = "/dev/null", unit = unit_dev, &
action = "write", iostat = status)
if (status /= 0) then
pipe = ""
pipe_dvi = ""
else
pipe = " > /dev/null"
pipe_dvi = " 2>/dev/null 1>/dev/null"
end if
close (unit_dev)
if (phs_config%os_data%whizard_texpath /= "") then
setenv_tex = "TEXINPUTS=" // &
phs_config%os_data%whizard_texpath // ":$TEXINPUTS "
setenv_mp = "MPINPUTS=" // &
phs_config%os_data%whizard_texpath // ":$MPINPUTS "
else
setenv_tex = ""
setenv_mp = ""
end if
call os_system_call (setenv_tex // &
phs_config%os_data%latex // " " // &
filename_vis // ".tex " // pipe, status)
if (status /= 0) exit BLOCK
if (phs_config%os_data%mpost /= "") then
call os_system_call (setenv_mp // &
phs_config%os_data%mpost // " " // &
filename_vis // "-graphs.mp" // pipe, status)
else
call msg_fatal ("Could not use MetaPOST.")
end if
if (status /= 0) exit BLOCK
call os_system_call (setenv_tex // &
phs_config%os_data%latex // " " // &
filename_vis // ".tex" // pipe, status)
if (status /= 0) exit BLOCK
call os_system_call &
(phs_config%os_data%dvips // " -o " // filename_vis &
// ".ps " // filename_vis // ".dvi" // pipe_dvi, status)
if (status /= 0) exit BLOCK
if (phs_config%os_data%event_analysis_pdf) then
call os_system_call (phs_config%os_data%ps2pdf // " " // &
filename_vis // ".ps", status)
if (status /= 0) exit BLOCK
end if
exit BLOCK
end do BLOCK
if (status /= 0) then
call msg_error ("Unable to compile analysis output file")
end if
end if
end if
else
call msg_fatal ("Phase-space configuration: &
&no phase space object generated")
end if
end subroutine phs_wood_config_write_phase_space
@ %def phs_config_write_phase_space
@ Clear the phase-space configuration. This is useful since the
object may become \emph{really} large.
<<PHS wood: phs wood config: TBP>>=
procedure :: clear_phase_space => phs_wood_config_clear_phase_space
<<PHS wood: procedures>>=
subroutine phs_wood_config_clear_phase_space (phs_config)
class(phs_wood_config_t), intent(inout) :: phs_config
if (allocated (phs_config%cascade_set)) then
call cascade_set_final (phs_config%cascade_set)
deallocate (phs_config%cascade_set)
end if
if (allocated (phs_config%feyngraph_set)) then
call phs_config%feyngraph_set%final ()
deallocate (phs_config%feyngraph_set)
end if
end subroutine phs_wood_config_clear_phase_space
@ %def phs_wood_config_clear_phase_space
@
Extract the set of resonance histories
<<PHS wood: phs wood config: TBP>>=
procedure :: extract_resonance_history_set &
=> phs_wood_config_extract_resonance_history_set
<<PHS wood: procedures>>=
subroutine phs_wood_config_extract_resonance_history_set &
(phs_config, res_set, include_trivial)
class(phs_wood_config_t), intent(in) :: phs_config
type(resonance_history_set_t), intent(out) :: res_set
logical, intent(in), optional :: include_trivial
call phs_config%forest%extract_resonance_history_set &
(res_set, include_trivial)
end subroutine phs_wood_config_extract_resonance_history_set
@ %def phs_wood_config_extract_resonance_history_set
@
\subsection{Phase-space configuration}
We read the phase-space configuration from the stored I/O unit. If
this is not set, we assume that we have to generate a phase space
configuration. When done, we open a scratch file and write the
configuration.
If [[rebuild]] is set, we should trash any existing phase space file
and build a new one. Otherwise, we try to use an old one, which we
check for existence and integrity. If [[ignore_mismatch]] is set, we
reuse an existing file even if it does not match the current setup.
<<PHS wood: phs wood config: TBP>>=
procedure :: configure => phs_wood_config_configure
<<PHS wood: procedures>>=
subroutine phs_wood_config_configure (phs_config, sqrts, &
sqrts_fixed, lab_is_cm, azimuthal_dependence, rebuild, ignore_mismatch, &
nlo_type, subdir)
class(phs_wood_config_t), intent(inout) :: phs_config
real(default), intent(in) :: sqrts
logical, intent(in), optional :: sqrts_fixed
logical, intent(in), optional :: lab_is_cm
logical, intent(in), optional :: azimuthal_dependence
logical, intent(in), optional :: rebuild
logical, intent(in), optional :: ignore_mismatch
integer, intent(in), optional :: nlo_type
type(string_t), intent(in), optional :: subdir
type(string_t) :: filename, filename_vis
logical :: variable_limits
logical :: ok, exist, found, check, match, rebuild_phs
integer :: g, c0, c1, n
if (present (nlo_type)) then
phs_config%nlo_type = nlo_type
else
phs_config%nlo_type = BORN
end if
phs_config%sqrts = sqrts
phs_config%par%sqrts = sqrts
if (present (sqrts_fixed)) &
phs_config%sqrts_fixed = sqrts_fixed
if (present (lab_is_cm)) &
phs_config%lab_is_cm = lab_is_cm
if (present (azimuthal_dependence)) &
phs_config%azimuthal_dependence = azimuthal_dependence
if (present (rebuild)) then
rebuild_phs = rebuild
else
rebuild_phs = .true.
end if
if (present (ignore_mismatch)) then
check = .not. ignore_mismatch
if (ignore_mismatch) &
call msg_warning ("Reading phs file: MD5 sum check disabled")
else
check = .true.
end if
phs_config%md5sum_forest = ""
call phs_config%compute_md5sum (include_id = .false.)
if (phs_config%io_unit == 0) then
filename = phs_config%make_phs_filename (subdir)
filename_vis = phs_config%make_phs_filename (subdir) // "-vis"
if (.not. rebuild_phs) then
if (check) then
call phs_config%read_phs_file (exist, found, match, subdir=subdir)
rebuild_phs = .not. (exist .and. found .and. match)
else
call phs_config%read_phs_file (exist, found, subdir=subdir)
rebuild_phs = .not. (exist .and. found)
end if
end if
if (.not. mpi_is_comm_master ()) then
rebuild_phs = .false.
call msg_message ("MPI: Workers do not build phase space configuration.")
end if
if (rebuild_phs) then
call phs_config%generate_phase_space ()
phs_config%io_unit = free_unit ()
if (phs_config%id /= "") then
call msg_message ("Phase space: writing configuration file '" &
// char (filename) // "'")
open (phs_config%io_unit, file = char (filename), &
status = "replace", action = "readwrite")
else
open (phs_config%io_unit, status = "scratch", action = "readwrite")
end if
call phs_config%write_phase_space (filename_vis)
rewind (phs_config%io_unit)
else
call msg_message ("Phase space: keeping configuration file '" &
// char (filename) // "'")
end if
end if
if (phs_config%io_unit == 0) then
ok = .true.
else
call phs_forest_read (phs_config%forest, phs_config%io_unit, &
phs_config%id, phs_config%n_in, phs_config%n_out, &
phs_config%model, ok)
if (.not. phs_config%io_unit_keep_open) then
close (phs_config%io_unit)
phs_config%io_unit = 0
end if
end if
if (ok) then
call phs_forest_set_flavors (phs_config%forest, phs_config%flv(:,1))
variable_limits = .not. phs_config%lab_is_cm
call phs_forest_set_parameters &
(phs_config%forest, phs_config%mapping_defaults, variable_limits)
call phs_forest_setup_prt_combinations (phs_config%forest)
phs_config%n_channel = phs_forest_get_n_channels (phs_config%forest)
phs_config%n_par = phs_forest_get_n_parameters (phs_config%forest)
allocate (phs_config%channel (phs_config%n_channel))
if (phs_config%use_equivalences) then
call phs_forest_set_equivalences (phs_config%forest)
call phs_forest_get_equivalences (phs_config%forest, &
phs_config%channel, phs_config%azimuthal_dependence)
phs_config%provides_equivalences = .true.
end if
call phs_forest_set_s_mappings (phs_config%forest)
call phs_config%record_on_shell ()
if (phs_config%mapping_defaults%enable_s_mapping) then
call phs_config%record_s_mappings ()
end if
allocate (phs_config%chain (phs_config%n_channel), source = 0)
do g = 1, phs_forest_get_n_groves (phs_config%forest)
call phs_forest_get_grove_bounds (phs_config%forest, g, c0, c1, n)
phs_config%chain (c0:c1) = g
end do
phs_config%provides_chains = .true.
call phs_config%compute_md5sum_forest ()
else
write (msg_buffer, "(A,A,A)") &
"Phase space: process '", &
char (phs_config%id), "' not found in configuration file"
call msg_fatal ()
end if
end subroutine phs_wood_config_configure
@ %def phs_wood_config_configure
@ The MD5 sum of the forest is computed in addition to the MD5 sum of
the configuration. The reason is that the forest may depend on a
user-provided external file. On the other hand, this MD5 sum encodes
all information that is relevant for further processing. Therefore,
the [[get_md5sum]] method returns this result, once it is available.
<<PHS wood: phs wood config: TBP>>=
procedure :: compute_md5sum_forest => phs_wood_config_compute_md5sum_forest
<<PHS wood: procedures>>=
subroutine phs_wood_config_compute_md5sum_forest (phs_config)
class(phs_wood_config_t), intent(inout) :: phs_config
integer :: u
u = free_unit ()
open (u, status = "scratch", action = "readwrite")
call phs_config%write_forest (u)
rewind (u)
phs_config%md5sum_forest = md5sum (u)
close (u)
end subroutine phs_wood_config_compute_md5sum_forest
@ %def phs_wood_config_compute_md5sum_forest
@ Create filenames according to standard conventions. The [[id]] is the
process name including the suffix [[_iX]] where [[X]] stands for the component
identifier (an integer). The [[run_id]] may be set or unset.
The convention for file names that include the run ID is to separate prefix, run
ID, and any extensions by dots. We construct the file name by concatenating
the individual elements accordingly. If there is no run ID, we nevertheless
replace [[_iX]] by [[.iX]].
<<PHS wood: phs wood config: TBP>>=
procedure :: make_phs_filename => phs_wood_make_phs_filename
<<PHS wood: procedures>>=
function phs_wood_make_phs_filename (phs_config, subdir) result (filename)
class(phs_wood_config_t), intent(in) :: phs_config
type(string_t), intent(in), optional :: subdir
type(string_t) :: filename
type(string_t) :: basename, suffix, comp_code, comp_index
basename = phs_config%id
call split (basename, suffix, "_", back=.true.)
comp_code = extract (suffix, 1, 1)
comp_index = extract (suffix, 2)
if (comp_code == "i" .and. verify (comp_index, "1234567890") == 0) then
suffix = "." // comp_code // comp_index
else
basename = phs_config%id
suffix = ""
end if
if (phs_config%run_id /= "") then
filename = basename // "." // phs_config%run_id // suffix // ".phs"
else
filename = basename // suffix // ".phs"
end if
if (present (subdir)) then
filename = subdir // "/" // filename
end if
end function phs_wood_make_phs_filename
@ %def phs_wood_make_phs_filename
@
<<PHS wood: phs wood config: TBP>>=
procedure :: reshuffle_flavors => phs_wood_config_reshuffle_flavors
<<PHS wood: procedures>>=
subroutine phs_wood_config_reshuffle_flavors (phs_config, reshuffle, flv_extra)
class(phs_wood_config_t), intent(inout) :: phs_config
integer, intent(in), dimension(:), allocatable :: reshuffle
type(flavor_t), intent(in) :: flv_extra
call phs_forest_set_flavors (phs_config%forest, phs_config%flv(:,1), reshuffle, flv_extra)
end subroutine phs_wood_config_reshuffle_flavors
@ %def phs_wood_config_reshuffle_flavors
@
<<PHS wood: phs wood config: TBP>>=
procedure :: set_momentum_links => phs_wood_config_set_momentum_links
<<PHS wood: procedures>>=
subroutine phs_wood_config_set_momentum_links (phs_config, reshuffle)
class(phs_wood_config_t), intent(inout) :: phs_config
integer, intent(in), dimension(:), allocatable :: reshuffle
call phs_forest_set_momentum_links (phs_config%forest, reshuffle)
end subroutine phs_wood_config_set_momentum_links
@ %def phs_wood_config_set_momentum_links
@ Identify resonances which are marked by s-channel mappings for the
whole phase space and report them to the channel array.
<<PHS wood: phs wood config: TBP>>=
procedure :: record_s_mappings => phs_wood_config_record_s_mappings
<<PHS wood: procedures>>=
subroutine phs_wood_config_record_s_mappings (phs_config)
class(phs_wood_config_t), intent(inout) :: phs_config
logical :: flag
real(default) :: mass, width
integer :: c
do c = 1, phs_config%n_channel
call phs_forest_get_s_mapping (phs_config%forest, c, flag, mass, width)
if (flag) then
if (mass == 0) then
call msg_fatal ("Phase space: s-channel resonance " &
// " has zero mass")
end if
if (width == 0) then
call msg_fatal ("Phase space: s-channel resonance " &
// " has zero width")
end if
call phs_config%channel(c)%set_resonant (mass, width)
end if
end do
end subroutine phs_wood_config_record_s_mappings
@ %def phs_wood_config_record_s_mappings
@ Identify on-shell mappings for the whole phase space and report them
to the channel array.
<<PHS wood: phs wood config: TBP>>=
procedure :: record_on_shell => phs_wood_config_record_on_shell
<<PHS wood: procedures>>=
subroutine phs_wood_config_record_on_shell (phs_config)
class(phs_wood_config_t), intent(inout) :: phs_config
logical :: flag
real(default) :: mass
integer :: c
do c = 1, phs_config%n_channel
call phs_forest_get_on_shell (phs_config%forest, c, flag, mass)
if (flag) then
call phs_config%channel(c)%set_on_shell (mass)
end if
end do
end subroutine phs_wood_config_record_on_shell
@ %def phs_wood_config_record_on_shell
@ Return the most relevant MD5 sum. This overrides the method of the
base type.
<<PHS wood: phs wood config: TBP>>=
procedure :: get_md5sum => phs_wood_config_get_md5sum
<<PHS wood: procedures>>=
function phs_wood_config_get_md5sum (phs_config) result (md5sum)
class(phs_wood_config_t), intent(in) :: phs_config
character(32) :: md5sum
if (phs_config%md5sum_forest /= "") then
md5sum = phs_config%md5sum_forest
else
md5sum = phs_config%md5sum_phs_config
end if
end function phs_wood_config_get_md5sum
@ %def phs_wood_config_get_md5sum
@ Check whether a phase-space configuration for the current process exists.
We look for the phase-space file that should correspond to the current
process. If we find it, we check the MD5 sums stored in the file against the
MD5 sums in the current configuration (if required).
If successful, read the PHS file.
<<PHS wood: phs wood config: TBP>>=
procedure :: read_phs_file => phs_wood_read_phs_file
<<PHS wood: procedures>>=
subroutine phs_wood_read_phs_file (phs_config, exist, found, match, subdir)
class(phs_wood_config_t), intent(inout) :: phs_config
logical, intent(out) :: exist
logical, intent(out) :: found
logical, intent(out), optional :: match
type(string_t), intent(in), optional :: subdir
type(string_t) :: filename
integer :: u
filename = phs_config%make_phs_filename (subdir)
inquire (file = char (filename), exist = exist)
if (exist) then
u = free_unit ()
open (u, file = char (filename), action = "read", status = "old")
call phs_forest_read (phs_config%forest, u, &
phs_config%id, phs_config%n_in, phs_config%n_out, &
phs_config%model, found, &
phs_config%md5sum_process, &
phs_config%md5sum_model_par, &
phs_config%md5sum_phs_config, &
match = match)
close (u)
else
found = .false.
if (present (match)) match = .false.
end if
end subroutine phs_wood_read_phs_file
@ %def phs_wood_read_phs_file
@ Startup message, after configuration is complete.
<<PHS wood: phs wood config: TBP>>=
procedure :: startup_message => phs_wood_config_startup_message
<<PHS wood: procedures>>=
subroutine phs_wood_config_startup_message (phs_config, unit)
class(phs_wood_config_t), intent(in) :: phs_config
integer, intent(in), optional :: unit
integer :: n_groves, n_eq
n_groves = phs_forest_get_n_groves (phs_config%forest)
n_eq = phs_forest_get_n_equivalences (phs_config%forest)
call phs_config%base_startup_message (unit)
if (phs_config%n_channel == 1) then
write (msg_buffer, "(A,2(I0,A))") &
"Phase space: found ", phs_config%n_channel, &
" channel, collected in ", n_groves, &
" grove."
else if (n_groves == 1) then
write (msg_buffer, "(A,2(I0,A))") &
"Phase space: found ", phs_config%n_channel, &
" channels, collected in ", n_groves, &
" grove."
else
write (msg_buffer, "(A,2(I0,A))") &
"Phase space: found ", phs_config%n_channel, &
" channels, collected in ", &
phs_forest_get_n_groves (phs_config%forest), &
" groves."
end if
call msg_message (unit = unit)
if (phs_config%use_equivalences) then
if (n_eq == 1) then
write (msg_buffer, "(A,I0,A)") &
"Phase space: Using ", n_eq, &
" equivalence between channels."
else
write (msg_buffer, "(A,I0,A)") &
"Phase space: Using ", n_eq, &
" equivalences between channels."
end if
else
write (msg_buffer, "(A)") &
"Phase space: no equivalences between channels used."
end if
call msg_message (unit = unit)
write (msg_buffer, "(A,2(1x,I0,1x,A))") &
"Phase space: wood"
call msg_message (unit = unit)
end subroutine phs_wood_config_startup_message
@ %def phs_wood_config_startup_message
@ Allocate an instance: the actual phase-space object.
<<PHS wood: phs wood config: TBP>>=
procedure, nopass :: allocate_instance => phs_wood_config_allocate_instance
<<PHS wood: procedures>>=
subroutine phs_wood_config_allocate_instance (phs)
class(phs_t), intent(inout), pointer :: phs
allocate (phs_wood_t :: phs)
end subroutine phs_wood_config_allocate_instance
@ %def phs_wood_config_allocate_instance
@
\subsection{Kinematics implementation}
We generate $\cos\theta$ and $\phi$ uniformly, covering the solid angle.
<<PHS wood: public>>=
public :: phs_wood_t
<<PHS wood: types>>=
type, extends (phs_t) :: phs_wood_t
real(default) :: sqrts = 0
type(phs_forest_t) :: forest
real(default), dimension(3) :: r_real
integer :: n_r_born = 0
contains
<<PHS wood: phs wood: TBP>>
end type phs_wood_t
@ %def phs_wood_t
@ Output. The [[verbose]] setting is irrelevant, we just display the contents
of the base object.
<<PHS wood: phs wood: TBP>>=
procedure :: write => phs_wood_write
<<PHS wood: procedures>>=
subroutine phs_wood_write (object, unit, verbose)
class(phs_wood_t), intent(in) :: object
integer, intent(in), optional :: unit
logical, intent(in), optional :: verbose
integer :: u
u = given_output_unit (unit)
call object%base_write (u)
end subroutine phs_wood_write
@ %def phs_wood_write
@ Write the forest separately.
<<PHS wood: phs wood: TBP>>=
procedure :: write_forest => phs_wood_write_forest
<<PHS wood: procedures>>=
subroutine phs_wood_write_forest (object, unit)
class(phs_wood_t), intent(in) :: object
integer, intent(in), optional :: unit
integer :: u
u = given_output_unit (unit)
call phs_forest_write (object%forest, u)
end subroutine phs_wood_write_forest
@ %def phs_wood_write_forest
@ Finalizer.
<<PHS wood: phs wood: TBP>>=
procedure :: final => phs_wood_final
<<PHS wood: procedures>>=
subroutine phs_wood_final (object)
class(phs_wood_t), intent(inout) :: object
call phs_forest_final (object%forest)
end subroutine phs_wood_final
@ %def phs_wood_final
@ Initialization. We allocate arrays ([[base_init]]) and adjust the
phase-space volume. The two-particle phase space volume is
\begin{equation}
\Phi_2 = \frac{1}{4(2\pi)^5} = 2.55294034614 \times 10^{-5}
\end{equation}
independent of the particle masses.
<<PHS wood: phs wood: TBP>>=
procedure :: init => phs_wood_init
<<PHS wood: procedures>>=
subroutine phs_wood_init (phs, phs_config)
class(phs_wood_t), intent(out) :: phs
class(phs_config_t), intent(in), target :: phs_config
call phs%base_init (phs_config)
select type (phs_config)
type is (phs_wood_config_t)
phs%forest = phs_config%forest
if (phs_config%is_combined_integration) then
phs%n_r_born = phs_config%n_par - 3
end if
end select
end subroutine phs_wood_init
@ %def phs_wood_init
@
\subsection{Evaluation}
We compute the outgoing momenta from the incoming momenta and
the input parameter set [[r_in]] in channel [[r_in]]. We also compute the
[[r]] parameters and Jacobians [[f]] for all other channels.
We do \emph{not} need to a apply a transformation from/to the c.m.\ frame,
because in [[phs_base]] the momenta are already boosted to the c.m.\ frame
before assigning them in the [[phs]] object, and inversely boosted when
extracting them.
<<PHS wood: phs wood: TBP>>=
procedure :: evaluate_selected_channel => phs_wood_evaluate_selected_channel
procedure :: evaluate_other_channels => phs_wood_evaluate_other_channels
<<PHS wood: procedures>>=
subroutine phs_wood_evaluate_selected_channel (phs, c_in, r_in)
class(phs_wood_t), intent(inout) :: phs
integer, intent(in) :: c_in
real(default), intent(in), dimension(:) :: r_in
logical :: ok
phs%q_defined = .false.
if (phs%p_defined) then
call phs_forest_set_prt_in (phs%forest, phs%p)
phs%r(:,c_in) = r_in
call phs_forest_evaluate_selected_channel (phs%forest, &
c_in, phs%active_channel, &
phs%sqrts_hat, phs%r, phs%f, phs%volume, ok)
select type (config => phs%config)
type is (phs_wood_config_t)
if (config%is_combined_integration) then
if (phs%n_r_born >= 0) then
phs%r_real = r_in (phs%n_r_born + 1 : phs%n_r_born + 3)
else
call msg_fatal ("n_r_born should be larger than 0!")
end if
end if
end select
if (ok) then
phs%q = phs_forest_get_momenta_out (phs%forest)
phs%q_defined = .true.
end if
end if
end subroutine phs_wood_evaluate_selected_channel
subroutine phs_wood_evaluate_other_channels (phs, c_in)
class(phs_wood_t), intent(inout) :: phs
integer, intent(in) :: c_in
integer :: c
if (phs%q_defined) then
call phs_forest_evaluate_other_channels (phs%forest, &
c_in, phs%active_channel, &
phs%sqrts_hat, phs%r, phs%f, combine=.true.)
select type (config => phs%config)
type is (phs_wood_config_t)
if (config%is_combined_integration) then
if (phs%n_r_born >= 0) then
do c = 1, size (phs%r, 2)
phs%r(phs%n_r_born + 1 : phs%n_r_born + 3, c) = phs%r_real
end do
else
phs%r_defined = .false.
end if
end if
end select
phs%r_defined = .true.
end if
end subroutine phs_wood_evaluate_other_channels
@ %def phs_wood_evaluate_selected_channel
@ %def phs_wood_evaluate_other_channels
@ Inverse evaluation.
<<PHS wood: phs wood: TBP>>=
procedure :: inverse => phs_wood_inverse
<<PHS wood: procedures>>=
subroutine phs_wood_inverse (phs)
class(phs_wood_t), intent(inout) :: phs
if (phs%p_defined .and. phs%q_defined) then
call phs_forest_set_prt_in (phs%forest, phs%p)
call phs_forest_set_prt_out (phs%forest, phs%q)
call phs_forest_recover_channel (phs%forest, &
1, &
phs%sqrts_hat, phs%r, phs%f, phs%volume)
call phs_forest_evaluate_other_channels (phs%forest, &
1, phs%active_channel, &
phs%sqrts_hat, phs%r, phs%f, combine=.false.)
phs%r_defined = .true.
end if
end subroutine phs_wood_inverse
@ %def phs_wood_inverse
@
\subsection{Unit tests}
Test module, followed by the corresponding implementation module.
<<[[phs_wood_ut.f90]]>>=
<<File header>>
module phs_wood_ut
use unit_tests
use phs_wood_uti
<<Standard module head>>
<<PHS wood: public test>>
<<PHS wood: public test auxiliary>>
contains
<<PHS wood: test driver>>
end module phs_wood_ut
@ %def phs_wood_ut
@
<<[[phs_wood_uti.f90]]>>=
<<File header>>
module phs_wood_uti
<<Use kinds>>
<<Use strings>>
use io_units
use os_interface
use lorentz
use flavors
use model_data
use process_constants
use mappings
use phs_base
use phs_forests
use phs_wood
use phs_base_ut, only: init_test_process_data, init_test_decay_data
<<Standard module head>>
<<PHS wood: public test auxiliary>>
<<PHS wood: test declarations>>
contains
<<PHS wood: tests>>
<<PHS wood: test auxiliary>>
end module phs_wood_uti
@ %def phs_wood_ut
@ API: driver for the unit tests below.
<<PHS wood: public test>>=
public :: phs_wood_test
<<PHS wood: test driver>>=
subroutine phs_wood_test (u, results)
integer, intent(in) :: u
type(test_results_t), intent(inout) :: results
<<PHS wood: execute tests>>
end subroutine phs_wood_test
@ %def phs_wood_test
<<PHS wood: public test>>=
public :: phs_wood_vis_test
<<PHS wood: test driver>>=
subroutine phs_wood_vis_test (u, results)
integer, intent(in) :: u
type(test_results_t), intent(inout) :: results
<<PHS wood: execute vis tests>>
end subroutine phs_wood_vis_test
@ %def phs_wood_vis_test
@
\subsubsection{Phase-space configuration data}
Construct and display a test phase-space configuration object. Also
check the [[azimuthal_dependence]] flag.
This auxiliary routine writes a phase-space configuration file to unit
[[u_phs]].
<<PHS wood: public test auxiliary>>=
public :: write_test_phs_file
<<PHS wood: test auxiliary>>=
subroutine write_test_phs_file (u_phs, procname)
integer, intent(in) :: u_phs
type(string_t), intent(in), optional :: procname
if (present (procname)) then
write (u_phs, "(A,A)") "process ", char (procname)
else
write (u_phs, "(A)") "process testproc"
end if
write (u_phs, "(A,A)") " md5sum_process = ", '""'
write (u_phs, "(A,A)") " md5sum_model_par = ", '""'
write (u_phs, "(A,A)") " md5sum_phs_config = ", '""'
write (u_phs, "(A)") " sqrts = 1000"
write (u_phs, "(A)") " m_threshold_s = 50"
write (u_phs, "(A)") " m_threshold_t = 100"
write (u_phs, "(A)") " off_shell = 2"
write (u_phs, "(A)") " t_channel = 6"
write (u_phs, "(A)") " keep_nonresonant = T"
write (u_phs, "(A)") " grove #1"
write (u_phs, "(A)") " tree 3"
end subroutine write_test_phs_file
@ %def write_test_phs_file
@
<<PHS wood: execute tests>>=
call test (phs_wood_1, "phs_wood_1", &
"phase-space configuration", &
u, results)
<<PHS wood: test declarations>>=
public :: phs_wood_1
<<PHS wood: tests>>=
subroutine phs_wood_1 (u)
integer, intent(in) :: u
type(model_data_t), target :: model
type(process_constants_t) :: process_data
class(phs_config_t), allocatable :: phs_data
type(mapping_defaults_t) :: mapping_defaults
real(default) :: sqrts
integer :: u_phs, iostat
character(32) :: buffer
write (u, "(A)") "* Test output: phs_wood_1"
write (u, "(A)") "* Purpose: initialize and display &
&phase-space configuration data"
write (u, "(A)")
call model%init_test ()
call syntax_phs_forest_init ()
write (u, "(A)") "* Initialize a process"
write (u, "(A)")
call init_test_process_data (var_str ("phs_wood_1"), process_data)
write (u, "(A)") "* Create a scratch phase-space file"
write (u, "(A)")
u_phs = free_unit ()
open (u_phs, status = "scratch", action = "readwrite")
call write_test_phs_file (u_phs, var_str ("phs_wood_1"))
rewind (u_phs)
do
read (u_phs, "(A)", iostat = iostat) buffer
if (iostat /= 0) exit
write (u, "(A)") trim (buffer)
end do
write (u, "(A)")
write (u, "(A)") "* Setup phase-space configuration object"
write (u, "(A)")
mapping_defaults%step_mapping = .false.
allocate (phs_wood_config_t :: phs_data)
call phs_data%init (process_data, model)
select type (phs_data)
type is (phs_wood_config_t)
call phs_data%set_input (u_phs)
call phs_data%set_mapping_defaults (mapping_defaults)
end select
sqrts = 1000._default
call phs_data%configure (sqrts)
call phs_data%write (u)
write (u, "(A)")
select type (phs_data)
type is (phs_wood_config_t)
call phs_data%write_forest (u)
end select
write (u, "(A)")
write (u, "(A)") "* Cleanup"
close (u_phs)
call phs_data%final ()
call model%final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: phs_wood_1"
end subroutine phs_wood_1
@ %def phs_wood_1
@
\subsubsection{Phase space evaluation}
Compute kinematics for given parameters, also invert the calculation.
<<PHS wood: execute tests>>=
call test (phs_wood_2, "phs_wood_2", &
"phase-space evaluation", &
u, results)
<<PHS wood: test declarations>>=
public :: phs_wood_2
<<PHS wood: tests>>=
subroutine phs_wood_2 (u)
integer, intent(in) :: u
type(model_data_t), target :: model
type(flavor_t) :: flv
type(process_constants_t) :: process_data
real(default) :: sqrts, E
class(phs_config_t), allocatable, target :: phs_data
class(phs_t), pointer :: phs => null ()
type(vector4_t), dimension(2) :: p, q
integer :: u_phs
write (u, "(A)") "* Test output: phs_wood_2"
write (u, "(A)") "* Purpose: test simple single-channel phase space"
write (u, "(A)")
call model%init_test ()
call flv%init (25, model)
write (u, "(A)") "* Initialize a process and a matching &
&phase-space configuration"
write (u, "(A)")
call init_test_process_data (var_str ("phs_wood_2"), process_data)
u_phs = free_unit ()
open (u_phs, status = "scratch", action = "readwrite")
call write_test_phs_file (u_phs, var_str ("phs_wood_2"))
rewind (u_phs)
allocate (phs_wood_config_t :: phs_data)
call phs_data%init (process_data, model)
select type (phs_data)
type is (phs_wood_config_t)
call phs_data%set_input (u_phs)
end select
sqrts = 1000._default
call phs_data%configure (sqrts)
call phs_data%write (u)
write (u, "(A)")
write (u, "(A)") "* Initialize the phase-space instance"
write (u, "(A)")
call phs_data%allocate_instance (phs)
call phs%init (phs_data)
call phs%write (u, verbose=.true.)
write (u, "(A)")
write (u, "(A)") "* Set incoming momenta"
write (u, "(A)")
E = sqrts / 2
p(1) = vector4_moving (E, sqrt (E**2 - flv%get_mass ()**2), 3)
p(2) = vector4_moving (E,-sqrt (E**2 - flv%get_mass ()**2), 3)
call phs%set_incoming_momenta (p)
call phs%compute_flux ()
call phs%write (u)
write (u, "(A)")
write (u, "(A)") "* Compute phase-space point &
&for x = 0.125, 0.5"
write (u, "(A)")
call phs%evaluate_selected_channel (1, [0.125_default, 0.5_default])
call phs%evaluate_other_channels (1)
call phs%write (u)
write (u, "(A)")
select type (phs)
type is (phs_wood_t)
call phs%write_forest (u)
end select
write (u, "(A)")
write (u, "(A)") "* Inverse kinematics"
write (u, "(A)")
call phs%get_outgoing_momenta (q)
call phs%final ()
deallocate (phs)
call phs_data%allocate_instance (phs)
call phs%init (phs_data)
call phs%set_incoming_momenta (p)
call phs%compute_flux ()
call phs%set_outgoing_momenta (q)
call phs%inverse ()
call phs%write (u)
write (u, "(A)")
select type (phs)
type is (phs_wood_t)
call phs%write_forest (u)
end select
call phs%final ()
deallocate (phs)
close (u_phs)
call phs_data%final ()
call model%final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: phs_wood_2"
end subroutine phs_wood_2
@ %def phs_wood_2
@
\subsubsection{Phase-space generation}
Generate phase space for a simple process.
<<PHS wood: execute tests>>=
call test (phs_wood_3, "phs_wood_3", &
"phase-space generation", &
u, results)
<<PHS wood: test declarations>>=
public :: phs_wood_3
<<PHS wood: tests>>=
subroutine phs_wood_3 (u)
integer, intent(in) :: u
type(model_data_t), target :: model
type(process_constants_t) :: process_data
type(phs_parameters_t) :: phs_par
class(phs_config_t), allocatable :: phs_data
integer :: iostat
character(80) :: buffer
write (u, "(A)") "* Test output: phs_wood_3"
write (u, "(A)") "* Purpose: generate a phase-space configuration"
write (u, "(A)")
call model%init_test ()
call syntax_phs_forest_init ()
write (u, "(A)") "* Initialize a process and phase-space parameters"
write (u, "(A)")
call init_test_process_data (var_str ("phs_wood_3"), process_data)
allocate (phs_wood_config_t :: phs_data)
call phs_data%init (process_data, model)
phs_par%sqrts = 1000
select type (phs_data)
type is (phs_wood_config_t)
call phs_data%set_parameters (phs_par)
phs_data%io_unit_keep_open = .true.
end select
write (u, "(A)")
write (u, "(A)") "* Generate a scratch phase-space file"
write (u, "(A)")
call phs_data%configure (phs_par%sqrts)
select type (phs_data)
type is (phs_wood_config_t)
rewind (phs_data%io_unit)
do
read (phs_data%io_unit, "(A)", iostat = iostat) buffer
if (iostat /= 0) exit
write (u, "(A)") trim (buffer)
end do
end select
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call phs_data%final ()
call model%final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: phs_wood_3"
end subroutine phs_wood_3
@ %def phs_wood_3
@
\subsubsection{Nontrivial process}
Generate phase space for a $2\to 3$ process.
<<PHS wood: execute tests>>=
call test (phs_wood_4, "phs_wood_4", &
"nontrivial process", &
u, results)
<<PHS wood: test declarations>>=
public :: phs_wood_4
<<PHS wood: tests>>=
subroutine phs_wood_4 (u)
integer, intent(in) :: u
type(model_data_t), target :: model
type(process_constants_t) :: process_data
type(phs_parameters_t) :: phs_par
class(phs_config_t), allocatable, target :: phs_data
integer :: iostat
character(80) :: buffer
class(phs_t), pointer :: phs => null ()
real(default) :: E, pL
type(vector4_t), dimension(2) :: p
type(vector4_t), dimension(3) :: q
write (u, "(A)") "* Test output: phs_wood_4"
write (u, "(A)") "* Purpose: generate a phase-space configuration"
write (u, "(A)")
call model%init_test ()
call syntax_phs_forest_init ()
write (u, "(A)") "* Initialize a process and phase-space parameters"
write (u, "(A)")
process_data%id = "phs_wood_4"
process_data%model_name = "Test"
process_data%n_in = 2
process_data%n_out = 3
process_data%n_flv = 1
allocate (process_data%flv_state (process_data%n_in + process_data%n_out, &
process_data%n_flv))
process_data%flv_state(:,1) = [25, 25, 25, 6, -6]
allocate (phs_wood_config_t :: phs_data)
call phs_data%init (process_data, model)
phs_par%sqrts = 1000
select type (phs_data)
type is (phs_wood_config_t)
call phs_data%set_parameters (phs_par)
phs_data%io_unit_keep_open = .true.
end select
write (u, "(A)")
write (u, "(A)") "* Generate a scratch phase-space file"
write (u, "(A)")
call phs_data%configure (phs_par%sqrts)
select type (phs_data)
type is (phs_wood_config_t)
rewind (phs_data%io_unit)
do
read (phs_data%io_unit, "(A)", iostat = iostat) buffer
if (iostat /= 0) exit
write (u, "(A)") trim (buffer)
end do
end select
write (u, "(A)")
write (u, "(A)") "* Initialize the phase-space instance"
write (u, "(A)")
call phs_data%allocate_instance (phs)
call phs%init (phs_data)
write (u, "(A)") "* Set incoming momenta"
write (u, "(A)")
select type (phs_data)
type is (phs_wood_config_t)
E = phs_data%sqrts / 2
pL = sqrt (E**2 - phs_data%flv(1,1)%get_mass ()**2)
end select
p(1) = vector4_moving (E, pL, 3)
p(2) = vector4_moving (E, -pL, 3)
call phs%set_incoming_momenta (p)
call phs%compute_flux ()
write (u, "(A)") "* Compute phase-space point &
&for x = 0.1, 0.2, 0.3, 0.4, 0.5"
write (u, "(A)")
call phs%evaluate_selected_channel (1, &
[0.1_default, 0.2_default, 0.3_default, 0.4_default, 0.5_default])
call phs%evaluate_other_channels (1)
call phs%write (u)
write (u, "(A)")
write (u, "(A)") "* Inverse kinematics"
write (u, "(A)")
call phs%get_outgoing_momenta (q)
call phs%final ()
deallocate (phs)
call phs_data%allocate_instance (phs)
call phs%init (phs_data)
call phs%set_incoming_momenta (p)
call phs%compute_flux ()
call phs%set_outgoing_momenta (q)
call phs%inverse ()
call phs%write (u)
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call phs%final ()
deallocate (phs)
call phs_data%final ()
call model%final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: phs_wood_4"
end subroutine phs_wood_4
@ %def phs_wood_4
@
\subsubsection{Equivalences}
Generate phase space for a simple process, including channel equivalences.
<<PHS wood: execute tests>>=
call test (phs_wood_5, "phs_wood_5", &
"equivalences", &
u, results)
<<PHS wood: test declarations>>=
public :: phs_wood_5
<<PHS wood: tests>>=
subroutine phs_wood_5 (u)
integer, intent(in) :: u
type(model_data_t), target :: model
type(process_constants_t) :: process_data
type(phs_parameters_t) :: phs_par
class(phs_config_t), allocatable :: phs_data
write (u, "(A)") "* Test output: phs_wood_5"
write (u, "(A)") "* Purpose: generate a phase-space configuration"
write (u, "(A)")
call model%init_test ()
call syntax_phs_forest_init ()
write (u, "(A)") "* Initialize a process and phase-space parameters"
write (u, "(A)")
call init_test_process_data (var_str ("phs_wood_5"), process_data)
allocate (phs_wood_config_t :: phs_data)
call phs_data%init (process_data, model)
phs_par%sqrts = 1000
select type (phs_data)
type is (phs_wood_config_t)
call phs_data%set_parameters (phs_par)
call phs_data%enable_equivalences ()
end select
write (u, "(A)")
write (u, "(A)") "* Generate a scratch phase-space file"
write (u, "(A)")
call phs_data%configure (phs_par%sqrts)
call phs_data%write (u)
write (u, "(A)")
select type (phs_data)
type is (phs_wood_config_t)
call phs_data%write_forest (u)
end select
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call phs_data%final ()
call model%final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: phs_wood_5"
end subroutine phs_wood_5
@ %def phs_wood_5
@
\subsubsection{MD5 sum checks}
Generate phase space for a simple process. Repeat this with and without
parameter change.
<<PHS wood: execute tests>>=
call test (phs_wood_6, "phs_wood_6", &
"phase-space generation", &
u, results)
<<PHS wood: test declarations>>=
public :: phs_wood_6
<<PHS wood: tests>>=
subroutine phs_wood_6 (u)
integer, intent(in) :: u
type(model_data_t), target :: model
type(process_constants_t) :: process_data
type(phs_parameters_t) :: phs_par
class(phs_config_t), allocatable :: phs_data
logical :: exist, found, match
integer :: u_phs
character(*), parameter :: filename = "phs_wood_6_p.phs"
write (u, "(A)") "* Test output: phs_wood_6"
write (u, "(A)") "* Purpose: generate and check phase-space file"
write (u, "(A)")
call model%init_test ()
call syntax_phs_forest_init ()
write (u, "(A)") "* Initialize a process and phase-space parameters"
write (u, "(A)")
call init_test_process_data (var_str ("phs_wood_6"), process_data)
process_data%id = "phs_wood_6_p"
process_data%md5sum = "1234567890abcdef1234567890abcdef"
allocate (phs_wood_config_t :: phs_data)
call phs_data%init (process_data, model)
phs_par%sqrts = 1000
select type (phs_data)
type is (phs_wood_config_t)
call phs_data%set_parameters (phs_par)
end select
write (u, "(A)") "* Remove previous phs file, if any"
write (u, "(A)")
inquire (file = filename, exist = exist)
if (exist) then
u_phs = free_unit ()
open (u_phs, file = filename, action = "write")
close (u_phs, status = "delete")
end if
write (u, "(A)") "* Check phase-space file (should fail)"
write (u, "(A)")
select type (phs_data)
type is (phs_wood_config_t)
call phs_data%read_phs_file (exist, found, match)
write (u, "(1x,A,L1)") "exist = ", exist
write (u, "(1x,A,L1)") "found = ", found
write (u, "(1x,A,L1)") "match = ", match
end select
write (u, "(A)")
write (u, "(A)") "* Generate a phase-space file"
write (u, "(A)")
call phs_data%configure (phs_par%sqrts)
write (u, "(1x,A,A,A)") "MD5 sum (process) = '", &
phs_data%md5sum_process, "'"
write (u, "(1x,A,A,A)") "MD5 sum (model par) = '", &
phs_data%md5sum_model_par, "'"
write (u, "(1x,A,A,A)") "MD5 sum (phs config) = '", &
phs_data%md5sum_phs_config, "'"
write (u, "(A)")
write (u, "(A)") "* Check MD5 sum"
write (u, "(A)")
call phs_data%final ()
deallocate (phs_data)
allocate (phs_wood_config_t :: phs_data)
call phs_data%init (process_data, model)
phs_par%sqrts = 1000
select type (phs_data)
type is (phs_wood_config_t)
call phs_data%set_parameters (phs_par)
phs_data%sqrts = phs_par%sqrts
phs_data%par%sqrts = phs_par%sqrts
end select
call phs_data%compute_md5sum ()
write (u, "(1x,A,A,A)") "MD5 sum (process) = '", &
phs_data%md5sum_process, "'"
write (u, "(1x,A,A,A)") "MD5 sum (model par) = '", &
phs_data%md5sum_model_par, "'"
write (u, "(1x,A,A,A)") "MD5 sum (phs config) = '", &
phs_data%md5sum_phs_config, "'"
select type (phs_data)
type is (phs_wood_config_t)
call phs_data%read_phs_file (exist, found, match)
write (u, "(1x,A,L1)") "exist = ", exist
write (u, "(1x,A,L1)") "found = ", found
write (u, "(1x,A,L1)") "match = ", match
end select
write (u, "(A)")
write (u, "(A)") "* Modify sqrts and check MD5 sum"
write (u, "(A)")
call phs_data%final ()
deallocate (phs_data)
allocate (phs_wood_config_t :: phs_data)
call phs_data%init (process_data, model)
phs_par%sqrts = 500
select type (phs_data)
type is (phs_wood_config_t)
call phs_data%set_parameters (phs_par)
phs_data%sqrts = phs_par%sqrts
phs_data%par%sqrts = phs_par%sqrts
end select
call phs_data%compute_md5sum ()
write (u, "(1x,A,A,A)") "MD5 sum (process) = '", &
phs_data%md5sum_process, "'"
write (u, "(1x,A,A,A)") "MD5 sum (model par) = '", &
phs_data%md5sum_model_par, "'"
write (u, "(1x,A,A,A)") "MD5 sum (phs config) = '", &
phs_data%md5sum_phs_config, "'"
select type (phs_data)
type is (phs_wood_config_t)
call phs_data%read_phs_file (exist, found, match)
write (u, "(1x,A,L1)") "exist = ", exist
write (u, "(1x,A,L1)") "found = ", found
write (u, "(1x,A,L1)") "match = ", match
end select
write (u, "(A)")
write (u, "(A)") "* Modify process and check MD5 sum"
write (u, "(A)")
call phs_data%final ()
deallocate (phs_data)
process_data%md5sum = "77777777777777777777777777777777"
allocate (phs_wood_config_t :: phs_data)
call phs_data%init (process_data, model)
phs_par%sqrts = 1000
select type (phs_data)
type is (phs_wood_config_t)
call phs_data%set_parameters (phs_par)
phs_data%sqrts = phs_par%sqrts
phs_data%par%sqrts = phs_par%sqrts
end select
call phs_data%compute_md5sum ()
write (u, "(1x,A,A,A)") "MD5 sum (process) = '", &
phs_data%md5sum_process, "'"
write (u, "(1x,A,A,A)") "MD5 sum (model par) = '", &
phs_data%md5sum_model_par, "'"
write (u, "(1x,A,A,A)") "MD5 sum (phs config) = '", &
phs_data%md5sum_phs_config, "'"
select type (phs_data)
type is (phs_wood_config_t)
call phs_data%read_phs_file (exist, found, match)
write (u, "(1x,A,L1)") "exist = ", exist
write (u, "(1x,A,L1)") "found = ", found
write (u, "(1x,A,L1)") "match = ", match
end select
write (u, "(A)")
write (u, "(A)") "* Modify phs parameter and check MD5 sum"
write (u, "(A)")
call phs_data%final ()
deallocate (phs_data)
allocate (phs_wood_config_t :: phs_data)
process_data%md5sum = "1234567890abcdef1234567890abcdef"
call phs_data%init (process_data, model)
phs_par%sqrts = 1000
phs_par%off_shell = 17
select type (phs_data)
type is (phs_wood_config_t)
call phs_data%set_parameters (phs_par)
phs_data%sqrts = phs_par%sqrts
phs_data%par%sqrts = phs_par%sqrts
end select
call phs_data%compute_md5sum ()
write (u, "(1x,A,A,A)") "MD5 sum (process) = '", &
phs_data%md5sum_process, "'"
write (u, "(1x,A,A,A)") "MD5 sum (model par) = '", &
phs_data%md5sum_model_par, "'"
write (u, "(1x,A,A,A)") "MD5 sum (phs config) = '", &
phs_data%md5sum_phs_config, "'"
select type (phs_data)
type is (phs_wood_config_t)
call phs_data%read_phs_file (exist, found, match)
write (u, "(1x,A,L1)") "exist = ", exist
write (u, "(1x,A,L1)") "found = ", found
write (u, "(1x,A,L1)") "match = ", match
end select
write (u, "(A)")
write (u, "(A)") "* Modify model parameter and check MD5 sum"
write (u, "(A)")
call phs_data%final ()
deallocate (phs_data)
allocate (phs_wood_config_t :: phs_data)
call model%set_par (var_str ("ms"), 100._default)
call phs_data%init (process_data, model)
phs_par%sqrts = 1000
phs_par%off_shell = 1
select type (phs_data)
type is (phs_wood_config_t)
call phs_data%set_parameters (phs_par)
phs_data%sqrts = phs_par%sqrts
phs_data%par%sqrts = phs_par%sqrts
end select
call phs_data%compute_md5sum ()
write (u, "(1x,A,A,A)") "MD5 sum (process) = '", &
phs_data%md5sum_process, "'"
write (u, "(1x,A,A,A)") "MD5 sum (model par) = '", &
phs_data%md5sum_model_par, "'"
write (u, "(1x,A,A,A)") "MD5 sum (phs config) = '", &
phs_data%md5sum_phs_config, "'"
select type (phs_data)
type is (phs_wood_config_t)
call phs_data%read_phs_file (exist, found, match)
write (u, "(1x,A,L1)") "exist = ", exist
write (u, "(1x,A,L1)") "found = ", found
write (u, "(1x,A,L1)") "match = ", match
end select
write (u, "(A)")
write (u, "(A)") "* Cleanup"
call phs_data%final ()
call model%final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: phs_wood_6"
end subroutine phs_wood_6
@ %def phs_wood_6
@
<<PHS wood: execute vis tests>>=
call test (phs_wood_vis_1, "phs_wood_vis_1", &
"visualizing phase space channels", &
u, results)
<<PHS wood: test declarations>>=
public :: phs_wood_vis_1
<<PHS wood: tests>>=
subroutine phs_wood_vis_1 (u)
integer, intent(in) :: u
type(os_data_t) :: os_data
type(model_data_t), target :: model
type(process_constants_t) :: process_data
class(phs_config_t), allocatable :: phs_data
type(mapping_defaults_t) :: mapping_defaults
type(string_t) :: vis_file, pdf_file, ps_file
real(default) :: sqrts
logical :: exist, exist_pdf, exist_ps
integer :: u_phs, iostat, u_vis
character(95) :: buffer
write (u, "(A)") "* Test output: phs_wood_vis_1"
write (u, "(A)") "* Purpose: visualizing the &
&phase-space configuration"
write (u, "(A)")
call os_data%init ()
call model%init_test ()
call syntax_phs_forest_init ()
write (u, "(A)") "* Initialize a process"
write (u, "(A)")
call init_test_process_data (var_str ("phs_wood_vis_1"), process_data)
write (u, "(A)") "* Create a scratch phase-space file"
write (u, "(A)")
u_phs = free_unit ()
open (u_phs, status = "scratch", action = "readwrite")
call write_test_phs_file (u_phs, var_str ("phs_wood_vis_1"))
rewind (u_phs)
do
read (u_phs, "(A)", iostat = iostat) buffer
if (iostat /= 0) exit
write (u, "(A)") trim (buffer)
end do
write (u, "(A)")
write (u, "(A)") "* Setup phase-space configuration object"
write (u, "(A)")
mapping_defaults%step_mapping = .false.
allocate (phs_wood_config_t :: phs_data)
call phs_data%init (process_data, model)
select type (phs_data)
type is (phs_wood_config_t)
call phs_data%set_input (u_phs)
call phs_data%set_mapping_defaults (mapping_defaults)
phs_data%os_data = os_data
phs_data%io_unit = 0
phs_data%io_unit_keep_open = .true.
phs_data%vis_channels = .true.
end select
sqrts = 1000._default
call phs_data%configure (sqrts)
call phs_data%write (u)
write (u, "(A)")
select type (phs_data)
type is (phs_wood_config_t)
call phs_data%write_forest (u)
end select
vis_file = "phs_wood_vis_1.phs-vis.tex"
ps_file = "phs_wood_vis_1.phs-vis.ps"
pdf_file = "phs_wood_vis_1.phs-vis.pdf"
inquire (file = char (vis_file), exist = exist)
if (exist) then
u_vis = free_unit ()
open (u_vis, file = char (vis_file), action = "read", status = "old")
iostat = 0
do while (iostat == 0)
read (u_vis, "(A)", iostat = iostat) buffer
if (iostat == 0) write (u, "(A)") trim (buffer)
end do
close (u_vis)
else
write (u, "(A)") "[Visualize LaTeX file is missing]"
end if
inquire (file = char (ps_file), exist = exist_ps)
if (exist_ps) then
write (u, "(A)") "[Visualize Postscript file exists and is nonempty]"
else
write (u, "(A)") "[Visualize Postscript file is missing/non-regular]"
end if
inquire (file = char (pdf_file), exist = exist_pdf)
if (exist_pdf) then
write (u, "(A)") "[Visualize PDF file exists and is nonempty]"
else
write (u, "(A)") "[Visualize PDF file is missing/non-regular]"
end if
write (u, "(A)")
write (u, "(A)") "* Cleanup"
close (u_phs)
call phs_data%final ()
call model%final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: phs_wood_vis_1"
end subroutine phs_wood_vis_1
@ %def phs_wood_vis_1
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{The FKS phase space}
<<[[phs_fks.f90]]>>=
<<File header>>
module phs_fks
<<Use kinds>>
<<Use strings>>
<<Use debug>>
use constants
use diagnostics
use io_units, only: given_output_unit, free_unit
use format_utils, only: write_separator
use lorentz
use physics_defs
use flavors
use pdg_arrays, only: is_colored
use models, only: model_t
use sf_mappings
use sf_base
use phs_base
use resonances, only: resonance_contributors_t, resonance_history_t
use phs_forests, only: phs_forest_final
use phs_wood
use cascades
use cascades2
use process_constants
use process_libraries
use ttv_formfactors, only: generate_on_shell_decay_threshold, m1s_to_mpole
use format_defs, only: FMT_17
<<Standard module head>>
<<phs fks: public>>
<<phs fks: parameters>>
<<phs fks: types>>
<<phs fks: interfaces>>
contains
<<phs fks: procedures>>
end module phs_fks
@ %def phs_fks
@
@ A container for the $x_\oplus$- and $x_\ominus$-values for initial-state
phase spaces.
<<phs fks: public>>=
public :: isr_kinematics_t
<<phs fks: types>>=
type :: isr_kinematics_t
integer :: n_in
real(default), dimension(2) :: x = one
real(default), dimension(2) :: z = zero
real(default) :: sqrts_born = zero
real(default), dimension(:), allocatable :: beam_energy
real(default) :: fac_scale = zero
real(default), dimension(2) :: jacobian = one
integer :: isr_mode = SQRTS_FIXED
contains
<<phs fks: isr kinematics: TBP>>
end type isr_kinematics_t
@ %def type isr_kinematics_t
@
<<phs fks: isr kinematics: TBP>>=
procedure :: write => isr_kinematics_write
<<phs fks: procedures>>=
subroutine isr_kinematics_write (isr, unit)
class(isr_kinematics_t), intent(in) :: isr
integer, intent(in), optional :: unit
integer :: u, i
u = given_output_unit (unit); if (u < 0) return
write (u,"(A)") "ISR kinematics: "
write (u,"(A," // FMT_17 // ",1X)") "x(+): ", isr%x(1)
write (u,"(A," // FMT_17 // ",1X)") "x(-): ", isr%x(2)
write (u,"(A," // FMT_17 // ",1X)") "z(+): ", isr%z(1)
write (u,"(A," // FMT_17 // ",1X)") "z(-): ", isr%z(2)
write (u,"(A," // FMT_17 // ",1X)") "sqrts (Born): ", isr%sqrts_born
if (allocated (isr%beam_energy)) then
do i = 1, size (isr%beam_energy)
write (u,"(A," // FMT_17 // ",1X)") "Beam energy: ", &
isr%beam_energy(i)
end do
end if
write (u,"(A," // FMT_17 // ",1X)") "Fac. scale: ", isr%fac_scale
do i = 1, 2
write (u,"(A," // FMT_17 // ",1X)") "Jacobian: ", isr%jacobian(i)
end do
write (u,"(A,I0,1X)") "ISR mode: ", isr%isr_mode
end subroutine isr_kinematics_write
@ %def isr_kinematics_write
@
<<phs fks: public>>=
public :: phs_point_set_t
<<phs fks: types>>=
type :: phs_point_set_t
type(phs_point_t), dimension(:), allocatable :: phs_point
logical :: initialized = .false.
contains
<<phs fks: phs point set: TBP>>
end type phs_point_set_t
@ %def phs_point_set_t
@
<<phs fks: phs point set: TBP>>=
procedure :: init => phs_point_set_init
<<phs fks: procedures>>=
subroutine phs_point_set_init (phs_point_set, n_particles, n_phs)
class(phs_point_set_t), intent(out) :: phs_point_set
integer, intent(in) :: n_particles, n_phs
integer :: i_phs
allocate (phs_point_set%phs_point (n_phs))
do i_phs = 1, n_phs
phs_point_set%phs_point(i_phs) = n_particles
end do
phs_point_set%initialized = .true.
end subroutine phs_point_set_init
@ %def phs_point_set_init
@
<<phs fks: phs point set: TBP>>=
procedure :: write => phs_point_set_write
<<phs fks: procedures>>=
subroutine phs_point_set_write (phs_point_set, i_phs, contributors, unit, show_mass, &
testflag, check_conservation, ultra, n_in)
class(phs_point_set_t), intent(in) :: phs_point_set
integer, intent(in), optional :: i_phs
integer, intent(in), dimension(:), optional :: contributors
integer, intent(in), optional :: unit
logical, intent(in), optional :: show_mass
logical, intent(in), optional :: testflag, ultra
logical, intent(in), optional :: check_conservation
integer, intent(in), optional :: n_in
integer :: i, u
type(vector4_t) :: p_sum
u = given_output_unit (unit); if (u < 0) return
if (present (i_phs)) then
call phs_point_set%phs_point(i_phs)%write &
(unit = u, show_mass = show_mass, testflag = testflag, &
check_conservation = check_conservation, ultra = ultra, n_in = n_in)
else
do i = 1, size(phs_point_set%phs_point)
call phs_point_set%phs_point(i)%write &
(unit = u, show_mass = show_mass, testflag = testflag, &
check_conservation = check_conservation, ultra = ultra, n_in = n_in)
end do
end if
if (present (contributors)) then
p_sum = vector4_null
if (debug_on) call msg_debug (D_SUBTRACTION, "Invariant masses for real emission: ")
associate (p => phs_point_set%phs_point(i_phs)%p)
do i = 1, size (contributors)
p_sum = p_sum + p(contributors(i))
end do
p_sum = p_sum + p(size(p))
end associate
if (debug_active (D_SUBTRACTION)) &
call vector4_write (p_sum, unit = unit, show_mass = show_mass, &
testflag = testflag, ultra = ultra)
end if
end subroutine phs_point_set_write
@ %def phs_point_set_write
@
<<phs fks: phs point set: TBP>>=
procedure :: get_n_momenta => phs_point_set_get_n_momenta
<<phs fks: procedures>>=
elemental function phs_point_set_get_n_momenta (phs_point_set, i_res) result (n)
integer :: n
class(phs_point_set_t), intent(in) :: phs_point_set
integer, intent(in) :: i_res
n = phs_point_set%phs_point(i_res)%n_momenta
end function phs_point_set_get_n_momenta
@ %def phs_point_set_get_n_momenta
@
<<phs fks: phs point set: TBP>>=
procedure :: get_momenta => phs_point_set_get_momenta
<<phs fks: procedures>>=
pure function phs_point_set_get_momenta (phs_point_set, i_phs, n_in) result (p)
type(vector4_t), dimension(:), allocatable :: p
class(phs_point_set_t), intent(in) :: phs_point_set
integer, intent(in) :: i_phs
integer, intent(in), optional :: n_in
if (present (n_in)) then
allocate (p (n_in), source = phs_point_set%phs_point(i_phs)%p(1:n_in))
else
allocate (p (phs_point_set%phs_point(i_phs)%n_momenta), &
source = phs_point_set%phs_point(i_phs)%p)
end if
end function phs_point_set_get_momenta
@ %def phs_point_set_get_momenta
@
<<phs fks: phs point set: TBP>>=
procedure :: get_momentum => phs_point_set_get_momentum
<<phs fks: procedures>>=
pure function phs_point_set_get_momentum (phs_point_set, i_phs, i_mom) result (p)
type(vector4_t) :: p
class(phs_point_set_t), intent(in) :: phs_point_set
integer, intent(in) :: i_phs, i_mom
p = phs_point_set%phs_point(i_phs)%p(i_mom)
end function phs_point_set_get_momentum
@ %def phs_point_set_get_momentum
@
<<phs fks: phs point set: TBP>>=
procedure :: get_energy => phs_point_set_get_energy
<<phs fks: procedures>>=
pure function phs_point_set_get_energy (phs_point_set, i_phs, i_mom) result (E)
real(default) :: E
class(phs_point_set_t), intent(in) :: phs_point_set
integer, intent(in) :: i_phs, i_mom
E = phs_point_set%phs_point(i_phs)%p(i_mom)%p(0)
end function phs_point_set_get_energy
@ %def phs_point_set_get_energy
@
<<phs fks: phs point set: TBP>>=
procedure :: get_sqrts => phs_point_set_get_sqrts
<<phs fks: procedures>>=
function phs_point_set_get_sqrts (phs_point_set, i_phs) result (sqrts)
real(default) :: sqrts
class(phs_point_set_t), intent(in) :: phs_point_set
integer, intent(in) :: i_phs
associate (p => phs_point_set%phs_point(i_phs)%p)
sqrts = (p(1) + p(2))**1
end associate
end function phs_point_set_get_sqrts
@ %def phs_point_set_get_sqrts
@
<<phs fks: phs point set: TBP>>=
generic :: set_momenta => set_momenta_p, set_momenta_phs_point
procedure :: set_momenta_p => phs_point_set_set_momenta_p
<<phs fks: procedures>>=
subroutine phs_point_set_set_momenta_p (phs_point_set, i_phs, p)
class(phs_point_set_t), intent(inout) :: phs_point_set
integer, intent(in) :: i_phs
type(vector4_t), intent(in), dimension(:) :: p
phs_point_set%phs_point(i_phs)%p = p
end subroutine phs_point_set_set_momenta_p
@ %def phs_point_set_set_momenta_p
@
<<phs fks: phs point set: TBP>>=
procedure :: set_momenta_phs_point => phs_point_set_set_momenta_phs_point
<<phs fks: procedures>>=
subroutine phs_point_set_set_momenta_phs_point (phs_point_set, i_phs, p)
class(phs_point_set_t), intent(inout) :: phs_point_set
integer, intent(in) :: i_phs
type(phs_point_t), intent(in) :: p
phs_point_set%phs_point(i_phs) = p
end subroutine phs_point_set_set_momenta_phs_point
@ %def phs_point_set_set_momenta_phs_point
@
<<phs fks: phs point set: TBP>>=
procedure :: get_n_particles => phs_point_set_get_n_particles
<<phs fks: procedures>>=
function phs_point_set_get_n_particles (phs_point_set, i) result (n_particles)
integer :: n_particles
class(phs_point_set_t), intent(in) :: phs_point_set
integer, intent(in), optional :: i
integer :: j
j = 1; if (present (i)) j = i
n_particles = size (phs_point_set%phs_point(j)%p)
end function phs_point_set_get_n_particles
@ %def phs_point_set_get_n_particles
@
<<phs fks: phs point set: TBP>>=
procedure :: get_n_phs => phs_point_set_get_n_phs
<<phs fks: procedures>>=
function phs_point_set_get_n_phs (phs_point_set) result (n_phs)
integer :: n_phs
class(phs_point_set_t), intent(in) :: phs_point_set
n_phs = size (phs_point_set%phs_point)
end function phs_point_set_get_n_phs
@ %def phs_point_set_get_n_phs
@
<<phs fks: phs point set: TBP>>=
procedure :: get_invariant_mass => phs_point_set_get_invariant_mass
<<phs fks: procedures>>=
function phs_point_set_get_invariant_mass (phs_point_set, i_phs, i_part) result (m2)
real(default) :: m2
class(phs_point_set_t), intent(in) :: phs_point_set
integer, intent(in) :: i_phs
integer, intent(in), dimension(:) :: i_part
type(vector4_t) :: p
integer :: i
p = vector4_null
do i = 1, size (i_part)
p = p + phs_point_set%phs_point(i_phs)%p(i_part(i))
end do
m2 = p**2
end function phs_point_set_get_invariant_mass
@ %def phs_point_set_get_invariant_mass
@
<<phs fks: phs point set: TBP>>=
procedure :: write_phs_point => phs_point_set_write_phs_point
<<phs fks: procedures>>=
subroutine phs_point_set_write_phs_point (phs_point_set, i_phs, unit, show_mass, &
testflag, check_conservation, ultra, n_in)
class(phs_point_set_t), intent(in) :: phs_point_set
integer, intent(in) :: i_phs
integer, intent(in), optional :: unit
logical, intent(in), optional :: show_mass
logical, intent(in), optional :: testflag, ultra
logical, intent(in), optional :: check_conservation
integer, intent(in), optional :: n_in
call phs_point_set%phs_point(i_phs)%write (unit, show_mass, testflag, &
check_conservation, ultra, n_in)
end subroutine phs_point_set_write_phs_point
@ %def phs_point_set_write_phs_point
@
<<phs fks: phs point set: TBP>>=
procedure :: final => phs_point_set_final
<<phs fks: procedures>>=
subroutine phs_point_set_final (phs_point_set)
class(phs_point_set_t), intent(inout) :: phs_point_set
integer :: i
do i = 1, size (phs_point_set%phs_point)
call phs_point_set%phs_point(i)%final ()
end do
deallocate (phs_point_set%phs_point)
phs_point_set%initialized = .false.
end subroutine phs_point_set_final
@ %def phs_point_set_final
@
<<phs fks: public>>=
public :: real_jacobian_t
<<phs fks: types>>=
type :: real_jacobian_t
real(default), dimension(4) :: jac = 1._default
end type real_jacobian_t
@ %def real_jacobian_t
@
<<phs fks: public>>=
public :: real_kinematics_t
<<phs fks: types>>=
type :: real_kinematics_t
logical :: supply_xi_max = .true.
real(default) :: xi_tilde
real(default) :: phi
real(default), dimension(:), allocatable :: xi_max, y
real(default) :: xi_mismatch, y_mismatch
type(real_jacobian_t), dimension(:), allocatable :: jac
real(default) :: jac_mismatch
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(phs_point_set_t) :: p_born_onshell
type(phs_point_set_t), dimension(2) :: p_real_onshell
integer, dimension(:), allocatable :: alr_to_i_phs
real(default), dimension(3) :: x_rad
real(default), dimension(:), allocatable :: jac_rand
real(default), dimension(:), allocatable :: y_soft
real(default) :: cms_energy2
type(vector4_t), dimension(:), allocatable :: xi_ref_momenta
contains
<<phs fks: real kinematics: TBP>>
end type real_kinematics_t
@ %def real_kinematics_t
@
<<phs fks: real kinematics: TBP>>=
procedure :: init => real_kinematics_init
<<phs fks: procedures>>=
subroutine real_kinematics_init (r, n_tot, n_phs, n_alr, n_contr)
class(real_kinematics_t), intent(inout) :: r
integer, intent(in) :: n_tot, n_phs, n_alr, n_contr
allocate (r%xi_max (n_phs))
allocate (r%y (n_phs))
allocate (r%y_soft (n_phs))
call r%p_born_cms%init (n_tot - 1, 1)
call r%p_born_lab%init (n_tot - 1, 1)
call r%p_real_cms%init (n_tot, n_phs)
call r%p_real_lab%init (n_tot, n_phs)
allocate (r%jac (n_phs), r%jac_rand (n_phs))
allocate (r%alr_to_i_phs (n_alr))
allocate (r%xi_ref_momenta (n_contr))
r%alr_to_i_phs = 0
r%xi_tilde = zero; r%xi_mismatch = zero
r%xi_max = zero
r%y = zero; r%y_mismatch = zero
r%y_soft = zero
r%phi = zero
r%cms_energy2 = zero
r%xi_ref_momenta = vector4_null
r%jac_mismatch = one
r%jac_rand = one
end subroutine real_kinematics_init
@ %def real_kinematics_init
@
<<phs fks: real kinematics: TBP>>=
procedure :: init_onshell => real_kinematics_init_onshell
<<phs fks: procedures>>=
subroutine real_kinematics_init_onshell (r, n_tot, n_phs)
class(real_kinematics_t), intent(inout) :: r
integer, intent(in) :: n_tot, n_phs
call r%p_born_onshell%init (n_tot - 1, 1)
call r%p_real_onshell(1)%init (n_tot, n_phs)
call r%p_real_onshell(2)%init (n_tot, n_phs)
end subroutine real_kinematics_init_onshell
@ %def real_kinematics_init_onshell
@
<<phs fks: real kinematics: TBP>>=
procedure :: write => real_kinematics_write
<<phs fks: procedures>>=
subroutine real_kinematics_write (r, unit)
class(real_kinematics_t), intent(in) :: r
integer, intent(in), optional :: unit
integer :: u, i
u = given_output_unit (unit); if (u < 0) return
write (u,"(A)") "Real kinematics: "
write (u,"(A," // FMT_17 // ",1X)") "xi_tilde: ", r%xi_tilde
write (u,"(A," // FMT_17 // ",1X)") "phi: ", r%phi
do i = 1, size (r%xi_max)
write (u,"(A,I1,1X)") "i_phs: ", i
write (u,"(A," // FMT_17 // ",1X)") "xi_max: ", r%xi_max(i)
write (u,"(A," // FMT_17 // ",1X)") "y: ", r%y(i)
write (u,"(A," // FMT_17 // ",1X)") "jac_rand: ", r%jac_rand(i)
write (u,"(A," // FMT_17 // ",1X)") "y_soft: ", r%y_soft(i)
end do
write (u, "(A)") "Born Momenta: "
write (u, "(A)") "CMS: "
call r%p_born_cms%write (unit = u)
write (u, "(A)") "Lab: "
call r%p_born_lab%write (unit = u)
write (u, "(A)") "Real Momenta: "
write (u, "(A)") "CMS: "
call r%p_real_cms%write (unit = u)
write (u, "(A)") "Lab: "
call r%p_real_lab%write (unit = u)
end subroutine real_kinematics_write
@ %def real_kinematics_write
@ The boost to the center-of-mass system only has a reasonable meaning
above the threshold. Below the threshold, we do not apply boost at all, so
that the top quarks stay in the rest frame. However, with top quarks exactly
at rest, problems arise in the matrix elements (e.g. in the computation
of angles). Therefore, we apply a boost which is not exactly 1, but has a
tiny value differing from that.
<<phs fks: public>>=
public :: get_boost_for_threshold_projection
<<phs fks: procedures>>=
function get_boost_for_threshold_projection (p, sqrts, mtop) result (L)
type(lorentz_transformation_t) :: L
type(vector4_t), intent(in), dimension(:) :: p
real(default), intent(in) :: sqrts, mtop
type(vector4_t) :: p_tmp
type(vector3_t) :: dir
real(default) :: scale_factor, arg
p_tmp = p(THR_POS_WP) + p(THR_POS_B)
arg = sqrts**2 - four * mtop**2
if (arg > zero) then
scale_factor = sqrt (arg) / two
else
scale_factor = tiny_07*1000
end if
dir = scale_factor * create_unit_vector (p_tmp)
p_tmp = [sqrts / two, dir%p]
L = boost (p_tmp, mtop)
end function get_boost_for_threshold_projection
@ %def get_boost_for_threshold_projection
@ This routine recomputes the value of $\phi$ used to generate the real phase space.
<<phs fks: procedures>>=
function get_generation_phi (p_born, p_real, emitter, i_gluon) result (phi)
real(default) :: phi
type(vector4_t), intent(in), dimension(:) :: p_born, p_real
integer, intent(in) :: emitter, i_gluon
type(vector4_t) :: p1, p2, pp
type(lorentz_transformation_t) :: rot_to_gluon, rot_to_z
type(vector3_t) :: dir, z
real(default) :: cpsi
pp = p_real(emitter) + p_real(i_gluon)
cpsi = (space_part_norm (pp)**2 - space_part_norm (p_real(emitter))**2 &
+ space_part_norm (p_real(i_gluon))**2) / &
(two * space_part_norm (pp) * space_part_norm (p_real(i_gluon)))
dir = create_orthogonal (space_part (p_born(emitter)))
rot_to_gluon = rotation (cpsi, sqrt (one - cpsi**2), dir)
pp = rot_to_gluon * p_born(emitter)
z%p = [0, 0, 1]
rot_to_z = rotation_to_2nd &
(space_part (p_born(emitter)) / space_part_norm (p_born(emitter)), z)
p1 = rot_to_z * pp / space_part_norm (pp)
p2 = rot_to_z * p_real(i_gluon)
phi = azimuthal_distance (p1, p2)
if (phi < zero) phi = twopi - abs(phi)
end function get_generation_phi
@ %def get_generation_phi
@
<<phs fks: real kinematics: TBP>>=
procedure :: apply_threshold_projection_real => real_kinematics_apply_threshold_projection_real
<<phs fks: procedures>>=
subroutine real_kinematics_apply_threshold_projection_real (r, i_phs, mtop, L_to_cms, invert)
class(real_kinematics_t), intent(inout) :: r
integer, intent(in) :: i_phs
real(default), intent(in) :: mtop
type(lorentz_transformation_t), intent(in), dimension(:) :: L_to_cms
logical, intent(in) :: invert
integer :: leg, other_leg
type(vector4_t), dimension(4) :: k_tmp
type(vector4_t), dimension(4) :: k_decay_onshell_real
type(vector4_t), dimension(3) :: k_decay_onshell_born
do leg = 1, 2
other_leg = 3 - leg
associate (p_real => r%p_real_cms%phs_point(i_phs)%p, &
p_real_onshell => r%p_real_onshell(leg)%phs_point(i_phs)%p)
p_real_onshell(1:2) = p_real(1:2)
k_tmp(1) = p_real(7)
k_tmp(2) = p_real(ass_quark(leg))
k_tmp(3) = p_real(ass_boson(leg))
k_tmp(4) = [mtop, zero, zero, zero]
call generate_on_shell_decay_threshold (k_tmp(1:3), &
k_tmp(4), k_decay_onshell_real (2:4))
k_decay_onshell_real (1) = k_tmp(4)
k_tmp(1) = p_real(ass_quark(other_leg))
k_tmp(2) = p_real(ass_boson(other_leg))
k_decay_onshell_born = create_two_particle_decay (mtop**2, k_tmp(1), k_tmp(2))
p_real_onshell(THR_POS_GLUON) = L_to_cms(leg) * k_decay_onshell_real (2)
p_real_onshell(ass_quark(leg)) = L_to_cms(leg) * k_decay_onshell_real(3)
p_real_onshell(ass_boson(leg)) = L_to_cms(leg) * k_decay_onshell_real(4)
p_real_onshell(ass_quark(other_leg)) = L_to_cms(leg) * k_decay_onshell_born (2)
p_real_onshell(ass_boson(other_leg)) = L_to_cms(leg) * k_decay_onshell_born (3)
if (invert) then
call vector4_invert_direction (p_real_onshell (ass_quark(other_leg)))
call vector4_invert_direction (p_real_onshell (ass_boson(other_leg)))
end if
end associate
end do
end subroutine real_kinematics_apply_threshold_projection_real
@ %def real_kinematics_apply_threshold_projection_real
@
<<phs fks: public>>=
public :: threshold_projection_born
<<phs fks: procedures>>=
subroutine threshold_projection_born (mtop, L_to_cms, p_in, p_onshell)
real(default), intent(in) :: mtop
type(lorentz_transformation_t), intent(in) :: L_to_cms
type(vector4_t), intent(in), dimension(:) :: p_in
type(vector4_t), intent(out), dimension(:) :: p_onshell
type(vector4_t), dimension(3) :: k_decay_onshell
type(vector4_t) :: p_tmp_1, p_tmp_2
type(lorentz_transformation_t) :: L_to_cms_inv
p_onshell(1:2) = p_in(1:2)
L_to_cms_inv = inverse (L_to_cms)
p_tmp_1 = L_to_cms_inv * p_in(THR_POS_B)
p_tmp_2 = L_to_cms_inv * p_in(THR_POS_WP)
k_decay_onshell = create_two_particle_decay (mtop**2, &
p_tmp_1, p_tmp_2)
p_onshell([THR_POS_B, THR_POS_WP]) = k_decay_onshell([2, 3])
p_tmp_1 = L_to_cms * p_in(THR_POS_BBAR)
p_tmp_2 = L_to_cms * p_in(THR_POS_WM)
k_decay_onshell = create_two_particle_decay (mtop**2, &
p_tmp_1, p_tmp_2)
p_onshell([THR_POS_BBAR, THR_POS_WM]) = k_decay_onshell([2, 3])
p_onshell([THR_POS_WP, THR_POS_B]) = L_to_cms * p_onshell([THR_POS_WP, THR_POS_B])
p_onshell([THR_POS_WM, THR_POS_BBAR]) = L_to_cms_inv * p_onshell([THR_POS_WM, THR_POS_BBAR])
end subroutine threshold_projection_born
@ %def threshold_projection_born
@ This routine computes the bounds of the Dalitz region for massive emitters, see below.
It is also used by [[Powheg]], so the routine is public.
The input parameter [[m2]] corresponds to the squared mass of the emitter.
<<phs fks: public>>=
public :: compute_dalitz_bounds
<<phs fks: procedures>>=
pure subroutine compute_dalitz_bounds (q0, m2, mrec2, z1, z2, k0_rec_max)
real(default), intent(in) :: q0, m2, mrec2
real(default), intent(out) :: z1, z2, k0_rec_max
k0_rec_max = (q0**2 - m2 + mrec2) / (two * q0)
z1 = (k0_rec_max + sqrt(k0_rec_max**2 - mrec2)) / q0
z2 = (k0_rec_max - sqrt(k0_rec_max**2 - mrec2)) / q0
end subroutine compute_dalitz_bounds
@ %def compute_dalitz_bounds
@ Compute the [[kt2]] of a given emitter
<<phs fks: real kinematics: TBP>>=
procedure :: kt2 => real_kinematics_kt2
<<phs fks: procedures>>=
function real_kinematics_kt2 &
(real_kinematics, i_phs, emitter, kt2_type, xi, y) result (kt2)
real(default) :: kt2
class(real_kinematics_t), intent(in) :: real_kinematics
integer, intent(in) :: emitter, i_phs, kt2_type
real(default), intent(in), optional :: xi, y
real(default) :: xii, yy
real(default) :: q, E_em, z, z1, z2, m2, mrec2, k0_rec_max
type(vector4_t) :: p_emitter
if (present (y)) then
yy = y
else
yy = real_kinematics%y (i_phs)
end if
if (present (xi)) then
xii = xi
else
xii = real_kinematics%xi_tilde * real_kinematics%xi_max (i_phs)
end if
select case (kt2_type)
case (FSR_SIMPLE)
kt2 = real_kinematics%cms_energy2 / two * xii**2 * (1 - yy)
case (FSR_MASSIVE)
q = sqrt (real_kinematics%cms_energy2)
p_emitter = real_kinematics%p_born_cms%phs_point(1)%p(emitter)
mrec2 = (q - p_emitter%p(0))**2 - sum (p_emitter%p(1:3)**2)
m2 = p_emitter**2
E_em = energy (p_emitter)
call compute_dalitz_bounds (q, m2, mrec2, z1, z2, k0_rec_max)
z = z2 - (z2 - z1) * (one + yy) / two
kt2 = xii**2 * q**3 * (one - z) / &
(two * E_em - z * xii * q)
case (FSR_MASSLESS_RECOILER)
kt2 = real_kinematics%cms_energy2 / two * xii**2 * (1 - yy**2) / two
case default
kt2 = zero
call msg_bug ("kt2_type must be set to a known value")
end select
end function real_kinematics_kt2
@ %def real_kinematics_kt2
@
<<phs fks: parameters>>=
integer, parameter, public :: FSR_SIMPLE = 1
integer, parameter, public :: FSR_MASSIVE = 2
integer, parameter, public :: FSR_MASSLESS_RECOILER = 3
@ %def FSR_SIMPLE FSR_MASSIVE FSR_MASSLESS_RECOILER
@
<<phs fks: real kinematics: TBP>>=
procedure :: final => real_kinematics_final
<<phs fks: procedures>>=
subroutine real_kinematics_final (real_kin)
class(real_kinematics_t), intent(inout) :: real_kin
if (allocated (real_kin%xi_max)) deallocate (real_kin%xi_max)
if (allocated (real_kin%y)) deallocate (real_kin%y)
if (allocated (real_kin%alr_to_i_phs)) deallocate (real_kin%alr_to_i_phs)
if (allocated (real_kin%jac_rand)) deallocate (real_kin%jac_rand)
if (allocated (real_kin%y_soft)) deallocate (real_kin%y_soft)
if (allocated (real_kin%xi_ref_momenta)) deallocate (real_kin%xi_ref_momenta)
call real_kin%p_born_cms%final (); call real_kin%p_born_lab%final ()
call real_kin%p_real_cms%final (); call real_kin%p_real_lab%final ()
end subroutine real_kinematics_final
@ %def real_kinematics_final
@
<<phs fks: parameters>>=
integer, parameter, public :: I_XI = 1
integer, parameter, public :: I_Y = 2
integer, parameter, public :: I_PHI = 3
integer, parameter, public :: PHS_MODE_UNDEFINED = 0
integer, parameter, public :: PHS_MODE_ADDITIONAL_PARTICLE = 1
integer, parameter, public :: PHS_MODE_COLLINEAR_REMNANT = 2
@ %def parameters
@
<<phs fks: public>>=
public :: phs_fks_config_t
<<phs fks: types>>=
type, extends (phs_wood_config_t) :: phs_fks_config_t
integer :: mode = PHS_MODE_UNDEFINED
character(32) :: md5sum_born_config
logical :: born_2_to_1 = .false.
logical :: make_dalitz_plot = .false.
contains
<<phs fks: fks config: TBP>>
end type phs_fks_config_t
@ %def phs_fks_config_t
@
<<phs fks: fks config: TBP>>=
procedure :: clear_phase_space => fks_config_clear_phase_space
<<phs fks: procedures>>=
subroutine fks_config_clear_phase_space (phs_config)
class(phs_fks_config_t), intent(inout) :: phs_config
end subroutine fks_config_clear_phase_space
@ %def fks_config_clear_phase_space
@
<<phs fks: fks config: TBP>>=
procedure :: write => phs_fks_config_write
<<phs fks: procedures>>=
subroutine phs_fks_config_write (object, unit, include_id)
class(phs_fks_config_t), intent(in) :: object
integer, intent(in), optional :: unit
logical, intent(in), optional :: include_id
integer :: u
u = given_output_unit (unit)
call object%phs_wood_config_t%write (u)
write (u, "(3x,A,I0)") "NLO mode = ", object%mode
write (u, "(3x,A,L1)") "2->1 proc = ", object%born_2_to_1
write (u, "(3x,A,L1)") "Dalitz = ", object%make_dalitz_plot
write (u, "(A,A)") "Extra Born md5sum: ", object%md5sum_born_config
end subroutine phs_fks_config_write
@ %def phs_fks_config_write
@
<<phs fks: fks config: TBP>>=
procedure :: set_mode => phs_fks_config_set_mode
<<phs fks: procedures>>=
subroutine phs_fks_config_set_mode (phs_config, mode)
class(phs_fks_config_t), intent(inout) :: phs_config
integer, intent(in) :: mode
select case (mode)
case (NLO_REAL, NLO_MISMATCH)
phs_config%mode = PHS_MODE_ADDITIONAL_PARTICLE
case (NLO_DGLAP)
phs_config%mode = PHS_MODE_COLLINEAR_REMNANT
end select
end subroutine phs_fks_config_set_mode
@ %def phs_fks_config_set_mod
@
<<phs fks: fks config: TBP>>=
procedure :: configure => phs_fks_config_configure
<<phs fks: procedures>>=
subroutine phs_fks_config_configure (phs_config, sqrts, &
sqrts_fixed, lab_is_cm, azimuthal_dependence, rebuild, &
ignore_mismatch, nlo_type, subdir)
class(phs_fks_config_t), intent(inout) :: phs_config
real(default), intent(in) :: sqrts
logical, intent(in), optional :: sqrts_fixed
logical, intent(in), optional :: lab_is_cm
logical, intent(in), optional :: azimuthal_dependence
logical, intent(in), optional :: rebuild
logical, intent(in), optional :: ignore_mismatch
integer, intent(in), optional :: nlo_type
type(string_t), intent(in), optional :: subdir
if (present (nlo_type)) phs_config%nlo_type = nlo_type
if (.not. phs_config%is_combined_integration) then
select case (phs_config%mode)
case (PHS_MODE_ADDITIONAL_PARTICLE)
phs_config%n_par = phs_config%n_par + 3
if (phs_config%nlo_type == NLO_REAL .and. phs_config%n_out == 2) then
phs_config%born_2_to_1 = .true.
end if
case (PHS_MODE_COLLINEAR_REMNANT)
phs_config%n_par = phs_config%n_par + 1
end select
end if
-!!! Channel equivalences not accessible yet
- phs_config%provides_equivalences = .false.
call phs_config%compute_md5sum ()
end subroutine phs_fks_config_configure
@ %def phs_fks_config_configure
@
<<phs fks: fks config: TBP>>=
procedure :: startup_message => phs_fks_config_startup_message
<<phs fks: procedures>>=
subroutine phs_fks_config_startup_message (phs_config, unit)
class(phs_fks_config_t), intent(in) :: phs_config
integer, intent(in), optional :: unit
call phs_config%phs_wood_config_t%startup_message (unit)
end subroutine phs_fks_config_startup_message
@ %def phs_fks_config_startup_message
@
<<phs fks: fks config: TBP>>=
procedure, nopass :: allocate_instance => phs_fks_config_allocate_instance
<<phs fks: procedures>>=
subroutine phs_fks_config_allocate_instance (phs)
class(phs_t), intent(inout), pointer :: phs
allocate (phs_fks_t :: phs)
end subroutine phs_fks_config_allocate_instance
@ %def phs_fks_config_allocate_instance
@ If the phase space is generated from file, but we want to have resonance
histories, we must force the cascade sets to be generated. However, it must
be assured that Born flavors are used for this.
<<phs fks: fks config: TBP>>=
procedure :: generate_phase_space_extra => phs_fks_config_generate_phase_space_extra
<<phs fks: procedures>>=
subroutine phs_fks_config_generate_phase_space_extra (phs_config)
class(phs_fks_config_t), intent(inout) :: phs_config
integer :: off_shell, extra_off_shell
type(flavor_t), dimension(:,:), allocatable :: flv_born
integer :: i, j
integer :: n_state, n_flv_born
integer :: unit_fds
logical :: valid
type(string_t) :: file_name
logical :: file_exists
if (phs_config%use_cascades2) then
allocate (phs_config%feyngraph_set)
else
allocate (phs_config%cascade_set)
end if
n_flv_born = size (phs_config%flv, 1) - 1
n_state = size (phs_config%flv, 2)
allocate (flv_born (n_flv_born, n_state))
do i = 1, n_flv_born
do j = 1, n_state
flv_born(i, j) = phs_config%flv(i, j)
end do
end do
if (phs_config%use_cascades2) then
file_name = char (phs_config%id) // ".fds"
inquire (file=char (file_name), exist=file_exists)
if (.not. file_exists) call msg_fatal &
("The O'Mega input file " // char (file_name) // &
" does not exist. " // "Please make sure that the " // &
"variable ?omega_write_phs_output has been set correctly.")
unit_fds = free_unit ()
open (unit=unit_fds, file=char(file_name), status='old', action='read')
end if
off_shell = phs_config%par%off_shell
do extra_off_shell = 0, max (n_flv_born - 2, 0)
phs_config%par%off_shell = off_shell + extra_off_shell
if (phs_config%use_cascades2) then
call feyngraph_set_generate (phs_config%feyngraph_set, &
phs_config%model, phs_config%n_in, phs_config%n_out - 1, &
flv_born, phs_config%par, phs_config%fatal_beam_decay, unit_fds, &
phs_config%vis_channels)
if (feyngraph_set_is_valid (phs_config%feyngraph_set)) exit
else
call cascade_set_generate (phs_config%cascade_set, &
phs_config%model, phs_config%n_in, phs_config%n_out - 1, &
flv_born, phs_config%par, phs_config%fatal_beam_decay)
if (cascade_set_is_valid (phs_config%cascade_set)) exit
end if
end do
if (phs_config%use_cascades2) then
close (unit_fds)
valid = feyngraph_set_is_valid (phs_config%feyngraph_set)
else
valid = cascade_set_is_valid (phs_config%cascade_set)
end if
if (.not. valid) &
call msg_fatal ("Resonance extraction: Phase space generation failed")
end subroutine phs_fks_config_generate_phase_space_extra
@ %def phs_fks_config_generate_phase_space_extra
@
<<phs fks: fks config: TBP>>=
procedure :: set_born_config => phs_fks_config_set_born_config
<<phs fks: procedures>>=
subroutine phs_fks_config_set_born_config (phs_config, phs_cfg_born)
class(phs_fks_config_t), intent(inout) :: phs_config
type(phs_wood_config_t), intent(in), target :: phs_cfg_born
if (debug_on) &
call msg_debug (D_PHASESPACE, "phs_fks_config_set_born_config")
phs_config%forest = phs_cfg_born%forest
phs_config%n_channel = phs_cfg_born%n_channel
allocate (phs_config%channel (phs_config%n_channel))
phs_config%channel = phs_cfg_born%channel
phs_config%n_par = phs_cfg_born%n_par
phs_config%n_state = phs_cfg_born%n_state
phs_config%sqrts = phs_cfg_born%sqrts
phs_config%par = phs_cfg_born%par
phs_config%sqrts_fixed = phs_cfg_born%sqrts_fixed
phs_config%azimuthal_dependence = phs_cfg_born%azimuthal_dependence
phs_config%provides_chains = phs_cfg_born%provides_chains
phs_config%lab_is_cm = phs_cfg_born%lab_is_cm
phs_config%vis_channels = phs_cfg_born%vis_channels
+ phs_config%provides_equivalences = phs_cfg_born%provides_equivalences
allocate (phs_config%chain (size (phs_cfg_born%chain)))
phs_config%chain = phs_cfg_born%chain
phs_config%model => phs_cfg_born%model
phs_config%use_cascades2 = phs_cfg_born%use_cascades2
if (allocated (phs_cfg_born%cascade_set)) then
allocate (phs_config%cascade_set)
phs_config%cascade_set = phs_cfg_born%cascade_set
end if
if (allocated (phs_cfg_born%feyngraph_set)) then
allocate (phs_config%feyngraph_set)
phs_config%feyngraph_set = phs_cfg_born%feyngraph_set
end if
phs_config%md5sum_born_config = phs_cfg_born%md5sum_phs_config
end subroutine phs_fks_config_set_born_config
@ %def phs_fks_config_set_born_config
@
<<phs fks: fks config: TBP>>=
procedure :: get_resonance_histories => phs_fks_config_get_resonance_histories
<<phs fks: procedures>>=
function phs_fks_config_get_resonance_histories (phs_config) result (resonance_histories)
type(resonance_history_t), dimension(:), allocatable :: resonance_histories
class(phs_fks_config_t), intent(inout) :: phs_config
if (allocated (phs_config%cascade_set)) then
call cascade_set_get_resonance_histories &
(phs_config%cascade_set, n_filter = 2, res_hists = resonance_histories)
else if (allocated (phs_config%feyngraph_set)) then
call feyngraph_set_get_resonance_histories &
(phs_config%feyngraph_set, n_filter = 2, res_hists = resonance_histories)
else
if (debug_on) call msg_debug (D_PHASESPACE, "Have to rebuild phase space for resonance histories")
call phs_config%generate_phase_space_extra ()
if (phs_config%use_cascades2) then
call feyngraph_set_get_resonance_histories &
(phs_config%feyngraph_set, n_filter = 2, res_hists = resonance_histories)
else
call cascade_set_get_resonance_histories &
(phs_config%cascade_set, n_filter = 2, res_hists = resonance_histories)
end if
end if
end function phs_fks_config_get_resonance_histories
@ %def phs_fks_config_get_resonance_histories
@
<<phs fks: public>>=
public :: dalitz_plot_t
<<phs fks: types>>=
type :: dalitz_plot_t
integer :: unit = -1
type(string_t) :: filename
logical :: active = .false.
logical :: inverse = .false.
contains
<<phs fks: dalitz plot: TBP>>
end type dalitz_plot_t
@ %def dalitz_plot_t
@
<<phs fks: dalitz plot: TBP>>=
procedure :: init => dalitz_plot_init
<<phs fks: procedures>>=
subroutine dalitz_plot_init (plot, unit, filename, inverse)
class(dalitz_plot_t), intent(inout) :: plot
integer, intent(in) :: unit
type(string_t), intent(in) :: filename
logical, intent(in) :: inverse
plot%active = .true.
plot%unit = unit
plot%inverse = inverse
open (plot%unit, file = char (filename), action = "write")
end subroutine dalitz_plot_init
@ %def daltiz_plot_init
@
<<phs fks: dalitz plot: TBP>>=
procedure :: write_header => dalitz_plot_write_header
<<phs fks: procedures>>=
subroutine dalitz_plot_write_header (plot)
class(dalitz_plot_t), intent(in) :: plot
write (plot%unit, "(A36)") "### Dalitz plot generated by WHIZARD"
if (plot%inverse) then
write (plot%unit, "(A10,1x,A4)") "### k0_n+1", "k0_n"
else
write (plot%unit, "(A8,1x,A6)") "### k0_n", "k0_n+1"
end if
end subroutine dalitz_plot_write_header
@ %def dalitz_plot_write_header
@
<<phs fks: dalitz plot: TBP>>=
procedure :: register => dalitz_plot_register
<<phs fks: procedures>>=
subroutine dalitz_plot_register (plot, k0_n, k0_np1)
class(dalitz_plot_t), intent(in) :: plot
real(default), intent(in) :: k0_n, k0_np1
if (plot%inverse) then
write (plot%unit, "(F8.4,1X,F8.4)") k0_np1, k0_n
else
write (plot%unit, "(F8.4,1X,F8.4)") k0_np1, k0_n
end if
end subroutine dalitz_plot_register
@ %def dalitz_plot_register
@
<<phs fks: dalitz plot: TBP>>=
procedure :: final => dalitz_plot_final
<<phs fks: procedures>>=
subroutine dalitz_plot_final (plot)
class(dalitz_plot_t), intent(inout) :: plot
logical :: opened
plot%active = .false.
plot%inverse = .false.
if (plot%unit >= 0) then
inquire (unit = plot%unit, opened = opened)
if (opened) close (plot%unit)
end if
plot%filename = var_str ('')
plot%unit = -1
end subroutine dalitz_plot_final
@ %def dalitz_plot_final
@
<<phs fks: parameters>>=
integer, parameter, public :: GEN_REAL_PHASE_SPACE = 1
integer, parameter, public :: GEN_SOFT_MISMATCH = 2
integer, parameter, public :: GEN_SOFT_LIMIT_TEST = 3
integer, parameter, public :: GEN_COLL_LIMIT_TEST = 4
integer, parameter, public :: GEN_ANTI_COLL_LIMIT_TEST = 5
integer, parameter, public :: GEN_SOFT_COLL_LIMIT_TEST = 6
integer, parameter, public :: GEN_SOFT_ANTI_COLL_LIMIT_TEST = 7
integer, parameter, public :: SQRTS_FIXED = 1
integer, parameter, public :: SQRTS_VAR = 2
real(default), parameter :: xi_tilde_test_soft = 0.00001_default
real(default), parameter :: xi_tilde_test_coll = 0.5_default
real(default), parameter :: y_test_soft = 0.5_default
real(default), parameter :: y_test_coll = 0.9999999_default
@
@ Very soft or collinear phase-space points can become a problem for
matrix elements providers, as some scalar products cannot be evaluated
properly. Here, a nonsensical result can spoil the whole integration.
We therefore check the scalar products appearing to be below a certain
tolerance.\\
Naturally, this happens very rarely but for some processes,
setting [[?test_coll_limit = true]] and/or [[?test_soft_limit = true]]
leads to all phase space points beeing discarded by this routine.
<<phs fks: public>>=
public :: check_scalar_products
<<phs fks: procedures>>=
function check_scalar_products (p) result (valid)
logical :: valid
type(vector4_t), intent(in), dimension(:) :: p
real(default), parameter :: tolerance = 1E-7_default
integer :: i, j
valid = .true.
do i = 1, size (p)
do j = i, size (p)
if (i /= j) then
if (abs(p(i) * p(j)) < tolerance) then
valid = .false.
exit
end if
end if
end do
end do
end function check_scalar_products
@ %def check_scalar_products
@ [[xi_min]] should be set to a non-zero value in order to avoid
phase-space points with [[p_real(emitter) = 0]].
<<phs fks: public>>=
public :: phs_fks_generator_t
<<phs fks: types>>=
type :: phs_fks_generator_t
integer, dimension(:), allocatable :: emitters
type(real_kinematics_t), pointer :: real_kinematics => null()
type(isr_kinematics_t), pointer :: isr_kinematics => null()
integer :: n_in
real(default) :: xi_min
real(default) :: y_max
real(default) :: sqrts
real(default) :: E_gluon
real(default) :: mrec2
real(default), dimension(:), allocatable :: m2
logical :: massive_phsp = .false.
logical, dimension(:), allocatable :: is_massive
logical :: singular_jacobian = .false.
integer :: i_fsr_first = -1
type(resonance_contributors_t), dimension(:), allocatable :: resonance_contributors !!! Put somewhere else?
integer :: mode = GEN_REAL_PHASE_SPACE
contains
<<phs fks: phs fks generator: TBP>>
end type phs_fks_generator_t
@ %def phs_fks_generator_t
@
<<phs fks: phs fks generator: TBP>>=
procedure :: connect_kinematics => phs_fks_generator_connect_kinematics
<<phs fks: procedures>>=
subroutine phs_fks_generator_connect_kinematics &
(generator, isr_kinematics, real_kinematics, massive_phsp)
class(phs_fks_generator_t), intent(inout) :: generator
type(isr_kinematics_t), intent(in), pointer :: isr_kinematics
type(real_kinematics_t), intent(in), pointer :: real_kinematics
logical, intent(in) :: massive_phsp
generator%real_kinematics => real_kinematics
generator%isr_kinematics => isr_kinematics
generator%massive_phsp = massive_phsp
end subroutine phs_fks_generator_connect_kinematics
@ %def phs_fks_generator_connect_kinematics
@
<<phs fks: phs fks generator: TBP>>=
procedure :: compute_isr_kinematics => phs_fks_generator_compute_isr_kinematics
<<phs fks: procedures>>=
subroutine phs_fks_generator_compute_isr_kinematics (generator, r, p_in)
class(phs_fks_generator_t), intent(inout) :: generator
real(default), intent(in) :: r
type(vector4_t), dimension(2), intent(in), optional :: p_in
integer :: em
type(vector4_t), dimension(2) :: p
if (present (p_in)) then
p = p_in
else
p = generator%real_kinematics%p_born_lab%phs_point(1)%p(1:2)
end if
associate (isr_kinematics => generator%isr_kinematics)
do em = 1, 2
isr_kinematics%x(em) = p(em)%p(0) / isr_kinematics%beam_energy(em)
isr_kinematics%z(em) = one - (one - isr_kinematics%x(em)) * r
isr_kinematics%jacobian(em) = one - isr_kinematics%x(em)
end do
isr_kinematics%sqrts_born = (p(1) + p(2))**1
end associate
end subroutine phs_fks_generator_compute_isr_kinematics
@ %def phs_fks_generator_compute_isr_kinematics
@
<<phs fks: phs fks generator: TBP>>=
procedure :: final => phs_fks_generator_final
<<phs fks: procedures>>=
subroutine phs_fks_generator_final (generator)
class(phs_fks_generator_t), intent(inout) :: generator
if (allocated (generator%emitters)) deallocate (generator%emitters)
if (associated (generator%real_kinematics)) nullify (generator%real_kinematics)
if (associated (generator%isr_kinematics)) nullify (generator%isr_kinematics)
if (allocated (generator%m2)) deallocate (generator%m2)
generator%massive_phsp = .false.
if (allocated (generator%is_massive)) deallocate (generator%is_massive)
generator%singular_jacobian = .false.
generator%i_fsr_first = -1
if (allocated (generator%resonance_contributors)) &
deallocate (generator%resonance_contributors)
generator%mode = GEN_REAL_PHASE_SPACE
end subroutine phs_fks_generator_final
@ %def phs_fks_generator_final
@ A resonance phase space is uniquely specified via the resonance contributors and the
corresponding emitters. The [[phs_identifier]] type also checks whether
the given contributor-emitter configuration has already been evaluated to
avoid duplicate computations.
<<phs fks: public>>=
public :: phs_identifier_t
<<phs fks: types>>=
type :: phs_identifier_t
integer, dimension(:), allocatable :: contributors
integer :: emitter = -1
logical :: evaluated = .false.
contains
<<phs fks: phs identifier: TBP>>
end type phs_identifier_t
@ %def phs_identifier_t
@
<<phs fks: phs identifier: TBP>>=
generic :: init => init_from_emitter, init_from_emitter_and_contributors
procedure :: init_from_emitter => phs_identifier_init_from_emitter
procedure :: init_from_emitter_and_contributors &
=> phs_identifier_init_from_emitter_and_contributors
<<phs fks: procedures>>=
subroutine phs_identifier_init_from_emitter (phs_id, emitter)
class(phs_identifier_t), intent(out) :: phs_id
integer, intent(in) :: emitter
phs_id%emitter = emitter
end subroutine phs_identifier_init_from_emitter
subroutine phs_identifier_init_from_emitter_and_contributors &
(phs_id, emitter, contributors)
class(phs_identifier_t), intent(out) :: phs_id
integer, intent(in) :: emitter
integer, intent(in), dimension(:) :: contributors
allocate (phs_id%contributors (size (contributors)))
phs_id%contributors = contributors
phs_id%emitter = emitter
end subroutine phs_identifier_init_from_emitter_and_contributors
@ %def phs_identifier_init_from_emitter
@ %def phs_identifier_init_from_emitter_and_contributors
@
<<phs fks: phs identifier: TBP>>=
procedure :: check => phs_identifier_check
<<phs fks: procedures>>=
function phs_identifier_check (phs_id, emitter, contributors) result (check)
logical :: check
class(phs_identifier_t), intent(in) :: phs_id
integer, intent(in) :: emitter
integer, intent(in), dimension(:), optional :: contributors
check = phs_id%emitter == emitter
if (present (contributors)) then
if (.not. allocated (phs_id%contributors)) &
call msg_fatal ("Phs identifier: contributors not allocated!")
check = check .and. all (phs_id%contributors == contributors)
end if
end function phs_identifier_check
@ %def phs_identifier_check
@
<<phs fks: phs identifier: TBP>>=
procedure :: write => phs_identifier_write
<<phs fks: procedures>>=
subroutine phs_identifier_write (phs_id, unit)
class(phs_identifier_t), intent(in) :: phs_id
integer, intent(in), optional :: unit
integer :: u, i
u = given_output_unit (unit); if (u < 0) return
write (u, '(A)') 'phs_identifier: '
write (u, '(A,1X,I1)') 'Emitter: ', phs_id%emitter
if (allocated (phs_id%contributors)) then
write (u, '(A)', advance = 'no') 'Resonance contributors: '
do i = 1, size (phs_id%contributors)
write (u, '(I1,1X)', advance = 'no') phs_id%contributors(i)
end do
else
write (u, '(A)') 'No Contributors allocated'
end if
end subroutine phs_identifier_write
@ %def phs_identifier_write
@
<<phs fks: public>>=
public :: check_for_phs_identifier
<<phs fks: procedures>>=
subroutine check_for_phs_identifier (phs_id, n_in, emitter, contributors, phs_exist, i_phs)
type(phs_identifier_t), intent(in), dimension(:) :: phs_id
integer, intent(in) :: n_in, emitter
integer, intent(in), dimension(:), optional :: contributors
logical, intent(out) :: phs_exist
integer, intent(out) :: i_phs
integer :: i
phs_exist = .false.
i_phs = -1
do i = 1, size (phs_id)
if (phs_id(i)%emitter < 0) then
i_phs = i
exit
end if
phs_exist = phs_id(i)%emitter == emitter
if (present (contributors)) &
phs_exist = phs_exist .and. all (phs_id(i)%contributors == contributors)
if (phs_exist) then
i_phs = i
exit
end if
end do
end subroutine check_for_phs_identifier
@ %def check_for_phs_identifier
@
@ The fks phase space type contains the wood phase space and
separately the in- and outcoming momenta for the real process and the
corresponding Born momenta. Additionally, there are the variables
$\xi$,$\xi_{max}$, $y$ and $\phi$ which are used to create the real
phase space, as well as the jacobian and its corresponding soft and
collinear limit. Lastly, the array \texttt{ch\_to\_em} connects each
channel with an emitter.
<<phs fks: public>>=
public :: phs_fks_t
<<phs fks: types>>=
type, extends (phs_wood_t) :: phs_fks_t
integer :: mode = PHS_MODE_UNDEFINED
type(vector4_t), dimension(:), allocatable :: p_born
type(vector4_t), dimension(:), allocatable :: q_born
type(vector4_t), dimension(:), allocatable :: p_real
type(vector4_t), dimension(:), allocatable :: q_real
type(vector4_t), dimension(:), allocatable :: p_born_tot
type(phs_fks_generator_t) :: generator
real(default) :: r_isr
type(phs_identifier_t), dimension(:), allocatable :: phs_identifiers
contains
<<phs fks: phs fks: TBP>>
end type phs_fks_t
@ %def phs_fks_t
@
<<phs fks: interfaces>>=
interface compute_beta
module procedure compute_beta_massless
module procedure compute_beta_massive
end interface
interface get_xi_max_fsr
module procedure get_xi_max_fsr_massless
module procedure get_xi_max_fsr_massive
end interface
@ %def interfaces
@
<<phs fks: phs fks: TBP>>=
procedure :: write => phs_fks_write
<<phs fks: procedures>>=
subroutine phs_fks_write (object, unit, verbose)
class(phs_fks_t), intent(in) :: object
integer, intent(in), optional :: unit
logical, intent(in), optional :: verbose
integer :: u, i, n_id
u = given_output_unit (unit)
call object%base_write ()
n_id = size (object%phs_identifiers)
if (n_id == 0) then
write (u, "(A)") "No phs identifiers allocated! "
else
do i = 1, n_id
call object%phs_identifiers(i)%write (u)
end do
end if
end subroutine phs_fks_write
@ %def phs_fks_write
@ Initializer for the phase space. Calls the initialization of the
corresponding Born phase space, sets up the
channel-emitter-association and allocates space for the momenta.
<<phs fks: phs fks: TBP>>=
procedure :: init => phs_fks_init
<<phs fks: procedures>>=
subroutine phs_fks_init (phs, phs_config)
class(phs_fks_t), intent(out) :: phs
class(phs_config_t), intent(in), target :: phs_config
call phs%base_init (phs_config)
select type (phs_config)
type is (phs_fks_config_t)
phs%config => phs_config
phs%forest = phs_config%forest
end select
select type (phs)
type is (phs_fks_t)
select type (phs_config)
type is (phs_fks_config_t)
phs%mode = phs_config%mode
end select
select case (phs%mode)
case (PHS_MODE_ADDITIONAL_PARTICLE)
phs%n_r_born = phs%config%n_par - 3
case (PHS_MODE_COLLINEAR_REMNANT)
phs%n_r_born = phs%config%n_par - 1
end select
end select
end subroutine phs_fks_init
@ %def phs_fks_init
@ For real components of $2\to 1$ NLO processes we have to recompute the
flux factor as this has to be the one of the underlying Born.
<<phs fks: phs fks: TBP>>=
procedure :: compute_flux => phs_fks_compute_flux
<<phs fks: procedures>>=
subroutine phs_fks_compute_flux (phs)
class(phs_fks_t), intent(inout) :: phs
call phs%compute_base_flux ()
select type (config => phs%config)
type is (phs_fks_config_t)
if (config%born_2_to_1) then
phs%flux = conv * twopi &
/ (2 * config%sqrts ** 2 * phs%m_out(1) ** 2)
end if
end select
end subroutine phs_fks_compute_flux
@ %def phs_fks_compute_flux
@
<<phs fks: phs fks: TBP>>=
procedure :: allocate_momenta => phs_fks_allocate_momenta
<<phs fks: procedures>>=
subroutine phs_fks_allocate_momenta (phs, phs_config, data_is_born)
class(phs_fks_t), intent(inout) :: phs
class(phs_config_t), intent(in) :: phs_config
logical, intent(in) :: data_is_born
integer :: n_out_born
allocate (phs%p_born (phs_config%n_in))
allocate (phs%p_real (phs_config%n_in))
select case (phs%mode)
case (PHS_MODE_ADDITIONAL_PARTICLE)
if (data_is_born) then
n_out_born = phs_config%n_out
else
n_out_born = phs_config%n_out - 1
end if
allocate (phs%q_born (n_out_born))
allocate (phs%q_real (n_out_born + 1))
allocate (phs%p_born_tot (phs_config%n_in + n_out_born))
end select
end subroutine phs_fks_allocate_momenta
@ %def phs_fks_allocate_momenta
@ Evaluate selected channel. First, the subroutine calls the
evaluation procedure of the underlying Born phase space, using $n_r -
3$ random numbers. Then, the remaining three random numbers are used
to create $\xi$, $y$ and $\phi$, from which the real momenta are
calculated from the Born momenta.
<<phs fks: phs fks: TBP>>=
procedure :: evaluate_selected_channel => phs_fks_evaluate_selected_channel
<<phs fks: procedures>>=
subroutine phs_fks_evaluate_selected_channel (phs, c_in, r_in)
class(phs_fks_t), intent(inout) :: phs
integer, intent(in) :: c_in
real(default), intent(in), dimension(:) :: r_in
integer :: n_in
call phs%phs_wood_t%evaluate_selected_channel (c_in, r_in)
phs%r(:,c_in) = r_in
phs%q_defined = phs%phs_wood_t%q_defined
if (.not. phs%q_defined) return
select case (phs%mode)
case (PHS_MODE_ADDITIONAL_PARTICLE)
n_in = phs%config%n_in
phs%p_born = phs%phs_wood_t%p
phs%q_born = phs%phs_wood_t%q
phs%p_born_tot (1: n_in) = phs%p_born
phs%p_born_tot (n_in + 1 :) = phs%q_born
call phs%set_reference_frames (.true.)
call phs%set_isr_kinematics (.true.)
case (PHS_MODE_COLLINEAR_REMNANT)
call phs%compute_isr_kinematics (r_in(phs%n_r_born + 1))
phs%r_isr = r_in(phs%n_r_born + 1)
end select
end subroutine phs_fks_evaluate_selected_channel
@ %def phs_fks_evaluate_selected_channel
@
<<phs fks: phs fks: TBP>>=
procedure :: evaluate_other_channels => phs_fks_evaluate_other_channels
<<phs fks: procedures>>=
subroutine phs_fks_evaluate_other_channels (phs, c_in)
class(phs_fks_t), intent(inout) :: phs
integer, intent(in) :: c_in
call phs%phs_wood_t%evaluate_other_channels (c_in)
phs%r_defined = .true.
end subroutine phs_fks_evaluate_other_channels
@ %def phs_fks_evaluate_other_channels
@
<<phs fks: phs fks: TBP>>=
procedure :: get_mcpar => phs_fks_get_mcpar
<<phs fks: procedures>>=
subroutine phs_fks_get_mcpar (phs, c, r)
class(phs_fks_t), intent(in) :: phs
integer, intent(in) :: c
real(default), dimension(:), intent(out) :: r
r(1 : phs%n_r_born) = phs%r(1 : phs%n_r_born,c)
select case (phs%mode)
case (PHS_MODE_ADDITIONAL_PARTICLE)
r(phs%n_r_born + 1 :) = phs%r_real
case (PHS_MODE_COLLINEAR_REMNANT)
r(phs%n_r_born + 1 :) = phs%r_isr
end select
end subroutine phs_fks_get_mcpar
@ %def phs_fks_get_mcpar
@
<<phs fks: phs fks: TBP>>=
procedure :: set_beam_energy => phs_fks_set_beam_energy
<<phs fks: procedures>>=
subroutine phs_fks_set_beam_energy (phs)
class(phs_fks_t), intent(inout) :: phs
call phs%generator%set_sqrts_hat (phs%config%sqrts)
end subroutine phs_fks_set_beam_energy
@ %def phs_fks_set_beam_energy
@
<<phs fks: phs fks: TBP>>=
procedure :: set_emitters => phs_fks_set_emitters
<<phs fks: procedures>>=
subroutine phs_fks_set_emitters (phs, emitters)
class(phs_fks_t), intent(inout) :: phs
integer, intent(in), dimension(:), allocatable :: emitters
call phs%generator%set_emitters (emitters)
end subroutine phs_fks_set_emitters
@ %def phs_fks_set_emitters
@
<<phs fks: phs fks: TBP>>=
procedure :: set_momenta => phs_fks_set_momenta
<<phs fks: procedures>>=
subroutine phs_fks_set_momenta (phs, p)
class(phs_fks_t), intent(inout) :: phs
type(vector4_t), intent(in), dimension(:) :: p
integer :: n_in, n_tot_born
select case (phs%mode)
case (PHS_MODE_ADDITIONAL_PARTICLE)
n_in = phs%config%n_in; n_tot_born = phs%config%n_tot - 1
phs%p_born = p(1 : n_in)
phs%q_born = p(n_in + 1 : n_tot_born)
phs%p_born_tot = p
end select
end subroutine phs_fks_set_momenta
@ %def phs_fks_set_momenta
@
<<phs fks: phs fks: TBP>>=
procedure :: setup_masses => phs_fks_setup_masses
<<phs fks: procedures>>=
subroutine phs_fks_setup_masses (phs, n_tot)
class(phs_fks_t), intent(inout) :: phs
integer, intent(in) :: n_tot
call phs%generator%setup_masses (n_tot)
end subroutine phs_fks_setup_masses
@ %def phs_fks_setup_masses
@
<<phs fks: phs fks: TBP>>=
procedure :: get_born_momenta => phs_fks_get_born_momenta
<<phs fks: procedures>>=
subroutine phs_fks_get_born_momenta (phs, p)
class(phs_fks_t), intent(inout) :: phs
type(vector4_t), intent(out), dimension(:) :: p
select case (phs%mode)
case (PHS_MODE_ADDITIONAL_PARTICLE)
p(1 : phs%config%n_in) = phs%p_born
p(phs%config%n_in + 1 :) = phs%q_born
case (PHS_MODE_COLLINEAR_REMNANT)
p(1:phs%config%n_in) = phs%phs_wood_t%p
p(phs%config%n_in + 1 : ) = phs%phs_wood_t%q
end select
if (.not. phs%config%lab_is_cm) p = phs%lt_cm_to_lab * p
end subroutine phs_fks_get_born_momenta
@ %def phs_fks_get_born_momenta
@
<<phs fks: phs fks: TBP>>=
procedure :: get_outgoing_momenta => phs_fks_get_outgoing_momenta
<<phs fks: procedures>>=
subroutine phs_fks_get_outgoing_momenta (phs, q)
class(phs_fks_t), intent(in) :: phs
type(vector4_t), intent(out), dimension(:) :: q
select case (phs%mode)
case (PHS_MODE_ADDITIONAL_PARTICLE)
q = phs%q_real
case (PHS_MODE_COLLINEAR_REMNANT)
q = phs%phs_wood_t%q
end select
end subroutine phs_fks_get_outgoing_momenta
@ %def phs_fks_get_outgoing_momenta
@
<<phs fks: phs fks: TBP>>=
procedure :: get_incoming_momenta => phs_fks_get_incoming_momenta
<<phs fks: procedures>>=
subroutine phs_fks_get_incoming_momenta (phs, p)
class(phs_fks_t), intent(in) :: phs
type(vector4_t), intent(inout), dimension(:), allocatable :: p
p = phs%p_real
end subroutine phs_fks_get_incoming_momenta
@ %def phs_fks_get_incoming_momenta
@
<<phs fks: phs fks: TBP>>=
procedure :: set_isr_kinematics => phs_fks_set_isr_kinematics
<<phs fks: procedures>>=
subroutine phs_fks_set_isr_kinematics (phs, requires_boost)
class(phs_fks_t), intent(inout) :: phs
logical, intent(in) :: requires_boost
type(vector4_t), dimension(2) :: p
if (phs%generator%isr_kinematics%isr_mode == SQRTS_VAR) then
if (requires_boost) then
p = phs%lt_cm_to_lab * phs%generator%real_kinematics%p_born_cms%phs_point(1)%p(1:2)
else
p = phs%generator%real_kinematics%p_born_lab%phs_point(1)%p(1:2)
end if
call phs%generator%set_isr_kinematics (p)
end if
end subroutine phs_fks_set_isr_kinematics
@ %def phs_fks_set_isr_kinematics
@
<<phs fks: phs fks: TBP>>=
procedure :: generate_radiation_variables => &
phs_fks_generate_radiation_variables
<<phs fks: procedures>>=
subroutine phs_fks_generate_radiation_variables (phs, r_in, threshold)
class(phs_fks_t), intent(inout) :: phs
real(default), intent(in), dimension(:) :: r_in
logical, intent(in) :: threshold
type(vector4_t), dimension(:), allocatable :: p_born
if (size (r_in) /= 3) call msg_fatal &
("Real kinematics need to be generated using three random numbers!")
select case (phs%mode)
case (PHS_MODE_ADDITIONAL_PARTICLE)
allocate (p_born (size (phs%p_born_tot)))
if (threshold) then
p_born = phs%get_onshell_projected_momenta ()
else
p_born = phs%p_born_tot
if (.not. phs%lab_is_cm ()) &
p_born = inverse (phs%lt_cm_to_lab) * p_born
end if
call phs%generator%generate_radiation_variables &
(r_in, p_born, phs%phs_identifiers, threshold)
phs%r_real = r_in
end select
end subroutine phs_fks_generate_radiation_variables
@ %def phs_fks_generate_radiation_variables
@
<<phs fks: phs fks: TBP>>=
procedure :: compute_xi_ref_momenta => phs_fks_compute_xi_ref_momenta
<<phs fks: procedures>>=
subroutine phs_fks_compute_xi_ref_momenta (phs, p_in, contributors)
class(phs_fks_t), intent(inout) :: phs
type(vector4_t), intent(in), dimension(:), optional :: p_in
type(resonance_contributors_t), intent(in), dimension(:), optional :: contributors
if (phs%mode == PHS_MODE_ADDITIONAL_PARTICLE) then
if (present (p_in)) then
call phs%generator%compute_xi_ref_momenta (p_in, contributors)
else
call phs%generator%compute_xi_ref_momenta (phs%p_born_tot, contributors)
end if
end if
end subroutine phs_fks_compute_xi_ref_momenta
@ %def phs_fks_compute_xi_ref_momenta
@
<<phs fks: phs fks: TBP>>=
procedure :: compute_xi_ref_momenta_threshold => phs_fks_compute_xi_ref_momenta_threshold
<<phs fks: procedures>>=
subroutine phs_fks_compute_xi_ref_momenta_threshold (phs)
class(phs_fks_t), intent(inout) :: phs
select case (phs%mode)
case (PHS_MODE_ADDITIONAL_PARTICLE)
call phs%generator%compute_xi_ref_momenta_threshold &
(phs%get_onshell_projected_momenta ())
end select
end subroutine phs_fks_compute_xi_ref_momenta_threshold
@ %def phs_fks_compute_xi_ref_momenta
@
<<phs fks: phs fks: TBP>>=
procedure :: compute_cms_energy => phs_fks_compute_cms_energy
<<phs fks: procedures>>=
subroutine phs_fks_compute_cms_energy (phs)
class(phs_fks_t), intent(inout) :: phs
if (phs%mode == PHS_MODE_ADDITIONAL_PARTICLE) &
call phs%generator%compute_cms_energy (phs%p_born_tot)
end subroutine phs_fks_compute_cms_energy
@ %def phs_fks_compute_cms_energy
@ When initial-state radiation is involved, either due to beamstrahlung or
QCD/QED corrections, it is important to have access to both the phase
space points in the center-of-mass and lab frame.
<<phs fks: phs fks: TBP>>=
procedure :: set_reference_frames => phs_fks_set_reference_frames
<<phs fks: procedures>>=
subroutine phs_fks_set_reference_frames (phs, is_cms)
class(phs_fks_t), intent(inout) :: phs
logical, intent(in) :: is_cms
type(lorentz_transformation_t) :: lt
associate (real_kinematics => phs%generator%real_kinematics)
if (phs%config%lab_is_cm) then
real_kinematics%p_born_cms%phs_point(1)%p = phs%p_born_tot
real_kinematics%p_born_lab%phs_point(1)%p = phs%p_born_tot
else
if (is_cms) then
real_kinematics%p_born_cms%phs_point(1)%p = phs%p_born_tot
lt = phs%lt_cm_to_lab
real_kinematics%p_born_lab%phs_point(1)%p = &
lt * phs%p_born_tot
else
real_kinematics%p_born_lab%phs_point(1)%p = phs%p_born_tot
lt = inverse (phs%lt_cm_to_lab)
real_kinematics%p_born_cms%phs_point(1)%p = &
lt * phs%p_born_tot
end if
end if
end associate
end subroutine phs_fks_set_reference_frames
@ %def phs_fks_set_reference_frames
@
<<phs fks: phs fks: TBP>>=
procedure :: i_phs_is_isr => phs_fks_i_phs_is_isr
<<phs fks: procedures>>=
function phs_fks_i_phs_is_isr (phs, i_phs) result (is_isr)
logical :: is_isr
class(phs_fks_t), intent(in) :: phs
integer, intent(in) :: i_phs
is_isr = phs%phs_identifiers(i_phs)%emitter <= phs%generator%n_in
end function phs_fks_i_phs_is_isr
@ %def phs_fks_i_phs_is_isr
@
\subsection{Creation of the real phase space - FSR}
At this point, the Born phase space has been generated, as well as the
three random variables $\xi$, $y$ and $\phi$. The question is how the
real phase space is generated for a final-state emission
configuration. We work with two different sets of momenta, the Born
configuration $\Bigl\{ \bar{k}_{\oplus}, \bar{k}_{\ominus}, \bar{k}_{1}, ...,
\bar{k}_{n} \Bigr\}$ and the real configuration $\Bigl\{ k_{\oplus},
k_{\ominus}, k_1,..., k_n, k_{n+1} \Bigr\}$. We define the momentum of
the emitter to be on the $n$-th position and the momentum of the
radiated particle to be at position $n+1$. The magnitude of the
spatial component of k is denoted by $\underline{k}$.
For final-state emissions, it is $\bar{k}_\oplus = k_\oplus$ and
$\bar{k}_\ominus = k_\ominus$. Thus, the center-of-mass systems
coincide and it is
\begin{equation}
q = \sum_{i=1}^n \bar{k}_i = \sum_{i=1}^{n+1} k_i,
\end{equation}
with $\vec{q} = 0$ and $q^2 = \left(q^0\right)^2$.
We want to construct the real phase space from the Born phase space
using three random numbers. They are defined as follows:
\begin{itemize}
\item $\xi = \frac{2k_{n+1}^0}{\sqrt{s}} \in [0, \xi_{max}]$, where
$k_{n+1}$ denotes the four-momentum of the radiated particle.
\item $y = \cos\theta = \frac{\vec{k}_n \cdot
\vec{k}_{n+1}}{\underline{k}_n \underline{k}_{n+1}}$ is the
splitting angle.
\item The angle between tho two splitting particles in the transversal
plane, $phi \in [0,2\pi]$.
\end{itemize}
Further, $k_{rec} = \sum_{i=1}^{n-1} k_i$ denotes the sum of all
recoiling momenta.
<<phs fks: phs fks generator: TBP>>=
generic :: generate_fsr => generate_fsr_default, generate_fsr_resonances
<<phs fks: phs fks generator: TBP>>=
procedure :: generate_fsr_default => phs_fks_generator_generate_fsr_default
<<phs fks: procedures>>=
subroutine phs_fks_generator_generate_fsr_default (generator, emitter, i_phs, &
p_born, p_real, xi_y_phi, no_jacobians)
class(phs_fks_generator_t), intent(inout) :: generator
integer, intent(in) :: emitter, i_phs
type(vector4_t), intent(in), dimension(:) :: p_born
type(vector4_t), intent(inout), dimension(:) :: p_real
real(default), intent(in), dimension(3), optional :: xi_y_phi
logical, intent(in), optional :: no_jacobians
real(default) :: q0
call generator%generate_fsr_in (p_born, p_real)
q0 = sum (p_born(1:generator%n_in))**1
generator%i_fsr_first = generator%n_in + 1
call generator%generate_fsr_out (emitter, i_phs, p_born, p_real, q0, &
xi_y_phi = xi_y_phi, no_jacobians = no_jacobians)
if (debug_active (D_PHASESPACE)) then
call vector4_check_momentum_conservation (p_real, generator%n_in, &
rel_smallness = 1000 * tiny_07, abs_smallness = tiny_07)
end if
end subroutine phs_fks_generator_generate_fsr_default
@ %def phs_fks_generator_generate_fsr
@
<<phs fks: phs fks generator: TBP>>=
procedure :: generate_fsr_resonances => phs_fks_generator_generate_fsr_resonances
<<phs fks: procedures>>=
subroutine phs_fks_generator_generate_fsr_resonances (generator, &
emitter, i_phs, i_con, p_born, p_real, xi_y_phi, no_jacobians)
class(phs_fks_generator_t), intent(inout) :: generator
integer, intent(in) :: emitter, i_phs
integer, intent(in) :: i_con
type(vector4_t), intent(in), dimension(:) :: p_born
type(vector4_t), intent(inout), dimension(:) :: p_real
real(default), intent(in), dimension(3), optional :: xi_y_phi
logical, intent(in), optional :: no_jacobians
integer, dimension(:), allocatable :: resonance_list
integer, dimension(size(p_born)) :: inv_resonance_list
type(vector4_t), dimension(:), allocatable :: p_tmp_born
type(vector4_t), dimension(:), allocatable :: p_tmp_real
type(vector4_t) :: p_resonance
real(default) :: q0
integer :: i, j, nlegborn, nlegreal
integer :: i_emitter
type(lorentz_transformation_t) :: boost_to_resonance
integer :: n_resonant_particles
if (debug_on) call msg_debug2 (D_PHASESPACE, "phs_fks_generator_generate_fsr_resonances")
nlegborn = size (p_born); nlegreal = nlegborn + 1
allocate (resonance_list (size (generator%resonance_contributors(i_con)%c)))
resonance_list = generator%resonance_contributors(i_con)%c
n_resonant_particles = size (resonance_list)
if (.not. any (resonance_list == emitter)) then
call msg_fatal ("Emitter must be included in the resonance list!")
else
do i = 1, n_resonant_particles
if (resonance_list (i) == emitter) i_emitter = i
end do
end if
inv_resonance_list = &
create_inverse_resonance_list (nlegborn, resonance_list)
allocate (p_tmp_born (n_resonant_particles))
allocate (p_tmp_real (n_resonant_particles + 1))
p_tmp_born = vector4_null
p_tmp_real = vector4_null
j = 1
do i = 1, n_resonant_particles
p_tmp_born(j) = p_born(resonance_list(i))
j = j + 1
end do
call generator%generate_fsr_in (p_born, p_real)
p_resonance = generator%real_kinematics%xi_ref_momenta(i_con)
q0 = p_resonance**1
boost_to_resonance = inverse (boost (p_resonance, q0))
p_tmp_born = boost_to_resonance * p_tmp_born
generator%i_fsr_first = 1
call generator%generate_fsr_out (emitter, i_phs, p_tmp_born, p_tmp_real, &
q0, i_emitter, xi_y_phi)
p_tmp_real = inverse (boost_to_resonance) * p_tmp_real
do i = generator%n_in + 1, nlegborn
if (any (resonance_list == i)) then
p_real(i) = p_tmp_real(inv_resonance_list (i))
else
p_real(i) = p_born (i)
end if
end do
p_real(nlegreal) = p_tmp_real (n_resonant_particles + 1)
if (debug_active (D_PHASESPACE)) then
call vector4_check_momentum_conservation (p_real, generator%n_in, &
rel_smallness = 1000 * tiny_07, abs_smallness = tiny_07)
end if
contains
function create_inverse_resonance_list (nlegborn, resonance_list) &
result (inv_resonance_list)
integer, intent(in) :: nlegborn
integer, intent(in), dimension(:) :: resonance_list
integer, dimension(nlegborn) :: inv_resonance_list
integer :: i, j
inv_resonance_list = 0
j = 1
do i = 1, nlegborn
if (any (i == resonance_list)) then
inv_resonance_list (i) = j
j = j + 1
end if
end do
end function create_inverse_resonance_list
function boosted_energy () result (E)
real(default) :: E
type(vector4_t) :: p_boost
p_boost = boost_to_resonance * p_resonance
E = p_boost%p(0)
end function boosted_energy
end subroutine phs_fks_generator_generate_fsr_resonances
@ %def phs_fks_generator_generate_fsr_resonances
@
<<phs fks: phs fks generator: TBP>>=
procedure :: generate_fsr_threshold => phs_fks_generator_generate_fsr_threshold
<<phs fks: procedures>>=
subroutine phs_fks_generator_generate_fsr_threshold (generator, &
emitter, i_phs, p_born, p_real, xi_y_phi)
class(phs_fks_generator_t), intent(inout) :: generator
integer, intent(in) :: emitter, i_phs
type(vector4_t), intent(in), dimension(:) :: p_born
type(vector4_t), intent(inout), dimension(:) :: p_real
real(default), intent(in), dimension(3), optional :: xi_y_phi
type(vector4_t), dimension(2) :: p_tmp_born
type(vector4_t), dimension(3) :: p_tmp_real
integer :: nlegborn, nlegreal
type(vector4_t) :: p_top
real(default) :: q0
type(lorentz_transformation_t) :: boost_to_top
integer :: leg, other_leg
real(default) :: sqrts, mtop
if (debug_on) call msg_debug2 (D_PHASESPACE, "phs_fks_generator_generate_fsr_resonances")
nlegborn = size (p_born); nlegreal = nlegborn + 1
leg = thr_leg(emitter); other_leg = 3 - leg
p_tmp_born(1) = p_born (ass_boson(leg))
p_tmp_born(2) = p_born (ass_quark(leg))
call generator%generate_fsr_in (p_born, p_real)
p_top = generator%real_kinematics%xi_ref_momenta(leg)
q0 = p_top**1
sqrts = two * p_born(1)%p(0)
mtop = m1s_to_mpole (sqrts)
if (sqrts**2 - four * mtop**2 > zero) then
boost_to_top = inverse (boost (p_top, q0))
else
boost_to_top = identity
end if
p_tmp_born = boost_to_top * p_tmp_born
generator%i_fsr_first = 1
call generator%generate_fsr_out (emitter, i_phs, p_tmp_born, &
p_tmp_real, q0, 2, xi_y_phi)
p_tmp_real = inverse (boost_to_top) * p_tmp_real
p_real(ass_boson(leg)) = p_tmp_real(1)
p_real(ass_quark(leg)) = p_tmp_real(2)
p_real(ass_boson(other_leg)) = p_born(ass_boson(other_leg))
p_real(ass_quark(other_leg)) = p_born(ass_quark(other_leg))
p_real(THR_POS_GLUON) = p_tmp_real(3)
end subroutine phs_fks_generator_generate_fsr_threshold
@ %def phs_fks_generator_generate_fsr_threshold
@
<<phs fks: phs fks generator: TBP>>=
procedure :: generate_fsr_in => phs_fks_generator_generate_fsr_in
<<phs fks: procedures>>=
subroutine phs_fks_generator_generate_fsr_in (generator, p_born, p_real)
class(phs_fks_generator_t), intent(inout) :: generator
type(vector4_t), intent(in), dimension(:) :: p_born
type(vector4_t), intent(inout), dimension(:) :: p_real
integer :: i
do i = 1, generator%n_in
p_real(i) = p_born(i)
end do
end subroutine phs_fks_generator_generate_fsr_in
@ %def phs_fks_generator_generate_fsr_in
@
<<phs fks: phs fks generator: TBP>>=
procedure :: generate_fsr_out => phs_fks_generator_generate_fsr_out
<<phs fks: procedures>>=
subroutine phs_fks_generator_generate_fsr_out (generator, &
emitter, i_phs, p_born, p_real, q0, p_emitter_index, xi_y_phi, no_jacobians)
class(phs_fks_generator_t), intent(inout) :: generator
integer, intent(in) :: emitter, i_phs
type(vector4_t), intent(in), dimension(:) :: p_born
type(vector4_t), intent(inout), dimension(:) :: p_real
real(default), intent(in) :: q0
integer, intent(in), optional :: p_emitter_index
real(default), intent(in), dimension(3), optional :: xi_y_phi
logical, intent(in), optional :: no_jacobians
real(default) :: xi, y, phi
integer :: nlegborn, nlegreal
real(default) :: uk_np1, uk_n
real(default) :: uk_rec, k_rec0
type(vector3_t) :: k_n_born, k
real(default) :: uk_n_born, uk, k2, k0_n
real(default) :: cpsi, beta
type(vector3_t) :: vec, vec_orth
type(lorentz_transformation_t) :: rot
integer :: i, p_em
logical :: compute_jac
p_em = emitter; if (present (p_emitter_index)) p_em = p_emitter_index
compute_jac = .true.
if (present (no_jacobians)) compute_jac = .not. no_jacobians
if (generator%i_fsr_first < 0) &
call msg_fatal ("FSR generator is called for outgoing particles but "&
&"i_fsr_first is not set!")
if (present (xi_y_phi)) then
xi = xi_y_phi(I_XI)
y = xi_y_phi(I_Y)
phi = xi_y_phi(I_PHI)
else
associate (rad_var => generator%real_kinematics)
xi = rad_var%xi_tilde
if (rad_var%supply_xi_max) xi = xi * rad_var%xi_max(i_phs)
y = rad_var%y(i_phs)
phi = rad_var%phi
end associate
end if
nlegborn = size (p_born)
nlegreal = nlegborn + 1
generator%E_gluon = q0 * xi / two
uk_np1 = generator%E_gluon
k_n_born = p_born(p_em)%p(1:3)
uk_n_born = k_n_born**1
generator%mrec2 = (q0 - p_born(p_em)%p(0))**2 &
- space_part_norm(p_born(p_em))**2
if (generator%is_massive(emitter)) then
call generator%compute_emitter_kinematics (y, emitter, &
i_phs, q0, k0_n, uk_n, uk, compute_jac)
else
call generator%compute_emitter_kinematics (y, q0, uk_n, uk)
generator%real_kinematics%y_soft(i_phs) = y
k0_n = uk_n
end if
if (debug_on) call msg_debug2 (D_PHASESPACE, "phs_fks_generator_generate_fsr_out")
call debug_input_values ()
vec = uk_n / uk_n_born * k_n_born
vec_orth = create_orthogonal (vec)
p_real(p_em)%p(0) = k0_n
p_real(p_em)%p(1:3) = vec%p(1:3)
cpsi = (uk_n**2 + uk**2 - uk_np1**2) / (two * uk_n * uk)
!!! This is to catch the case where cpsi = 1, but numerically
!!! turns out to be slightly larger than 1.
call check_cpsi_bound (cpsi)
rot = rotation (cpsi, - sqrt (one - cpsi**2), vec_orth)
p_real(p_em) = rot * p_real(p_em)
vec = uk_np1 / uk_n_born * k_n_born
vec_orth = create_orthogonal (vec)
p_real(nlegreal)%p(0) = uk_np1
p_real(nlegreal)%p(1:3) = vec%p(1:3)
cpsi = (uk_np1**2 + uk**2 - uk_n**2) / (two * uk_np1 * uk)
call check_cpsi_bound (cpsi)
rot = rotation (cpsi, sqrt (one - cpsi**2), vec_orth)
p_real(nlegreal) = rot * p_real(nlegreal)
call construct_recoiling_momenta ()
if (compute_jac) call compute_jacobians ()
contains
<<phs fks: generator generate fsr out procedures>>
end subroutine phs_fks_generator_generate_fsr_out
@ %def phs_fks_generator_generate_fsr_out
@
<<phs fks: generator generate fsr out procedures>>=
subroutine debug_input_values ()
if (debug2_active (D_PHASESPACE)) then
call generator%write ()
print *, 'emitter = ', emitter
print *, 'p_born:'
call vector4_write_set (p_born)
print *, 'p_real:'
call vector4_write_set (p_real)
print *, 'q0 = ', q0
if (present(p_emitter_index)) then
print *, 'p_emitter_index = ', p_emitter_index
else
print *, 'p_emitter_index not given'
end if
end if
end subroutine debug_input_values
<<phs fks: generator generate fsr out procedures>>=
subroutine check_cpsi_bound (cpsi)
real(default), intent(inout) :: cpsi
if (cpsi > one) then
cpsi = one
else if (cpsi < -one) then
cpsi = - one
end if
end subroutine check_cpsi_bound
@ Construction of the recoiling momenta. The reshuffling of momenta
must not change the invariant mass of the recoiling system, which
means $k_{\rm{rec}}^2 = \bar{k_{\rm{rec}}}^2$. Therefore, the momenta
are related by a boost, $\bar{k}_i = \Lambda k_i$. The boost parameter
is
\begin{equation*}
\beta = \frac{q^2 - (k_{\rm{rec}}^0 +
\underline{k}_{\rm{rec}})^2}{q^2 + (k_{\rm{rec}}^0 +
\underline{k}_{\rm{rec}})^2}
\end{equation*}
<<phs fks: generator generate fsr out procedures>>=
subroutine construct_recoiling_momenta ()
type(lorentz_transformation_t) :: lambda
k_rec0 = q0 - p_real(p_em)%p(0) - p_real(nlegreal)%p(0)
if (k_rec0**2 > generator%mrec2) then
uk_rec = sqrt (k_rec0**2 - generator%mrec2)
else
uk_rec = 0
end if
if (generator%is_massive(emitter)) then
beta = compute_beta (q0**2, k_rec0, uk_rec, &
p_born(p_em)%p(0), uk_n_born)
else
beta = compute_beta (q0**2, k_rec0, uk_rec)
end if
k = p_real(p_em)%p(1:3) + p_real(nlegreal)%p(1:3)
vec%p(1:3) = one / uk * k%p(1:3)
lambda = boost (beta / sqrt(one - beta**2), vec)
do i = generator%i_fsr_first, nlegborn
if (i /= p_em) then
p_real(i) = lambda * p_born(i)
end if
end do
vec%p(1:3) = p_born(p_em)%p(1:3) / uk_n_born
rot = rotation (cos(phi), sin(phi), vec)
p_real(nlegreal) = rot * p_real(nlegreal)
p_real(p_em) = rot * p_real(p_em)
end subroutine construct_recoiling_momenta
@ The factor $\frac{q^2}{(4\pi)^3}$ is not included here since it is
supplied during phase space generation. Also, we already divide by
$\xi$.
<<phs fks: generator generate fsr out procedures>>=
subroutine compute_jacobians ()
associate (jac => generator%real_kinematics%jac(i_phs))
if (generator%is_massive(emitter)) then
jac%jac(1) = jac%jac(1) * four / q0 / uk_n_born / xi
else
k2 = two * uk_n * uk_np1* (one - y)
jac%jac(1) = uk_n**2 / uk_n_born / (uk_n - k2 / (two * q0))
end if
jac%jac(2) = one
jac%jac(3) = one - xi / two * q0 / uk_n_born
end associate
end subroutine compute_jacobians
@ %def compute_jacobians
@
<<phs fks: phs fks: TBP>>=
procedure :: generate_fsr_in => phs_fks_generate_fsr_in
<<phs fks: procedures>>=
subroutine phs_fks_generate_fsr_in (phs)
class(phs_fks_t), intent(inout) :: phs
type(vector4_t), dimension(:), allocatable :: p
p = phs%generator%real_kinematics%p_born_lab%get_momenta (1, phs%generator%n_in)
end subroutine phs_fks_generate_fsr_in
@ %def phs_fks_generate_fsr_in
@
<<phs fks: phs fks: TBP>>=
procedure :: generate_fsr => phs_fks_generate_fsr
<<phs fks: procedures>>=
subroutine phs_fks_generate_fsr (phs, emitter, i_phs, p_real, i_con, &
xi_y_phi, no_jacobians)
class(phs_fks_t), intent(inout) :: phs
integer, intent(in) :: emitter, i_phs
type(vector4_t), intent(inout), dimension(:) :: p_real
integer, intent(in), optional :: i_con
real(default), intent(in), dimension(3), optional :: xi_y_phi
logical, intent(in), optional :: no_jacobians
type(vector4_t), dimension(:), allocatable :: p
associate (generator => phs%generator)
allocate (p (1:generator%real_kinematics%p_born_cms%get_n_particles()), &
source = generator%real_kinematics%p_born_cms%phs_point(1)%p)
generator%real_kinematics%supply_xi_max = .true.
if (present (i_con)) then
call generator%generate_fsr (emitter, i_phs, i_con, p, p_real, &
xi_y_phi, no_jacobians)
else
call generator%generate_fsr (emitter, i_phs, p, p_real, &
xi_y_phi, no_jacobians)
end if
generator%real_kinematics%p_real_cms%phs_point(i_phs)%p = p_real
if (.not. phs%config%lab_is_cm) p_real = phs%lt_cm_to_lab * p_real
generator%real_kinematics%p_real_lab%phs_point(i_phs)%p = p_real
end associate
end subroutine phs_fks_generate_fsr
@ %def phs_fks_generate_fsr
@
<<phs fks: phs fks: TBP>>=
procedure :: get_onshell_projected_momenta => phs_fks_get_onshell_projected_momenta
<<phs fks: procedures>>=
pure function phs_fks_get_onshell_projected_momenta (phs) result (p)
type(vector4_t), dimension(:), allocatable :: p
class(phs_fks_t), intent(in) :: phs
p = phs%generator%real_kinematics%p_born_onshell%phs_point(1)%p
end function phs_fks_get_onshell_projected_momenta
@ %def phs_fks_get_onshell_projected_momenta
@
<<phs fks: phs fks: TBP>>=
procedure :: generate_fsr_threshold => phs_fks_generate_fsr_threshold
<<phs fks: procedures>>=
subroutine phs_fks_generate_fsr_threshold (phs, emitter, i_phs, p_real)
class(phs_fks_t), intent(inout) :: phs
integer, intent(in) :: emitter, i_phs
type(vector4_t), intent(inout), dimension(:), optional :: p_real
type(vector4_t), dimension(:), allocatable :: p_born
type(vector4_t), dimension(:), allocatable :: pp
integer :: leg
associate (generator => phs%generator)
generator%real_kinematics%supply_xi_max = .true.
allocate (p_born (1 : generator%real_kinematics%p_born_cms%get_n_particles()))
p_born = generator%real_kinematics%p_born_onshell%get_momenta (1)
allocate (pp (size (p_born) + 1))
call generator%generate_fsr_threshold (emitter, i_phs, p_born, pp)
leg = thr_leg (emitter)
call generator%real_kinematics%p_real_onshell(leg)%set_momenta (i_phs, pp)
if (present (p_real)) p_real = pp
end associate
end subroutine phs_fks_generate_fsr_threshold
@ %def phs_fks_generate_fsr_threshold
@
<<phs fks: phs fks: TBP>>=
generic :: compute_xi_max => compute_xi_max_internal, compute_xi_max_with_output
procedure :: compute_xi_max_internal => phs_fks_compute_xi_max_internal
<<phs fks: procedures>>=
subroutine phs_fks_compute_xi_max_internal (phs, p, threshold)
class(phs_fks_t), intent(inout) :: phs
type(vector4_t), intent(in), dimension(:) :: p
logical, intent(in) :: threshold
integer :: i_phs, i_con, emitter
do i_phs = 1, size (phs%phs_identifiers)
associate (phs_id => phs%phs_identifiers(i_phs), generator => phs%generator)
emitter = phs_id%emitter
if (threshold) then
call generator%compute_xi_max (emitter, i_phs, p, &
generator%real_kinematics%xi_max(i_phs), i_con = thr_leg(emitter))
else if (allocated (phs_id%contributors)) then
do i_con = 1, size (phs_id%contributors)
call generator%compute_xi_max (emitter, i_phs, p, &
generator%real_kinematics%xi_max(i_phs), i_con = 1)
end do
else
call generator%compute_xi_max (emitter, i_phs, p, &
generator%real_kinematics%xi_max(i_phs))
end if
end associate
end do
end subroutine phs_fks_compute_xi_max_internal
@ %def phs_fks_compute_xi_max
@
<<phs fks: phs fks: TBP>>=
procedure :: compute_xi_max_with_output => phs_fks_compute_xi_max_with_output
<<phs fks: procedures>>=
subroutine phs_fks_compute_xi_max_with_output (phs, emitter, i_phs, y, p, xi_max)
class(phs_fks_t), intent(inout) :: phs
integer, intent(in) :: i_phs, emitter
real(default), intent(in) :: y
type(vector4_t), intent(in), dimension(:) :: p
real(default), intent(out) :: xi_max
call phs%generator%compute_xi_max (emitter, i_phs, p, xi_max, y_in = y)
end subroutine phs_fks_compute_xi_max_with_output
@ %def phs_fks_compute_xi_max_with_output
@
<<phs fks: phs fks generator: TBP>>=
generic :: compute_emitter_kinematics => &
compute_emitter_kinematics_massless, &
compute_emitter_kinematics_massive
procedure :: compute_emitter_kinematics_massless => &
phs_fks_generator_compute_emitter_kinematics_massless
procedure :: compute_emitter_kinematics_massive => &
phs_fks_generator_compute_emitter_kinematics_massive
<<phs fks: procedures>>=
subroutine phs_fks_generator_compute_emitter_kinematics_massless &
(generator, y, q0, uk_em, uk)
class(phs_fks_generator_t), intent(inout) :: generator
real(default), intent(in) :: y, q0
real(default), intent(out) :: uk_em, uk
real(default) :: k0_np1, q2
k0_np1 = generator%E_gluon
q2 = q0**2
uk_em = (q2 - generator%mrec2 - two * q0 * k0_np1) / (two * (q0 - k0_np1 * (one - y)))
uk = sqrt (uk_em**2 + k0_np1**2 + two * uk_em * k0_np1 * y)
end subroutine phs_fks_generator_compute_emitter_kinematics_massless
subroutine phs_fks_generator_compute_emitter_kinematics_massive &
(generator, y, em, i_phs, q0, k0_em, uk_em, uk, compute_jac)
class(phs_fks_generator_t), intent(inout) :: generator
real(default), intent(in) :: y
integer, intent(in) :: em, i_phs
real(default), intent(in) :: q0
real(default), intent(inout) :: k0_em, uk_em, uk
logical, intent(in) :: compute_jac
real(default) :: k0_np1, q2, mrec2, m2
real(default) :: k0_rec_max, k0_em_max, k0_rec, uk_rec
real(default) :: z, z1, z2
k0_np1 = generator%E_gluon
q2 = q0**2
mrec2 = generator%mrec2
m2 = generator%m2(em)
k0_rec_max = (q2 - m2 + mrec2) / (two * q0)
k0_em_max = (q2 + m2 - mrec2) /(two * q0)
z1 = (k0_rec_max + sqrt (k0_rec_max**2 - mrec2)) / q0
z2 = (k0_rec_max - sqrt (k0_rec_max**2 - mrec2)) / q0
z = z2 - (z2 - z1) * (one + y) / two
k0_em = k0_em_max - k0_np1 * z
k0_rec = q0 - k0_np1 - k0_em
uk_em = sqrt(k0_em**2 - m2)
uk_rec = sqrt(k0_rec**2 - mrec2)
uk = uk_rec
if (compute_jac) &
generator%real_kinematics%jac(i_phs)%jac = q0 * (z1 - z2) / four * k0_np1
generator%real_kinematics%y_soft(i_phs) = &
(two * q2 * z - q2 - mrec2 + m2) / (sqrt(k0_em_max**2 - m2) * q0) / two
end subroutine phs_fks_generator_compute_emitter_kinematics_massive
@ %def phs_fks_generator_compute_emitter_kinematics
@
<<phs fks: procedures>>=
function recompute_xi_max (q0, mrec2, m2, y) result (xi_max)
real(default) :: xi_max
real(default), intent(in) :: q0, mrec2, m2, y
real(default) :: q2, k0_np1_max, k0_rec_max
real(default) :: z1, z2, z
q2 = q0**2
k0_rec_max = (q2 - m2 + mrec2) / (two * q0)
z1 = (k0_rec_max + sqrt (k0_rec_max**2 - mrec2)) / q0
z2 = (k0_rec_max - sqrt (k0_rec_max**2 - mrec2)) / q0
z = z2 - (z2 - z1) * (one + y) / 2
k0_np1_max = - (q2 * z**2 - two * q0 * k0_rec_max * z + mrec2) / (two * q0 * z * (one - z))
xi_max = two * k0_np1_max / q0
end function recompute_xi_max
@ %def recompute_xi_max
@
<<phs fks: procedures>>=
function compute_beta_massless (q2, k0_rec, uk_rec) result (beta)
real(default), intent(in) :: q2, k0_rec, uk_rec
real(default) :: beta
beta = (q2 - (k0_rec + uk_rec)**2) / (q2 + (k0_rec + uk_rec)**2)
end function compute_beta_massless
function compute_beta_massive (q2, k0_rec, uk_rec, &
k0_em_born, uk_em_born) result (beta)
real(default), intent(in) :: q2, k0_rec, uk_rec
real(default), intent(in) :: k0_em_born, uk_em_born
real(default) :: beta
real(default) :: k0_rec_born, uk_rec_born, alpha
k0_rec_born = sqrt(q2) - k0_em_born
uk_rec_born = uk_em_born
alpha = (k0_rec + uk_rec) / (k0_rec_born + uk_rec_born)
beta = (one - alpha**2) / (one + alpha**2)
end function compute_beta_massive
@ %def compute_beta
@ The momentum of the radiated particle is computed according to
\begin{equation}
\label{eq:phs fks:compute k_n}
\underline{k}_n = \frac{q^2 - M_{\rm{rec}}^2 -
2q^0\underline{k}_{n+1}}{2(q^0 - \underline{k}_{n+1}(1-y))},
\end{equation}
with $k = k_n + k_{n+1}$ and $M_{\rm{rec}}^2 = k_{\rm{rec}}^2 =
\left(q-k\right)^2$. Because of $\boldsymbol{\bar{k}}_n \parallel
\boldsymbol{k}_n + \boldsymbol{k}_{n+1}$ we find $M_{\rm{rec}}^2 =
\left(q-\bar{k}_n\right)^2$.
Equation \ref{eq:phs fks: compute k_n} follows from the fact that
$\left(\boldsymbol{k} - \boldsymbol{k}_n\right)^2 =
\boldsymbol{k}_{n+1}^2$, which is equivalent to $\boldsymbol{k}_n
\cdot \boldsymbol{k} = \frac{1}{2} \left(\underline{k}_n^2 +
\underline{k}^2 - \underline{k}_{n+1}^2\right)$.\\
$\boldsymbol{k}_n$ and $\boldsymbol{k}_{n+1}$ are obtained by first
setting up vectors parallel to $\boldsymbol{\bar{k}}_n$,
\begin{equation*}
\boldsymbol{k}_n' = \underline{k}_n
\frac{\bar{\pmb{k}}_n}{\underline{\bar{k}}_n}, \quad \pmb{k}_{n+1}'
= \underline{k}_{n+1}\frac{\bar{\pmb{k}}_n}{\underline{\bar{k}}_n},
\end{equation*}
and then rotating these vectors by an amount of $\cos\psi_n =
\frac{\boldsymbol{k}_n\cdot\pmb{k}}{\underline{k}_n \underline{k}}$.
@ The emitted particle cannot have more momentum than the emitter has
in the Born phase space. Thus, there is an upper bound for $\xi$,
determined by the condition $k_{n+1}^0 = \underline{\bar{k}}_n$, which
is equal to
\begin{equation*}
\xi_{\rm{max}} = \frac{2}{\underline{\bar{k}}_n}{q^0}.
\end{equation*}
<<phs fks: procedures>>=
pure function get_xi_max_fsr_massless (p_born, q0, emitter) result (xi_max)
type(vector4_t), intent(in), dimension(:) :: p_born
real(default), intent(in) :: q0
integer, intent(in) :: emitter
real(default) :: xi_max
real(default) :: uk_n_born
uk_n_born = space_part_norm (p_born(emitter))
xi_max = two * uk_n_born / q0
end function get_xi_max_fsr_massless
@ %def get_xi_max_fsr_massless
@ The computation of $\xi_{\rm{max}}$ for massive emitters is described
in arXiv:1202.0465. Let's recapitulate it here.
We consider the Dalitz-domain created by $k_{n+1}^0$, $k_n^0$ and
$k_{\rm{rec}}^0$ and introduce the parameterization
\begin{equation*}
k_n^0 = \bar{k}_n^0 - zk_{n+1}^0
\end{equation*}
Then, for each value of $z$, there exists a maximum value of
$\underline{k}_{n+1}$ from which $\xi_{\rm{max}}$ can be extracted via
$\xi_{\rm{max}} = 2k_{n+1}^0/q$. It is determined by the condition
\begin{equation*}
\underline{k}_{n+1} \pm \underline{k}_n \pm \underline{k}_{\rm{rec}} = 0.
\end{equation*}
This can be manipulated to yield
\begin{equation*}
\left(\underline{k}_{n+1}^2 + \underline{k}_n^2 -
\underline{k}_{\rm{rec}}^2\right)^2 =
4\underline{k}^2_{n+1}\underline{k}_n^2.
\end{equation*}
Here we can use $\underline{k}_n^2 = \left(k_n^0\right)^2 - m^2$ and
$\underline{k}_{\rm{rec}}^2 = \left(q - k_n^0 - k_{n+1}^0\right)^2 -
M_{\rm{rec}}^2$, as well as the above parameterization of $k_n^0$, to
obtain
\begin{equation*}
4\underline{k}_{n+1}^2\left(2\underline{k}_{n+1}qz(1-z) +
q^2z^2 - 2q\bar{k}_{\rm{rec}}^0z + M_{\rm{rec}}^2\right) = 0.
\end{equation*}
Solving for $k_{n+1}^0$ gives
\begin{equation}
k_{n+1}^0 = \frac{2q\bar{k}^0_{\rm{rec}}z - q^2z^2 - M_{\rm{rec}}^2}{2qz(1-z)}.
\label{XiMaxMassive}
\end{equation}
It is still open how to compute $z$. For this, consider that the
right-hand-side of equation (\ref{XiMaxMassive}) vanishes for
\begin{equation*}
z_{1,2} = \left(\bar{k}_{\rm{rec}}^0 \pm
\sqrt{\left(\bar{k}_{\rm{rec}}^0\right)^2 - M_{\rm{rec}}^2}\right)/q,
\end{equation*}
which corresponds to the borders of the Dalitz-region where the gluon
momentum vanishes. Thus we define
\begin{equation*}
z = z_2 - \frac{1}{2} (z_2 - z_1)(1+y).
\end{equation*}
<<phs fks: procedures>>=
pure function get_xi_max_fsr_massive (p_born, q0, emitter, m2, y) result (xi_max)
real(default) :: xi_max
type(vector4_t), intent(in), dimension(:) :: p_born
real(default), intent(in) :: q0
integer, intent(in) :: emitter
real(default), intent(in) :: m2, y
real(default) :: mrec2
real(default) :: k0_rec_max
real(default) :: z, z1, z2
real(default) :: k0_np1_max
associate (p => p_born(emitter)%p)
mrec2 = (q0 - p(0))**2 - p(1)**2 - p(2)**2 - p(3)**2
end associate
call compute_dalitz_bounds (q0, m2, mrec2, z1, z2, k0_rec_max)
z = z2 - (z2 - z1) * (one + y) / two
k0_np1_max = - (q0**2 * z**2 - two * q0 * k0_rec_max * z + mrec2) &
/ (two * q0 * z * (one - z))
xi_max = two * k0_np1_max / q0
end function get_xi_max_fsr_massive
@ %def get_xi_max_fsr_massive
@
<<phs fks: parameters>>=
integer, parameter, public :: I_PLUS = 1
integer, parameter, public :: I_MINUS = 2
@ %def parameters
@ Computes $\xi_{\text{max}}$ in the case of ISR as documented in eq. \ref{eqn:xi_max_isr}.
<<phs fks: procedures>>=
function get_xi_max_isr (xb, y) result (xi_max)
real(default) :: xi_max
real(default), dimension(2), intent(in) :: xb
real(default), intent(in) :: y
xi_max = one - max (xi_max_isr_plus (xb(I_PLUS), y), xi_max_isr_minus (xb(I_MINUS), y))
contains
function xi_max_isr_plus (x, y)
real(default) :: xi_max_isr_plus
real(default), intent(in) :: x, y
real(default) :: deno
deno = sqrt ((one + x**2)**2 * (one - y)**2 + 16 * y * x**2) + (one - y) * (1 - x**2)
xi_max_isr_plus = two * (one + y) * x**2 / deno
end function xi_max_isr_plus
function xi_max_isr_minus (x, y)
real(default) :: xi_max_isr_minus
real(default), intent(in) :: x, y
real(default) :: deno
deno = sqrt ((one + x**2)**2 * (one + y)**2 - 16 * y * x**2) + (one + y) * (1 - x**2)
xi_max_isr_minus = two * (one - y) * x**2 / deno
end function xi_max_isr_minus
end function get_xi_max_isr
@ %def get_xi_max_isr
@
<<phs fks: procedures>>=
recursive function get_xi_max_isr_decay (p) result (xi_max)
real(default) :: xi_max
type(vector4_t), dimension(:), intent(in) :: p
integer :: n_tot
type(vector4_t), dimension(:), allocatable :: p_dec_new
n_tot = size (p)
if (n_tot == 3) then
xi_max = xi_max_one_to_two (p(1), p(2), p(3))
else
allocate (p_dec_new (n_tot - 1))
p_dec_new(1) = sum (p (3 : ))
p_dec_new(2 : n_tot - 1) = p (3 : n_tot)
xi_max = min (xi_max_one_to_two (p(1), p(2), sum(p(3 : ))), &
get_xi_max_isr_decay (p_dec_new))
end if
contains
function xi_max_one_to_two (p_in, p_out1, p_out2) result (xi_max)
real(default) :: xi_max
type(vector4_t), intent(in) :: p_in, p_out1, p_out2
real(default) :: m_in, m_out1, m_out2
m_in = p_in**1
m_out1 = p_out1**1; m_out2 = p_out2**1
xi_max = one - (m_out1 + m_out2)**2 / m_in**2
end function xi_max_one_to_two
end function get_xi_max_isr_decay
@ %def get_xi_max_isr_decay
@
\subsection{Creation of the real phase space - ISR}
<<phs fks: phs fks: TBP>>=
procedure :: generate_isr => phs_fks_generate_isr
<<phs fks: procedures>>=
subroutine phs_fks_generate_isr (phs, i_phs, p_real)
class(phs_fks_t), intent(inout) :: phs
integer, intent(in) :: i_phs
type(vector4_t), intent(inout), dimension(:) :: p_real
type(vector4_t) :: p0, p1
type(lorentz_transformation_t) :: lt
real(default) :: sqrts_hat
type(vector4_t), dimension(:), allocatable :: p_work
associate (generator => phs%generator)
select case (generator%n_in)
case (1)
allocate (p_work (1:generator%real_kinematics%p_born_cms%get_n_particles()), &
source = generator%real_kinematics%p_born_cms%phs_point(1)%p)
call generator%generate_isr_fixed_beam_energy (i_phs, p_work, p_real)
phs%config%lab_is_cm = .true.
case (2)
select case (generator%isr_kinematics%isr_mode)
case (SQRTS_FIXED)
allocate (p_work (1:generator%real_kinematics%p_born_cms%get_n_particles()), &
source = generator%real_kinematics%p_born_cms%phs_point(1)%p)
call generator%generate_isr_fixed_beam_energy (i_phs, p_work, p_real)
case (SQRTS_VAR)
allocate (p_work (1:generator%real_kinematics%p_born_lab%get_n_particles()), &
source = generator%real_kinematics%p_born_lab%phs_point(1)%p)
call generator%generate_isr (i_phs, p_work, p_real)
end select
end select
generator%real_kinematics%p_real_lab%phs_point(i_phs)%p = p_real
if (.not. phs%config%lab_is_cm) then
sqrts_hat = (p_real(1) + p_real(2))**1
p0 = p_real(1) + p_real(2)
lt = boost (p0, sqrts_hat)
p1 = inverse(lt) * p_real(1)
lt = lt * rotation_to_2nd (3, space_part (p1))
phs%generator%real_kinematics%p_real_cms%phs_point(i_phs)%p = &
inverse (lt) * p_real
else
phs%generator%real_kinematics%p_real_cms%phs_point(i_phs)%p = p_real
end if
end associate
end subroutine phs_fks_generate_isr
@ %def phs_fks_generate_isr
@ The real phase space for an inital-state emission involved in a decay
process is generated by first setting the gluon momentum like in the
scattering case by using its angular coordinates $y$ and $\phi$ and then
adjusting the gluon energy with $\xi$. The emitter momentum is kept
identical to the Born case, i.e. $p_{\rm{in}} = \bar{p}_{\rm{in}}$, so
that after the emission it has momentum $p_{\rm{virt}} = p_{\rm{in}} -
p_{\rm{g}}$ and invariant mass $m^2 = p_{\rm{virt}}^2$. Note that the
final state momenta have to remain on-shell, so that $p_1^2 =
\bar{p}_1^2 = m_1^2$ and $p_2^2 = \bar{p}_2^2 = m_2^2$. Let $\Lambda$ be
the boost from into the rest frame of the emitter after emission, i.e.
$\Lambda p_{\rm{virt}} = \left(m, 0, 0, 0\right)$. In this reference
frame, the spatial components of the final-state momenta sum up to zero,
and their magnitude is
\begin{equation*}
p = \frac{\sqrt {\lambda (m^2, m_1^2, m_2^2)}}{2m},
\end{equation*}
a fact already used in the evaluation of the phase space trees of
[[phs_forest]]. Obviously, from this, the final-state energies can be
deferred via $E_i^2 = m_i^2 - p^2$. In the next step, the $p_{1,2}$ are
set up as vectors $(E,0,0,\pm p)$ along the z-axis and then rotated
about the same azimuthal and polar angles as in the Born system.
Finally, the momenta are boosted out of the rest frame by multiplying
with $\Lambda$.
<<phs fks: phs fks generator: TBP>>=
procedure :: generate_isr_fixed_beam_energy => &
phs_fks_generator_generate_isr_fixed_beam_energy
<<phs fks: procedures>>=
subroutine phs_fks_generator_generate_isr_fixed_beam_energy &
(generator, i_phs, p_born, p_real)
class(phs_fks_generator_t), intent(inout) :: generator
integer, intent(in) :: i_phs
type(vector4_t), intent(in), dimension(:) :: p_born
type(vector4_t), intent(inout), dimension(:) :: p_real
real(default) :: xi_max, xi, y, phi
integer :: nlegborn, nlegreal, i
real(default) :: k0_np1
real(default) :: msq_in
type(vector4_t) :: p_virt
real(default) :: jac_real
associate (rad_var => generator%real_kinematics)
xi_max = rad_var%xi_max(i_phs)
xi = rad_var%xi_tilde * xi_max
y = rad_var%y(i_phs)
phi = rad_var%phi
rad_var%y_soft(i_phs) = y
end associate
nlegborn = size (p_born)
nlegreal = nlegborn + 1
msq_in = sum (p_born(1:generator%n_in))**2
generator%real_kinematics%jac(i_phs)%jac = one
p_real(1) = p_born(1)
if (generator%n_in > 1) p_real(2) = p_born(2)
k0_np1 = zero
do i = 1, generator%n_in
k0_np1 = k0_np1 + p_real(i)%p(0) * xi / two
end do
p_real(nlegreal)%p(0) = k0_np1
p_real(nlegreal)%p(1) = k0_np1 * sqrt(one - y**2) * sin(phi)
p_real(nlegreal)%p(2) = k0_np1 * sqrt(one - y**2) * cos(phi)
p_real(nlegreal)%p(3) = k0_np1 * y
p_virt = sum (p_real(1:generator%n_in)) - p_real(nlegreal)
jac_real = one
call generate_on_shell_decay (p_virt, &
p_born(generator%n_in + 1 : nlegborn), p_real(generator%n_in + 1 : nlegreal - 1), &
1, msq_in, jac_real)
associate (jac => generator%real_kinematics%jac(i_phs))
jac%jac(1) = jac_real
jac%jac(2) = one
end associate
end subroutine phs_fks_generator_generate_isr_fixed_beam_energy
@ %def phs_fks_generator_generate_isr_fixed_beam_energy
@
<<phs fks: phs fks generator: TBP>>=
procedure :: generate_isr_factorized => phs_fks_generator_generate_isr_factorized
<<phs fks: procedures>>=
subroutine phs_fks_generator_generate_isr_factorized (generator, i_phs, emitter, p_born, p_real)
class(phs_fks_generator_t), intent(inout) :: generator
integer, intent(in) :: i_phs, emitter
type(vector4_t), intent(in), dimension(:) :: p_born
type(vector4_t), intent(inout), dimension(:) :: p_real
type(vector4_t), dimension(3) :: p_tmp_born
type(vector4_t), dimension(4) :: p_tmp_real
type(vector4_t) :: p_top
type(lorentz_transformation_t) :: boost_to_rest_frame
integer, parameter :: nlegreal = 7 !!! Factorized phase space so far only required for ee -> bwbw
p_tmp_born = vector4_null; p_tmp_real = vector4_null
p_real(1:2) = p_born(1:2)
if (emitter == THR_POS_B) then
p_top = p_born (THR_POS_WP) + p_born (THR_POS_B)
p_tmp_born(2) = p_born (THR_POS_WP)
p_tmp_born(3) = p_born (THR_POS_B)
else if (emitter == THR_POS_BBAR) then
p_top = p_born (THR_POS_WM) + p_born (THR_POS_BBAR)
p_tmp_born(2) = p_born (THR_POS_WM)
p_tmp_born(3) = p_born (THR_POS_BBAR)
else
call msg_fatal ("Threshold computation requires emitters to be at position 5 and 6 " // &
"Please check if your process specification fulfills this requirement.")
end if
p_tmp_born (1) = p_top
boost_to_rest_frame = inverse (boost (p_top, p_top**1))
p_tmp_born = boost_to_rest_frame * p_tmp_born
call generator%compute_xi_max_isr_factorized (i_phs, p_tmp_born)
call generator%generate_isr_fixed_beam_energy (i_phs, p_tmp_born, p_tmp_real)
p_tmp_real = inverse (boost_to_rest_frame) * p_tmp_real
if (emitter == THR_POS_B) then
p_real(THR_POS_WP) = p_tmp_real(2)
p_real(THR_POS_B) = p_tmp_real(3)
p_real(THR_POS_WM) = p_born(THR_POS_WM)
p_real(THR_POS_BBAR) = p_born(THR_POS_BBAR)
!!! Exception has been handled above
else
p_real(THR_POS_WM) = p_tmp_real(2)
p_real(THR_POS_BBAR) = p_tmp_real(3)
p_real(THR_POS_WP) = p_born(THR_POS_WP)
p_real(THR_POS_B) = p_born(THR_POS_B)
end if
p_real(nlegreal) = p_tmp_real(4)
end subroutine phs_fks_generator_generate_isr_factorized
@ %def phs_fks_generator_generate_isr_factorized
@ Construction of the real momenta [[p_real]] in case of ISR.
Follows the discussion in [0709.2092] sec. 5.1.
The sequence of Lorentz boosts required to construct [[p_real]] from [[p_born]] is as follows:
\begin{enumerate}
\item[\labelitemii] We construct the IS momenta of [[p_real]] from the Born momenta via rescaling:
[[p_real(1:2)]] $= \frac{x}{\overline{x}} \cdot$ [[p_born(1:2)]].
If the Born momenta are imported in the lab frame, these will define the real lab frame.
\item[\labelitemii] We construct the momentum of the radiated particle in the real CMS:
$k_{n+1} = \frac{s \xi}{2} \cdot (1, \sin(\theta) \sin(\phi), \sin(\theta) \cos(\phi), \cos(\theta))$
\setcounter{enumi}{-1}
\item We first boost the momentum of the radiated particle from the real CMS to the real
lab frame determined from [[p_real(1:2)]].
\item We initialize the non-radiated real FS momenta by a longitudinal boost of [[p_born]]
to a system with zero rapidity, i.e. zero longitudinal momenum. This is $\mathbb{B}_L$.
\item We boost these momenta in a transverse direction to compensate the transverse momentum
of the radiation.
This is $\mathbb{B}_T$. Note: we switched $\mathbb{B}_T$ and $\mathbb{B}^{-1}_T$ in Eq. (5.16) and
their definition w.r.t. [0709.2092].
\item We restore longitudinal momentum conservation by applying the inverse boost of $\mathbb{B}_L$
to all non-radiated real FS momenta.
\end{enumerate}
This way, all components of [[p_real]] are constructed in the real Lab frame.
<<phs fks: phs fks generator: TBP>>=
procedure :: generate_isr => phs_fks_generator_generate_isr
<<phs fks: procedures>>=
subroutine phs_fks_generator_generate_isr (generator, i_phs, p_born, p_real)
!!! Important: Import Born momenta in the lab frame
class(phs_fks_generator_t), intent(inout) :: generator
integer, intent(in) :: i_phs
type(vector4_t), intent(in) , dimension(:) :: p_born
type(vector4_t), intent(inout), dimension(:) :: p_real
real(default) :: xi_max, xi_tilde, xi, y, phi
integer :: nlegborn, nlegreal
real(default) :: sqrts_real
real(default) :: k0_np1
type(lorentz_transformation_t) :: lambda_transv, lambda_longit, lambda_longit_inv
real(default) :: x_plus, x_minus, xb_plus, xb_minus
real(default) :: onemy, onepy
integer :: i
real(default) :: xi_plus, xi_minus
real(default) :: beta_gamma
type(vector3_t) :: beta_vec
associate (rad_var => generator%real_kinematics)
xi_max = rad_var%xi_max(i_phs)
xi_tilde = rad_var%xi_tilde
xi = xi_tilde * xi_max
y = rad_var%y(i_phs)
onemy = one - y; onepy = one + y
phi = rad_var%phi
rad_var%y_soft(i_phs) = y
end associate
nlegborn = size (p_born)
nlegreal = nlegborn + 1
generator%isr_kinematics%sqrts_born = (p_born(1) + p_born(2))**1
!!! Initial state real momenta
xb_plus = generator%isr_kinematics%x(I_PLUS)
xb_minus = generator%isr_kinematics%x(I_MINUS)
x_plus = xb_plus / sqrt(one - xi) * sqrt ((two - xi * onemy) / (two - xi * onepy))
x_minus = xb_minus / sqrt(one - xi) * sqrt ((two - xi * onepy) / (two - xi * onemy))
xi_plus = xi_tilde * (one - xb_plus)
xi_minus = xi_tilde * (one - xb_minus)
p_real(I_PLUS) = x_plus / xb_plus * p_born(I_PLUS)
p_real(I_MINUS) = x_minus / xb_minus * p_born(I_MINUS)
!!! Fraction of momentum fractions in a collinear splitting
generator%isr_kinematics%z(I_PLUS) = (one - xi_plus)
generator%isr_kinematics%z(I_MINUS) = (one - xi_minus)
!!! Create radiation momentum in the real CMS
sqrts_real = generator%isr_kinematics%sqrts_born / sqrt (one - xi)
k0_np1 = sqrts_real * xi / two
p_real(nlegreal)%p(0) = k0_np1
p_real(nlegreal)%p(1) = k0_np1 * sqrt (one - y**2) * sin(phi)
p_real(nlegreal)%p(2) = k0_np1 * sqrt (one - y**2) * cos(phi)
p_real(nlegreal)%p(3) = k0_np1 * y
!!! Boosts the radiation from real CMS to the real LAB frame
call get_boost_parameters (p_real, beta_gamma, beta_vec)
lambda_longit = create_longitudinal_boost (beta_gamma, beta_vec, inverse = .true.)
p_real(nlegreal) = lambda_longit * p_real(nlegreal)
call get_boost_parameters (p_born, beta_gamma, beta_vec)
lambda_longit = create_longitudinal_boost (beta_gamma, beta_vec, inverse = .false.)
forall (i = 3 : nlegborn) p_real(i) = lambda_longit * p_born(i)
lambda_transv = create_transversal_boost (p_real(nlegreal), xi, sqrts_real)
forall (i = 3 : nlegborn) p_real(i) = lambda_transv * p_real(i)
lambda_longit_inv = create_longitudinal_boost (beta_gamma, beta_vec, inverse = .true.)
forall (i = 3 : nlegborn) p_real(i) = lambda_longit_inv * p_real(i)
!!! Compute Jacobians
associate (jac => generator%real_kinematics%jac(i_phs))
!!! Additional 1 / (1 - xi) factor because in the real jacobian,
!!! there is s_real in the numerator
!!! We also have to adapt the flux factor, which is 1/2s_real for the real component
!!! The reweighting factor is s_born / s_real, cancelling the (1-x) factor from above
jac%jac(1) = one / (one - xi)
jac%jac(2) = one
jac%jac(3) = one / (one - xi_plus)**2
jac%jac(4) = one / (one - xi_minus)**2
end associate
contains
subroutine get_boost_parameters (p, beta_gamma, beta_vec)
type(vector4_t), intent(in), dimension(:) :: p
real(default), intent(out) :: beta_gamma
type(vector3_t), intent(out) :: beta_vec
beta_vec = (p(1)%p(1:3) + p(2)%p(1:3)) / (p(1)%p(0) + p(2)%p(0))
beta_gamma = beta_vec**1 / sqrt (one - beta_vec**2)
beta_vec = beta_vec / beta_vec**1
end subroutine get_boost_parameters
function create_longitudinal_boost (beta_gamma, beta_vec, inverse) result (lambda)
real(default), intent(in) :: beta_gamma
type(vector3_t), intent(in) :: beta_vec
logical, intent(in) :: inverse
type(lorentz_transformation_t) :: lambda
if (inverse) then
lambda = boost (beta_gamma, beta_vec)
else
lambda = boost (-beta_gamma, beta_vec)
end if
end function create_longitudinal_boost
function create_transversal_boost (p_rad, xi, sqrts_real) result (lambda)
type(vector4_t), intent(in) :: p_rad
real(default), intent(in) :: xi, sqrts_real
type(lorentz_transformation_t) :: lambda
type(vector3_t) :: vec_transverse
real(default) :: pt2, beta, beta_gamma
pt2 = transverse_part (p_rad)**2
beta = one / sqrt (one + sqrts_real**2 * (one - xi) / pt2)
beta_gamma = beta / sqrt (one - beta**2)
vec_transverse%p(1:2) = p_rad%p(1:2)
vec_transverse%p(3) = zero
vec_transverse = normalize (vec_transverse)
lambda = boost (-beta_gamma, vec_transverse)
end function create_transversal_boost
end subroutine phs_fks_generator_generate_isr
@ %def phs_fks_generator_generate_isr
@
<<phs fks: phs fks generator: TBP>>=
procedure :: set_sqrts_hat => phs_fks_generator_set_sqrts_hat
<<phs fks: procedures>>=
subroutine phs_fks_generator_set_sqrts_hat (generator, sqrts)
class(phs_fks_generator_t), intent(inout) :: generator
real(default), intent(in) :: sqrts
generator%sqrts = sqrts
end subroutine phs_fks_generator_set_sqrts_hat
@ %def phs_fks_generator_set_sqrts_hat
@
<<phs fks: phs fks generator: TBP>>=
procedure :: set_emitters => phs_fks_generator_set_emitters
<<phs fks: procedures>>=
subroutine phs_fks_generator_set_emitters (generator, emitters)
class(phs_fks_generator_t), intent(inout) :: generator
integer, intent(in), dimension(:), allocatable :: emitters
allocate (generator%emitters (size (emitters)))
generator%emitters = emitters
end subroutine phs_fks_generator_set_emitters
@ %def phs_fks_generator_set_emitters
@
<<phs fks: phs fks generator: TBP>>=
procedure :: setup_masses => phs_fks_generator_setup_masses
<<phs fks: procedures>>=
subroutine phs_fks_generator_setup_masses (generator, n_tot)
class (phs_fks_generator_t), intent(inout) :: generator
integer, intent(in) :: n_tot
if (.not. allocated (generator%m2)) then
allocate (generator%is_massive (n_tot))
allocate (generator%m2 (n_tot))
generator%is_massive = .false.
generator%m2 = zero
end if
end subroutine phs_fks_generator_setup_masses
@ %def phs_fks_generator_setup_masses
@
<<phs fks: phs fks generator: TBP>>=
procedure :: set_xi_and_y_bounds => phs_fks_generator_set_xi_and_y_bounds
<<phs fks: procedures>>=
subroutine phs_fks_generator_set_xi_and_y_bounds (generator, fks_xi_min, fks_y_max)
class(phs_fks_generator_t), intent(inout) :: generator
real(default), intent(in), optional :: fks_xi_min, fks_y_max
real(default) :: xi_min, y_max
xi_min = zero; y_max = one
if (present (fks_xi_min)) xi_min = fks_xi_min
if (present (fks_y_max)) y_max = fks_y_max
generator%xi_min = min (one, max (xi_min, tiny_07))
generator%y_max = min (abs (y_max), one)
end subroutine phs_fks_generator_set_xi_and_y_bounds
@ %def phs_fks_generator_set_xi_and_y_bounds
@ Sets [[x]] in the [[isr_kinematics]] of the generator.
<<phs fks: phs fks generator: TBP>>=
procedure :: set_isr_kinematics => phs_fks_generator_set_isr_kinematics
<<phs fks: procedures>>=
subroutine phs_fks_generator_set_isr_kinematics (generator, p)
class(phs_fks_generator_t), intent(inout) :: generator
type(vector4_t), dimension(2), intent(in) :: p
if (allocated (generator%isr_kinematics%beam_energy)) then
select case (size (generator%isr_kinematics%beam_energy))
case (1)
generator%isr_kinematics%x = p%p(0) / &
generator%isr_kinematics%beam_energy(1)
case (2)
generator%isr_kinematics%x = p%p(0) / &
generator%isr_kinematics%beam_energy
end select
else
generator%isr_kinematics%x = 0
end if
end subroutine phs_fks_generator_set_isr_kinematics
@ %def phs_fks_generator_set_isr_kinematics
@
<<phs fks: phs fks generator: TBP>>=
procedure :: generate_radiation_variables => &
phs_fks_generator_generate_radiation_variables
<<phs fks: procedures>>=
subroutine phs_fks_generator_generate_radiation_variables &
(generator, r_in, p_born, phs_identifiers, threshold)
class(phs_fks_generator_t), intent(inout) :: generator
real(default), intent(in), dimension(:) :: r_in
type(vector4_t), intent(in), dimension(:) :: p_born
type(phs_identifier_t), intent(in), dimension(:) :: phs_identifiers
logical, intent(in), optional :: threshold
associate (rad_var => generator%real_kinematics)
rad_var%phi = r_in (I_PHI) * twopi
select case (generator%mode)
case (GEN_REAL_PHASE_SPACE)
rad_var%jac_rand = twopi
call generator%compute_y_real_phs (r_in(I_Y), p_born, phs_identifiers, &
rad_var%jac_rand, rad_var%y, threshold)
case (GEN_SOFT_MISMATCH)
rad_var%jac_mismatch = twopi
call generator%compute_y_mismatch (r_in(I_Y), rad_var%jac_mismatch, &
rad_var%y_mismatch, rad_var%y_soft)
case default
call generator%compute_y_test (rad_var%y)
end select
call generator%compute_xi_tilde (r_in(I_XI))
call generator%set_masses (p_born, phs_identifiers)
end associate
end subroutine phs_fks_generator_generate_radiation_variables
@ %def phs_fks_generator_generate_radiation_variables
@
<<phs fks: phs fks generator: TBP>>=
procedure :: compute_xi_ref_momenta => phs_fks_generator_compute_xi_ref_momenta
<<phs fks: procedures>>=
subroutine phs_fks_generator_compute_xi_ref_momenta &
(generator, p_born, resonance_contributors)
class(phs_fks_generator_t), intent(inout) :: generator
type(vector4_t), intent(in), dimension(:) :: p_born
type(resonance_contributors_t), intent(in), dimension(:), optional &
:: resonance_contributors
integer :: i_con, n_contributors
if (present (resonance_contributors)) then
n_contributors = size (resonance_contributors)
if (.not. allocated (generator%resonance_contributors)) &
allocate (generator%resonance_contributors (n_contributors))
do i_con = 1, n_contributors
generator%real_kinematics%xi_ref_momenta(i_con) = &
get_resonance_momentum (p_born, resonance_contributors(i_con)%c)
generator%resonance_contributors(i_con) = resonance_contributors(i_con)
end do
else
generator%real_kinematics%xi_ref_momenta(1) = sum (p_born(1:generator%n_in))
end if
end subroutine phs_fks_generator_compute_xi_ref_momenta
@ %def phs_fks_generator_compute_xi_ref_momenta
@
<<phs fks: phs fks generator: TBP>>=
procedure :: compute_xi_ref_momenta_threshold &
=> phs_fks_generator_compute_xi_ref_momenta_threshold
<<phs fks: procedures>>=
subroutine phs_fks_generator_compute_xi_ref_momenta_threshold (generator, p_born)
class(phs_fks_generator_t), intent(inout) :: generator
type(vector4_t), intent(in), dimension(:) :: p_born
generator%real_kinematics%xi_ref_momenta(1) = p_born(THR_POS_WP) + p_born(THR_POS_B)
generator%real_kinematics%xi_ref_momenta(2) = p_born(THR_POS_WM) + p_born(THR_POS_BBAR)
end subroutine phs_fks_generator_compute_xi_ref_momenta_threshold
@ %def phs_fks_generator_compute_xi_ref_momenta
@
<<phs fks: phs fks generator: TBP>>=
procedure :: compute_cms_energy => phs_fks_generator_compute_cms_energy
<<phs fks: procedures>>=
subroutine phs_fks_generator_compute_cms_energy (generator, p_born)
class(phs_fks_generator_t), intent(inout) :: generator
type(vector4_t), intent(in), dimension(:) :: p_born
type(vector4_t) :: p_sum
p_sum = sum (p_born (1 : generator%n_in))
generator%real_kinematics%cms_energy2 = p_sum**2
end subroutine phs_fks_generator_compute_cms_energy
@ %def phs_fks_generator_compute_cms_energy
@
<<phs fks: phs fks generator: TBP>>=
procedure :: compute_xi_max => phs_fks_generator_compute_xi_max
<<phs fks: procedures>>=
subroutine phs_fks_generator_compute_xi_max (generator, emitter, &
i_phs, p, xi_max, i_con, y_in)
class(phs_fks_generator_t), intent(inout) :: generator
integer, intent(in) :: i_phs, emitter
type(vector4_t), intent(in), dimension(:) :: p
real(default), intent(out) :: xi_max
integer, intent(in), optional :: i_con
real(default), intent(in), optional :: y_in
real(default) :: q0
type(vector4_t), dimension(:), allocatable :: pp, pp_decay
type(vector4_t) :: p_res
type(lorentz_transformation_t) :: L_to_resonance
real(default) :: y
if (.not. any (generator%emitters == emitter)) return
allocate (pp (size (p)))
associate (rad_var => generator%real_kinematics)
if (present (i_con)) then
q0 = rad_var%xi_ref_momenta(i_con)**1
else
q0 = energy (sum (p(1:generator%n_in)))
end if
if (present (y_in)) then
y = y_in
else
y = rad_var%y(i_phs)
end if
if (present (i_con)) then
p_res = rad_var%xi_ref_momenta(i_con)
L_to_resonance = inverse (boost (p_res, q0))
pp = L_to_resonance * p
else
pp = p
end if
if (emitter <= generator%n_in) then
select case (generator%isr_kinematics%isr_mode)
case (SQRTS_FIXED)
if (generator%n_in > 1) then
allocate (pp_decay (size (pp) - 1))
else
allocate (pp_decay (size (pp)))
end if
pp_decay (1) = sum (pp(1:generator%n_in))
pp_decay (2 : ) = pp (generator%n_in + 1 : )
xi_max = get_xi_max_isr_decay (pp_decay)
deallocate (pp_decay)
case (SQRTS_VAR)
xi_max = get_xi_max_isr (generator%isr_kinematics%x, y)
end select
else
if (generator%is_massive(emitter)) then
xi_max = get_xi_max_fsr (pp, q0, emitter, generator%m2(emitter), y)
else
xi_max = get_xi_max_fsr (pp, q0, emitter)
end if
end if
deallocate (pp)
end associate
end subroutine phs_fks_generator_compute_xi_max
@ %def phs_fks_generator_compute_xi_max
@
<<phs fks: phs fks generator: TBP>>=
procedure :: compute_xi_max_isr_factorized &
=> phs_fks_generator_compute_xi_max_isr_factorized
<<phs fks: procedures>>=
subroutine phs_fks_generator_compute_xi_max_isr_factorized &
(generator, i_phs, p)
class(phs_fks_generator_t), intent(inout) :: generator
integer, intent(in) :: i_phs
type(vector4_t), intent(in), dimension(:) :: p
generator%real_kinematics%xi_max(i_phs) = get_xi_max_isr_decay (p)
end subroutine phs_fks_generator_compute_xi_max_isr_factorized
@ %def phs_fks_generator_compute_xi_max_isr_factorized
@
<<phs fks: phs fks generator: TBP>>=
procedure :: set_masses => phs_fks_generator_set_masses
<<phs fks: procedures>>=
subroutine phs_fks_generator_set_masses (generator, p, phs_identifiers)
class(phs_fks_generator_t), intent(inout) :: generator
type(phs_identifier_t), intent(in), dimension(:) :: phs_identifiers
type(vector4_t), intent(in), dimension(:) :: p
integer :: emitter, i_phs
do i_phs = 1, size (phs_identifiers)
emitter = phs_identifiers(i_phs)%emitter
if (any (generator%emitters == emitter) .and. emitter > 0) then
if (generator%is_massive (emitter) .and. emitter > generator%n_in) &
generator%m2(emitter) = p(emitter)**2
end if
end do
end subroutine phs_fks_generator_set_masses
@ %def phs_fhs_generator_set_masses
@
<<phs fks: public>>=
public :: compute_y_from_emitter
<<phs fks: procedures>>=
subroutine compute_y_from_emitter (r_y, p, n_in, emitter, massive, &
y_max, jac_rand, y, contributors, threshold)
real(default), intent(in) :: r_y
type(vector4_t), intent(in), dimension(:) :: p
integer, intent(in) :: n_in
integer, intent(in) :: emitter
logical, intent(in) :: massive
real(default), intent(in) :: y_max
real(default), intent(inout) :: jac_rand
real(default), intent(out) :: y
integer, intent(in), dimension(:), allocatable, optional :: contributors
logical, intent(in), optional :: threshold
logical :: thr, resonance
type(vector4_t) :: p_res, p_em
real(default) :: q0
type(lorentz_transformation_t) :: boost_to_resonance
integer :: i
real(default) :: beta, one_m_beta, one_p_beta
thr = .false.; if (present (threshold)) thr = threshold
p_res = vector4_null
if (present (contributors)) then
resonance = allocated (contributors)
else
resonance = .false.
end if
if (massive) then
if (resonance) then
do i = 1, size (contributors)
p_res = p_res + p(contributors(i))
end do
else if (thr) then
p_res = p(ass_boson(thr_leg(emitter))) + p(ass_quark(thr_leg(emitter)))
else
p_res = sum (p(1:n_in))
end if
q0 = p_res**1
boost_to_resonance = inverse (boost (p_res, q0))
p_em = boost_to_resonance * p(emitter)
beta = beta_emitter (q0, p_em)
one_m_beta = one - beta
one_p_beta = one + beta
y = one / beta * (one - one_p_beta * &
exp ( - r_y * log(one_p_beta / one_m_beta)))
jac_rand = jac_rand * &
(one - beta * y) * log(one_p_beta / one_m_beta) / beta
else
y = (one - two * r_y) * y_max
jac_rand = jac_rand * 3 * (one - y**2)
y = 1.5_default * (y - y**3 / 3)
end if
end subroutine compute_y_from_emitter
@ %def compute_y_from_emitter
@
<<phs fks: phs fks generator: TBP>>=
procedure :: compute_y_real_phs => phs_fks_generator_compute_y_real_phs
<<phs fks: procedures>>=
subroutine phs_fks_generator_compute_y_real_phs (generator, r_y, p, phs_identifiers, &
jac_rand, y, threshold)
class(phs_fks_generator_t), intent(inout) :: generator
real(default), intent(in) :: r_y
type(vector4_t), intent(in), dimension(:) :: p
type(phs_identifier_t), intent(in), dimension(:) :: phs_identifiers
real(default), intent(inout), dimension(:) :: jac_rand
real(default), intent(out), dimension(:) :: y
logical, intent(in), optional :: threshold
real(default) :: beta, one_p_beta, one_m_beta
type(lorentz_transformation_t) :: boost_to_resonance
real(default) :: q0
type(vector4_t) :: p_res, p_em
integer :: i, i_phs, emitter
logical :: thr
logical :: construct_massive_fsr
construct_massive_fsr = .false.
thr = .false.; if (present (threshold)) thr = threshold
do i_phs = 1, size (phs_identifiers)
emitter = phs_identifiers(i_phs)%emitter
!!! We need this additional check because of decay phase spaces
!!! t -> bW has a massive emitter at position 1, which should
!!! not be treated here.
construct_massive_fsr = emitter > generator%n_in
if (construct_massive_fsr) construct_massive_fsr = &
construct_massive_fsr .and. generator%is_massive (emitter)
call compute_y_from_emitter (r_y, p, generator%n_in, emitter, construct_massive_fsr, &
generator%y_max, jac_rand(i_phs), y(i_phs), &
phs_identifiers(i_phs)%contributors, threshold)
end do
end subroutine phs_fks_generator_compute_y_real_phs
@ %def phs_fks_generator_compute_y_real_phs
@
<<phs fks: phs fks generator: TBP>>=
procedure :: compute_y_mismatch => phs_fks_generator_compute_y_mismatch
<<phs fks: procedures>>=
subroutine phs_fks_generator_compute_y_mismatch (generator, r_y, jac_rand, y, y_soft)
class(phs_fks_generator_t), intent(inout) :: generator
real(default), intent(in) :: r_y
real(default), intent(inout) :: jac_rand
real(default), intent(out) :: y
real(default), intent(out), dimension(:) :: y_soft
y = (one - two * r_y) * generator%y_max
jac_rand = jac_rand * 3 * (one - y**2)
y = 1.5_default * (y - y**3 / 3)
y_soft = y
end subroutine phs_fks_generator_compute_y_mismatch
@ %def phs_fks_generator_compute_y_mismatch
@
<<phs fks: phs fks generator: TBP>>=
procedure :: compute_y_test => phs_fks_generator_compute_y_test
<<phs fks: procedures>>=
subroutine phs_fks_generator_compute_y_test (generator, y)
class(phs_fks_generator_t), intent(inout) :: generator
real(default), intent(out), dimension(:):: y
select case (generator%mode)
case (GEN_SOFT_LIMIT_TEST)
y = y_test_soft
case (GEN_COLL_LIMIT_TEST)
y = y_test_coll
case (GEN_ANTI_COLL_LIMIT_TEST)
y = - y_test_coll
case (GEN_SOFT_COLL_LIMIT_TEST)
y = y_test_coll
case (GEN_SOFT_ANTI_COLL_LIMIT_TEST)
y = - y_test_coll
end select
end subroutine phs_fks_generator_compute_y_test
@ %def phs_fks_generator_compute_y_test
@
<<phs fks: public>>=
public :: beta_emitter
<<phs fks: procedures>>=
pure function beta_emitter (q0, p) result (beta)
real(default), intent(in) :: q0
type(vector4_t), intent(in) :: p
real(default) :: beta
real(default) :: m2, mrec2, k0_max
m2 = p**2
mrec2 = (q0 - p%p(0))**2 - p%p(1)**2 - p%p(2)**2 - p%p(3)**2
k0_max = (q0**2 - mrec2 + m2) / (two * q0)
beta = sqrt(one - m2 / k0_max**2)
end function beta_emitter
@ %def beta_emitter
@
<<phs fks: phs fks generator: TBP>>=
procedure :: compute_xi_tilde => phs_fks_generator_compute_xi_tilde
<<phs fks: procedures>>=
pure subroutine phs_fks_generator_compute_xi_tilde (generator, r)
class(phs_fks_generator_t), intent(inout) :: generator
real(default), intent(in) :: r
real(default) :: deno
associate (rad_var => generator%real_kinematics)
select case (generator%mode)
case (GEN_REAL_PHASE_SPACE)
if (generator%singular_jacobian) then
rad_var%xi_tilde = (one - generator%xi_min) - (one - r)**2 * &
(one - two * generator%xi_min)
rad_var%jac_rand = rad_var%jac_rand * two * (one - r) * &
(one - two * generator%xi_min)
else
rad_var%xi_tilde = generator%xi_min + r * (one - generator%xi_min)
rad_var%jac_rand = rad_var%jac_rand * (one - generator%xi_min)
end if
case (GEN_SOFT_MISMATCH)
deno = one - r
if (deno < tiny_13) deno = tiny_13
rad_var%xi_mismatch = generator%xi_min + r / deno
rad_var%jac_mismatch = rad_var%jac_mismatch / deno**2
case (GEN_SOFT_LIMIT_TEST)
rad_var%xi_tilde = r * two * xi_tilde_test_soft
rad_var%jac_rand = two * xi_tilde_test_soft
case (GEN_COLL_LIMIT_TEST)
rad_var%xi_tilde = xi_tilde_test_coll
rad_var%jac_rand = xi_tilde_test_coll
case (GEN_ANTI_COLL_LIMIT_TEST)
rad_var%xi_tilde = xi_tilde_test_coll
rad_var%jac_rand = xi_tilde_test_coll
case (GEN_SOFT_COLL_LIMIT_TEST)
rad_var%xi_tilde = r * two * xi_tilde_test_soft
rad_var%jac_rand = two * xi_tilde_test_soft
case (GEN_SOFT_ANTI_COLL_LIMIT_TEST)
rad_var%xi_tilde = r * two * xi_tilde_test_soft
rad_var%jac_rand = two * xi_tilde_test_soft
end select
end associate
end subroutine phs_fks_generator_compute_xi_tilde
@ %def phs_fks_generator_compute_xi_tilde
@
<<phs fks: phs fks generator: TBP>>=
procedure :: prepare_generation => phs_fks_generator_prepare_generation
<<phs fks: procedures>>=
subroutine phs_fks_generator_prepare_generation (generator, r_in, i_phs, &
emitter, p_born, phs_identifiers, contributors, i_con)
class(phs_fks_generator_t), intent(inout) :: generator
real(default), dimension(3), intent(in) :: r_in
integer, intent(in) :: i_phs, emitter
type(vector4_t), intent(in), dimension(:) :: p_born
type(phs_identifier_t), intent(in), dimension(:) :: phs_identifiers
type(resonance_contributors_t), intent(in), dimension(:), optional :: contributors
integer, intent(in), optional :: i_con
call generator%generate_radiation_variables (r_in, p_born, phs_identifiers)
call generator%compute_xi_ref_momenta &
(generator%real_kinematics%p_born_lab%phs_point(1)%p, contributors)
call generator%compute_xi_max (emitter, i_phs, p_born, &
generator%real_kinematics%xi_max(i_phs), i_con = i_con)
end subroutine phs_fks_generator_prepare_generation
@ %def phs_fks_generator_prepare_generation
@ Get [[xi]] and [[y]] from an external routine (e.g. [[powheg]]) and
generate an FSR phase space. Note that the flag [[supply_xi_max]] is
set to [[.false.]] because it is assumed that the upper bound on [[xi]]
has already been taken into account during its generation.
<<phs fks: phs fks generator: TBP>>=
procedure :: generate_fsr_from_xi_and_y => &
phs_fks_generator_generate_fsr_from_xi_and_y
<<phs fks: procedures>>=
subroutine phs_fks_generator_generate_fsr_from_xi_and_y (generator, xi, y, &
phi, emitter, i_phs, p_born, p_real)
class(phs_fks_generator_t), intent(inout) :: generator
real(default), intent(in) :: xi, y, phi
integer, intent(in) :: emitter, i_phs
type(vector4_t), intent(in), dimension(:) :: p_born
type(vector4_t), intent(inout), dimension(:) :: p_real
associate (rad_var => generator%real_kinematics)
rad_var%supply_xi_max = .false.
rad_var%xi_tilde = xi
rad_var%y(i_phs) = y
rad_var%phi = phi
end associate
call generator%set_sqrts_hat (p_born(1)%p(0) + p_born(2)%p(0))
call generator%generate_fsr (emitter, i_phs, p_born, p_real)
end subroutine phs_fks_generator_generate_fsr_from_xi_and_y
@ %def phs_fks_generator_generate_fsr_from_xi_and_y
@
<<phs fks: phs fks generator: TBP>>=
procedure :: get_radiation_variables => &
phs_fks_generator_get_radiation_variables
<<phs fks: procedures>>=
pure subroutine phs_fks_generator_get_radiation_variables (generator, &
i_phs, xi, y, phi)
class(phs_fks_generator_t), intent(in) :: generator
integer, intent(in) :: i_phs
real(default), intent(out) :: xi, y
real(default), intent(out), optional :: phi
associate (rad_var => generator%real_kinematics)
xi = rad_var%xi_max(i_phs) * rad_var%xi_tilde
y = rad_var%y(i_phs)
if (present (phi)) phi = rad_var%phi
end associate
end subroutine phs_fks_generator_get_radiation_variables
@ %def phs_fks_generator_get_radiation_variables
@
<<phs fks: phs fks generator: TBP>>=
procedure :: write => phs_fks_generator_write
<<phs fks: procedures>>=
subroutine phs_fks_generator_write (generator, unit)
class(phs_fks_generator_t), intent(in) :: generator
integer, intent(in), optional :: unit
integer :: u
type(string_t) :: massive_phsp
u = given_output_unit (unit); if (u < 0) return
if (generator%massive_phsp) then
massive_phsp = " massive "
else
massive_phsp = " massless "
end if
write (u, "(A)") char ("This is a generator for a" &
// massive_phsp // "phase space")
if (associated (generator%real_kinematics)) then
call generator%real_kinematics%write ()
else
write (u, "(A)") "Warning: There are no real " // &
"kinematics associated with this generator"
end if
call write_separator (u)
write (u, "(A," // FMT_17 // ",1X)") "sqrts: ", generator%sqrts
write (u, "(A," // FMT_17 // ",1X)") "E_gluon: ", generator%E_gluon
write (u, "(A," // FMT_17 // ",1X)") "mrec2: ", generator%mrec2
end subroutine phs_fks_generator_write
@ %def phs_fks_generator_write
@
<<phs fks: phs fks: TBP>>=
procedure :: compute_isr_kinematics => phs_fks_compute_isr_kinematics
<<phs fks: procedures>>=
subroutine phs_fks_compute_isr_kinematics (phs, r)
class(phs_fks_t), intent(inout) :: phs
real(default), intent(in) :: r
if (.not. phs%config%lab_is_cm) then
call phs%generator%compute_isr_kinematics (r, phs%lt_cm_to_lab * phs%phs_wood_t%p)
else
call phs%generator%compute_isr_kinematics (r, phs%phs_wood_t%p)
end if
end subroutine phs_fks_compute_isr_kinematics
@ %def phs_fks_compute_isr_kinematics
@
<<phs fks: phs fks: TBP>>=
procedure :: final => phs_fks_final
<<phs fks: procedures>>=
subroutine phs_fks_final (object)
class(phs_fks_t), intent(inout) :: object
call phs_forest_final (object%forest)
call object%generator%final ()
end subroutine phs_fks_final
@ %def phs_fks_final
@
<<phs fks: public>>=
public :: get_filtered_resonance_histories
<<phs fks: procedures>>=
subroutine filter_particles_from_resonances (res_hist, exclusion_list, &
model, res_hist_filtered)
type(resonance_history_t), intent(in), dimension(:) :: res_hist
type(string_t), intent(in), dimension(:) :: exclusion_list
type(model_t), intent(in) :: model
type(resonance_history_t), intent(out), dimension(:), allocatable :: res_hist_filtered
integer :: i_hist, i_flv, i_new, n_orig
logical, dimension(size (res_hist)) :: to_filter
type(flavor_t) :: flv
to_filter = .false.
n_orig = size (res_hist)
do i_flv = 1, size (exclusion_list)
call flv%init (exclusion_list (i_flv), model)
do i_hist = 1, size (res_hist)
if (res_hist(i_hist)%has_flavor (flv)) to_filter (i_hist) = .true.
end do
end do
allocate (res_hist_filtered (n_orig - count (to_filter)))
i_new = 1
do i_hist = 1, size (res_hist)
if (.not. to_filter (i_hist)) then
res_hist_filtered (i_new) = res_hist (i_hist)
i_new = i_new + 1
end if
end do
end subroutine filter_particles_from_resonances
@ %def filter_particles_from_resonances
@
<<phs fks: procedures>>=
subroutine clean_resonance_histories (res_hist, n_in, flv, res_hist_clean, success)
type(resonance_history_t), intent(in), dimension(:) :: res_hist
integer, intent(in) :: n_in
integer, intent(in), dimension(:) :: flv
type(resonance_history_t), intent(out), dimension(:), allocatable :: res_hist_clean
logical, intent(out) :: success
integer :: i_hist
type(resonance_history_t), dimension(:), allocatable :: res_hist_colored, res_hist_contracted
if (debug_on) call msg_debug (D_SUBTRACTION, "resonance_mapping_init")
if (debug_active (D_SUBTRACTION)) then
call msg_debug (D_SUBTRACTION, "Original resonances:")
do i_hist = 1, size(res_hist)
call res_hist(i_hist)%write ()
end do
end if
call remove_uncolored_resonances ()
call contract_resonances (res_hist_colored, res_hist_contracted)
call remove_subresonances (res_hist_contracted, res_hist_clean)
!!! Here, we are still not sure whether we actually would rather use
!!! call remove_multiple_resonances (res_hist_contracted, res_hist_clean)
if (debug_active (D_SUBTRACTION)) then
call msg_debug (D_SUBTRACTION, "Resonances after removing uncolored and duplicates: ")
do i_hist = 1, size (res_hist_clean)
call res_hist_clean(i_hist)%write ()
end do
end if
if (size (res_hist_clean) == 0) then
call msg_warning ("No resonances found. Proceed in usual FKS mode.")
success = .false.
else
success = .true.
end if
contains
subroutine remove_uncolored_resonances ()
type(resonance_history_t), dimension(:), allocatable :: res_hist_tmp
integer :: n_hist, nleg_out, n_removed
integer :: i_res, i_hist
n_hist = size (res_hist)
nleg_out = size (flv) - n_in
allocate (res_hist_tmp (n_hist))
allocate (res_hist_colored (n_hist))
do i_hist = 1, n_hist
res_hist_tmp(i_hist) = res_hist(i_hist)
call res_hist_tmp(i_hist)%add_offset (n_in)
n_removed = 0
do i_res = 1, res_hist_tmp(i_hist)%n_resonances
associate (resonance => res_hist_tmp(i_hist)%resonances(i_res - n_removed))
if (.not. any (is_colored (flv (resonance%contributors%c))) &
.or. size (resonance%contributors%c) == nleg_out) then
call res_hist_tmp(i_hist)%remove_resonance (i_res - n_removed)
n_removed = n_removed + 1
end if
end associate
end do
if (allocated (res_hist_tmp(i_hist)%resonances)) then
if (any (res_hist_colored == res_hist_tmp(i_hist))) then
cycle
else
do i_res = 1, res_hist_tmp(i_hist)%n_resonances
associate (resonance => res_hist_tmp(i_hist)%resonances(i_res))
call res_hist_colored(i_hist)%add_resonance (resonance)
end associate
end do
end if
end if
end do
end subroutine remove_uncolored_resonances
subroutine contract_resonances (res_history_in, res_history_out)
type(resonance_history_t), intent(in), dimension(:) :: res_history_in
type(resonance_history_t), intent(out), dimension(:), allocatable :: res_history_out
logical, dimension(:), allocatable :: i_non_zero
integer :: n_hist_non_zero, n_hist
integer :: i_hist_new
n_hist = size (res_history_in); n_hist_non_zero = 0
allocate (i_non_zero (n_hist))
i_non_zero = .false.
do i_hist = 1, n_hist
if (res_history_in(i_hist)%n_resonances /= 0) then
n_hist_non_zero = n_hist_non_zero + 1
i_non_zero(i_hist) = .true.
end if
end do
allocate (res_history_out (n_hist_non_zero))
i_hist_new = 1
do i_hist = 1, n_hist
if (i_non_zero (i_hist)) then
res_history_out (i_hist_new) = res_history_in (i_hist)
i_hist_new = i_hist_new + 1
end if
end do
end subroutine contract_resonances
subroutine remove_subresonances (res_history_in, res_history_out)
type(resonance_history_t), intent(in), dimension(:) :: res_history_in
type(resonance_history_t), intent(out), dimension(:), allocatable :: res_history_out
logical, dimension(:), allocatable :: i_non_sub_res
integer :: n_hist, n_hist_non_sub_res
integer :: i_hist1, i_hist2
logical :: is_not_subres
n_hist = size (res_history_in); n_hist_non_sub_res = 0
allocate (i_non_sub_res (n_hist)); i_non_sub_res = .false.
do i_hist1 = 1, n_hist
is_not_subres = .true.
do i_hist2 = 1, n_hist
if (i_hist1 == i_hist2) cycle
is_not_subres = is_not_subres .and. &
.not.(res_history_in(i_hist2) .contains. res_history_in(i_hist1))
end do
if (is_not_subres) then
n_hist_non_sub_res = n_hist_non_sub_res + 1
i_non_sub_res (i_hist1) = .true.
end if
end do
allocate (res_history_out (n_hist_non_sub_res))
i_hist2 = 1
do i_hist1 = 1, n_hist
if (i_non_sub_res (i_hist1)) then
res_history_out (i_hist2) = res_history_in (i_hist1)
i_hist2 = i_hist2 + 1
end if
end do
end subroutine remove_subresonances
subroutine remove_multiple_resonances (res_history_in, res_history_out)
type(resonance_history_t), intent(in), dimension(:) :: res_history_in
type(resonance_history_t), intent(out), dimension(:), allocatable :: res_history_out
integer :: n_hist, n_hist_single
logical, dimension(:), allocatable :: i_hist_single
integer :: i_hist, j
n_hist = size (res_history_in)
n_hist_single = 0
allocate (i_hist_single (n_hist)); i_hist_single = .false.
do i_hist = 1, n_hist
if (res_history_in(i_hist)%n_resonances == 1) then
n_hist_single = n_hist_single + 1
i_hist_single(i_hist) = .true.
end if
end do
allocate (res_history_out (n_hist_single))
j = 1
do i_hist = 1, n_hist
if (i_hist_single(i_hist)) then
res_history_out(j) = res_history_in(i_hist)
j = j + 1
end if
end do
end subroutine remove_multiple_resonances
end subroutine clean_resonance_histories
@ %def clean_resonance_histories
@
<<phs fks: procedures>>=
subroutine get_filtered_resonance_histories (phs_config, n_in, flv_state, model, &
excluded_resonances, resonance_histories_filtered, success)
type(phs_fks_config_t), intent(inout) :: phs_config
integer, intent(in) :: n_in
integer, intent(in), dimension(:,:), allocatable :: flv_state
type(model_t), intent(in) :: model
type(string_t), intent(in), dimension(:), allocatable :: excluded_resonances
type(resonance_history_t), intent(out), dimension(:), &
allocatable :: resonance_histories_filtered
logical, intent(out) :: success
type(resonance_history_t), dimension(:), allocatable :: resonance_histories
type(resonance_history_t), dimension(:), allocatable :: &
resonance_histories_clean!, resonance_histories_filtered
allocate (resonance_histories (size (phs_config%get_resonance_histories ())))
resonance_histories = phs_config%get_resonance_histories ()
call clean_resonance_histories (resonance_histories, &
n_in, flv_state (:,1), resonance_histories_clean, success)
if (success .and. allocated (excluded_resonances)) then
call filter_particles_from_resonances (resonance_histories_clean, &
excluded_resonances, model, resonance_histories_filtered)
else
allocate (resonance_histories_filtered (size (resonance_histories_clean)))
resonance_histories_filtered = resonance_histories_clean
end if
end subroutine get_filtered_resonance_histories
@ %def get_filtered_resonance_histories
@
\clearpage
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{Unit tests}
Test module for FKS phase space, followed by the corresponding implementation module.
<<[[phs_fks_ut.f90]]>>=
<<File header>>
module phs_fks_ut
use unit_tests
use phs_fks_uti
<<Standard module head>>
<<phs fks: public test>>
contains
<<phs fks: test driver>>
end module phs_fks_ut
@ %def phs_fks_ut
@
<<[[phs_fks_uti.f90]]>>=
<<File header>>
module phs_fks_uti
<<Use kinds>>
use format_utils, only: write_separator, pac_fmt
use format_defs, only: FMT_15, FMT_19
use numeric_utils, only: nearly_equal
use constants, only: tiny_07, zero, one, two
use lorentz
use physics_defs, only: THR_POS_B, THR_POS_BBAR, THR_POS_WP, THR_POS_WM, THR_POS_GLUON
use physics_defs, only: thr_leg
use resonances, only: resonance_contributors_t
use phs_fks
<<Standard module head>>
<<phs fks: test declarations>>
contains
<<phs fks: tests>>
end module phs_fks_uti
@ %def phs_fks_uti
@ API: driver for the unit tests below.
<<phs fks: public test>>=
public :: phs_fks_generator_test
<<phs fks: test driver>>=
subroutine phs_fks_generator_test (u, results)
integer, intent(in) :: u
type(test_results_t), intent(inout) :: results
call test(phs_fks_generator_1, "phs_fks_generator_1", &
"Test the generation of FKS phase spaces", u, results)
call test(phs_fks_generator_2, "phs_fks_generator_2", &
"Test the generation of an ISR FKS phase space", u, results)
call test(phs_fks_generator_3, "phs_fks_generator_3", &
"Test the generation of a real phase space for decays", &
u, results)
call test(phs_fks_generator_4, "phs_fks_generator_4", &
"Test the generation of an FSR phase space with "&
&"conserved invariant resonance masses", u, results)
call test(phs_fks_generator_5, "phs_fks_generator_5", &
"Test on-shell projection of a Born phase space and the generation"&
&" of a real phase-space from that", u, results)
call test(phs_fks_generator_6, "phs_fks_generator_6", &
"Test the generation of a real phase space for 1 -> 3 decays", &
u, results)
call test(phs_fks_generator_7, "phs_fks_generator_7", &
"Test the generation of an ISR FKS phase space for fixed beam energy", &
u, results)
end subroutine phs_fks_generator_test
@ %def phs_fks_generator_test
@
<<phs fks: test declarations>>=
public :: phs_fks_generator_1
<<phs fks: tests>>=
subroutine phs_fks_generator_1 (u)
integer, intent(in) :: u
type(phs_fks_generator_t) :: generator
type(vector4_t), dimension(:), allocatable :: p_born
type(vector4_t), dimension(:), allocatable :: p_real
integer :: emitter, i_phs
real(default) :: x1, x2, x3
real(default), parameter :: sqrts = 250.0_default
type(phs_identifier_t), dimension(2) :: phs_identifiers
write (u, "(A)") "* Test output: phs_fks_generator_1"
write (u, "(A)") "* Purpose: Create massless fsr phase space"
write (u, "(A)")
allocate (p_born (4))
p_born(1)%p(0) = 125.0_default
p_born(1)%p(1:2) = 0.0_default
p_born(1)%p(3) = 125.0_default
p_born(2)%p(0) = 125.0_default
p_born(2)%p(1:2) = 0.0_default
p_born(2)%p(3) = -125.0_default
p_born(3)%p(0) = 125.0_default
p_born(3)%p(1) = -39.5618_default
p_born(3)%p(2) = -20.0791_default
p_born(3)%p(3) = -114.6957_default
p_born(4)%p(0) = 125.0_default
p_born(4)%p(1:3) = -p_born(3)%p(1:3)
allocate (generator%isr_kinematics)
generator%n_in = 2
generator%isr_kinematics%isr_mode = SQRTS_FIXED
call generator%set_xi_and_y_bounds ()
call generator%set_sqrts_hat (sqrts)
write (u, "(A)") "* Use four-particle phase space containing: "
call vector4_write_set (p_born, u, testflag = .true., ultra = .true.)
write (u, "(A)") "***********************"
write (u, "(A)")
x1 = 0.5_default; x2 = 0.25_default; x3 = 0.75_default
write (u, "(A)" ) "* Use random numbers: "
write (u, "(A,F3.2,1X,A,F3.2,1X,A,F3.2)") &
"x1: ", x1, "x2: ", x2, "x3: ", x3
allocate (generator%real_kinematics)
call generator%real_kinematics%init (4, 2, 2, 1)
allocate (generator%emitters (2))
generator%emitters(1) = 3; generator%emitters(2) = 4
allocate (generator%m2 (4))
generator%m2 = zero
allocate (generator%is_massive (4))
generator%is_massive(1:2) = .false.
generator%is_massive(3:4) = .true.
phs_identifiers(1)%emitter = 3
phs_identifiers(2)%emitter = 4
call generator%compute_xi_ref_momenta (p_born)
call generator%generate_radiation_variables ([x1,x2,x3], p_born, phs_identifiers)
do i_phs = 1, 2
emitter = phs_identifiers(i_phs)%emitter
call generator%compute_xi_max (emitter, i_phs, p_born, &
generator%real_kinematics%xi_max(i_phs))
end do
write (u, "(A)") &
"* With these, the following radiation variables have been produced:"
associate (rad_var => generator%real_kinematics)
write (u, "(A,F3.2)") "xi_tilde: ", rad_var%xi_tilde
write (u, "(A,F3.2)") "y: " , rad_var%y(1)
write (u, "(A,F3.2)") "phi: ", rad_var%phi
end associate
call write_separator (u)
write (u, "(A)") "Produce real momenta: "
i_phs = 1; emitter = phs_identifiers(i_phs)%emitter
write (u, "(A,I1)") "emitter: ", emitter
allocate (p_real (5))
call generator%generate_fsr (emitter, i_phs, p_born, p_real)
call vector4_write_set (p_real, u, testflag = .true., ultra = .true.)
call write_separator (u)
write (u, "(A)")
write (u, "(A)") "* Test output end: phs_fks_generator_1"
end subroutine phs_fks_generator_1
@ %def phs_fks_generator_1
@
<<phs fks: test declarations>>=
public :: phs_fks_generator_2
<<phs fks: tests>>=
subroutine phs_fks_generator_2 (u)
integer, intent(in) :: u
type(phs_fks_generator_t) :: generator
type(vector4_t), dimension(:), allocatable :: p_born
type(vector4_t), dimension(:), allocatable :: p_real
integer :: emitter, i_phs
real(default) :: x1, x2, x3
real(default), parameter :: sqrts_hadronic = 250.0_default
type(phs_identifier_t), dimension(2) :: phs_identifiers
write (u, "(A)") "* Test output: phs_fks_generator_2"
write (u, "(A)") "* Purpose: Create massless ISR phase space"
write (u, "(A)")
allocate (p_born (4))
p_born(1)%p(0) = 114.661_default
p_born(1)%p(1:2) = 0.0_default
p_born(1)%p(3) = 114.661_default
p_born(2)%p(0) = 121.784_default
p_born(2)%p(1:2) = 0.0_default
p_born(2)%p(3) = -121.784_default
p_born(3)%p(0) = 115.148_default
p_born(3)%p(1) = -46.250_default
p_born(3)%p(2) = -37.711_default
p_born(3)%p(3) = 98.478_default
p_born(4)%p(0) = 121.296_default
p_born(4)%p(1:2) = -p_born(3)%p(1:2)
p_born(4)%p(3) = -105.601_default
phs_identifiers(1)%emitter = 1
phs_identifiers(2)%emitter = 2
allocate (generator%emitters (2))
allocate (generator%isr_kinematics)
generator%emitters(1) = 1; generator%emitters(2) = 2
generator%sqrts = sqrts_hadronic
allocate (generator%isr_kinematics%beam_energy(2))
generator%isr_kinematics%beam_energy = sqrts_hadronic / two
call generator%set_sqrts_hat (sqrts_hadronic)
call generator%set_isr_kinematics (p_born)
generator%n_in = 2
generator%isr_kinematics%isr_mode = SQRTS_VAR
call generator%set_xi_and_y_bounds ()
write (u, "(A)") "* Use four-particle phase space containing: "
call vector4_write_set (p_born, u, testflag = .true., ultra = .true.)
write (u, "(A)") "***********************"
write (u, "(A)")
x1=0.5_default; x2=0.25_default; x3=0.65_default
write (u, "(A)" ) "* Use random numbers: "
write (u, "(A,F3.2,1X,A,F3.2,1X,A,F3.2)") &
"x1: ", x1, "x2: ", x2, "x3: ", x3
allocate (generator%real_kinematics)
call generator%real_kinematics%init (4, 2, 2, 1)
call generator%real_kinematics%p_born_lab%set_momenta (1, p_born)
allocate (generator%m2 (2))
generator%m2(1) = 0._default; generator%m2(2) = 0._default
allocate (generator%is_massive (4))
generator%is_massive = .false.
call generator%generate_radiation_variables ([x1,x2,x3], p_born, phs_identifiers)
call generator%compute_xi_ref_momenta (p_born)
do i_phs = 1, 2
emitter = phs_identifiers(i_phs)%emitter
call generator%compute_xi_max (emitter, i_phs, p_born, &
generator%real_kinematics%xi_max(i_phs))
end do
write (u, "(A)") &
"* With these, the following radiation variables have been produced:"
associate (rad_var => generator%real_kinematics)
write (u, "(A,F3.2)") "xi_tilde: ", rad_var%xi_tilde
write (u, "(A,F3.2)") "y: " , rad_var%y(1)
write (u, "(A,F3.2)") "phi: ", rad_var%phi
end associate
write (u, "(A)") "Initial-state momentum fractions: "
associate (xb => generator%isr_kinematics%x)
write (u, "(A,F3.2)") "x_born_plus: ", xb(1)
write (u, "(A,F3.2)") "x_born_minus: ", xb(2)
end associate
call write_separator (u)
write (u, "(A)") "Produce real momenta: "
i_phs = 1; emitter = phs_identifiers(i_phs)%emitter
write (u, "(A,I1)") "emitter: ", emitter
allocate (p_real(5))
call generator%generate_isr (i_phs, p_born, p_real)
call vector4_write_set (p_real, u, testflag = .true., ultra = .true.)
call write_separator (u)
write (u, "(A)")
write (u, "(A)") "* Test output end: phs_fks_generator_2"
end subroutine phs_fks_generator_2
@ %def phs_fks_generator_2
@
<<phs fks: test declarations>>=
public :: phs_fks_generator_3
<<phs fks: tests>>=
subroutine phs_fks_generator_3 (u)
integer, intent(in) :: u
type(phs_fks_generator_t) :: generator
type(vector4_t), dimension(:), allocatable :: p_born
type(vector4_t), dimension(:), allocatable :: p_real
real(default) :: x1, x2, x3
real(default) :: mB, mW, mT
integer :: i, emitter, i_phs
type(phs_identifier_t), dimension(2) :: phs_identifiers
write (u, "(A)") "* Test output: phs_fks_generator_3"
write (u, "(A)") "* Puropse: Create real phase space for particle decays"
write (u, "(A)")
allocate (p_born(3))
p_born(1)%p(0) = 172._default
p_born(1)%p(1) = 0._default
p_born(1)%p(2) = 0._default
p_born(1)%p(3) = 0._default
p_born(2)%p(0) = 104.72866679_default
p_born(2)%p(1) = 45.028053213_default
p_born(2)%p(2) = 29.450337581_default
p_born(2)%p(3) = -5.910229156_default
p_born(3)%p(0) = 67.271333209_default
p_born(3)%p(1:3) = -p_born(2)%p(1:3)
generator%n_in = 1
allocate (generator%isr_kinematics)
generator%isr_kinematics%isr_mode = SQRTS_FIXED
call generator%set_xi_and_y_bounds ()
mB = 4.2_default
mW = 80.376_default
mT = 172._default
generator%sqrts = mT
write (u, "(A)") "* Use three-particle phase space containing: "
call vector4_write_set (p_born, u, testflag = .true., ultra = .true.)
write (u, "(A)") "**********************"
write (u, "(A)")
x1 = 0.5_default; x2 = 0.25_default; x3 = 0.6_default
write (u, "(A)") "* Use random numbers: "
write (u, "(A,F3.2,1X,A,F3.2,A,1X,F3.2)") &
"x1: ", x1, "x2: ", x2, "x3: ", x3
allocate (generator%real_kinematics)
call generator%real_kinematics%init (3, 2, 2, 1)
call generator%real_kinematics%p_born_lab%set_momenta (1, p_born)
allocate (generator%emitters(2))
generator%emitters(1) = 1
generator%emitters(2) = 3
allocate (generator%m2 (3), generator%is_massive(3))
generator%m2(1) = mT**2
generator%m2(2) = mW**2
generator%m2(3) = mB**2
generator%is_massive = .true.
phs_identifiers(1)%emitter = 1
phs_identifiers(2)%emitter = 3
call generator%generate_radiation_variables ([x1,x2,x3], p_born, phs_identifiers)
call generator%compute_xi_ref_momenta (p_born)
do i_phs = 1, 2
emitter = phs_identifiers(i_phs)%emitter
call generator%compute_xi_max (emitter, i_phs, p_born, &
generator%real_kinematics%xi_max(i_phs))
end do
write (u, "(A)") &
"* With these, the following radiation variables have been produced: "
associate (rad_var => generator%real_kinematics)
write (u, "(A,F4.2)") "xi_tilde: ", rad_var%xi_tilde
do i = 1, 2
write (u, "(A,I1,A,F5.2)") "i: ", i, "y: " , rad_var%y(i)
end do
write (u, "(A,F4.2)") "phi: ", rad_var%phi
end associate
call write_separator (u)
write (u, "(A)") "Produce real momenta via initial-state emission: "
i_phs = 1; emitter = phs_identifiers(i_phs)%emitter
write (u, "(A,I1)") "emitter: ", emitter
allocate (p_real (4))
call generator%generate_isr_fixed_beam_energy (i_phs, p_born, p_real)
call pacify (p_real, 1E-6_default)
call vector4_write_set (p_real, u, testflag = .true., ultra = .true.)
call write_separator(u)
write (u, "(A)") "Produce real momenta via final-state emisson: "
i_phs = 2; emitter = phs_identifiers(i_phs)%emitter
write (u, "(A,I1)") "emitter: ", emitter
call generator%generate_fsr (emitter, i_phs, p_born, p_real)
call pacify (p_real, 1E-6_default)
call vector4_write_set (p_real, u, testflag = .true., ultra = .true.)
write (u, "(A)")
write (u, "(A)") "* Test output end: phs_fks_generator_3"
end subroutine phs_fks_generator_3
@ %def phs_fks_generator_3
@
<<phs fks: test declarations>>=
public :: phs_fks_generator_4
<<phs fks: tests>>=
subroutine phs_fks_generator_4 (u)
integer, intent(in) :: u
type(phs_fks_generator_t) :: generator
type(vector4_t), dimension(:), allocatable :: p_born
type(vector4_t), dimension(:), allocatable :: p_real
integer, dimension(:), allocatable :: emitters
integer, dimension(:,:), allocatable :: resonance_lists
type(resonance_contributors_t), dimension(2) :: alr_contributors
real(default) :: x1, x2, x3
real(default), parameter :: sqrts = 250.0_default
integer, parameter :: nlegborn = 6
integer :: i_phs, i_con, emitter
real(default) :: m_inv_born, m_inv_real
character(len=7) :: fmt
type(phs_identifier_t), dimension(2) :: phs_identifiers
call pac_fmt (fmt, FMT_19, FMT_15, .true.)
write (u, "(A)") "* Test output: phs_fks_generator_4"
write (u, "(A)") "* Purpose: Create FSR phase space with fixed resonances"
write (u, "(A)")
allocate (p_born (nlegborn))
p_born(1)%p(0) = 250._default
p_born(1)%p(1) = 0._default
p_born(1)%p(2) = 0._default
p_born(1)%p(3) = 250._default
p_born(2)%p(0) = 250._default
p_born(2)%p(1) = 0._default
p_born(2)%p(2) = 0._default
p_born(2)%p(3) = -250._default
p_born(3)%p(0) = 145.91184486_default
p_born(3)%p(1) = 50.39727589_default
p_born(3)%p(2) = 86.74156041_default
p_born(3)%p(3) = -69.03608748_default
p_born(4)%p(0) = 208.1064784_default
p_born(4)%p(1) = -44.07610020_default
p_born(4)%p(2) = -186.34264578_default
p_born(4)%p(3) = 13.48038407_default
p_born(5)%p(0) = 26.25614471_default
p_born(5)%p(1) = -25.12258068_default
p_born(5)%p(2) = -1.09540228_default
p_born(5)%p(3) = -6.27703505_default
p_born(6)%p(0) = 119.72553196_default
p_born(6)%p(1) = 18.80140499_default
p_born(6)%p(2) = 100.69648766_default
p_born(6)%p(3) = 61.83273846_default
allocate (generator%isr_kinematics)
generator%n_in = 2
generator%isr_kinematics%isr_mode = SQRTS_FIXED
call generator%set_xi_and_y_bounds ()
call generator%set_sqrts_hat (sqrts)
write (u, "(A)") "* Test process: e+ e- -> W+ W- b b~"
write (u, "(A)") "* Resonance pairs: (3,5) and (4,6)"
write (u, "(A)") "* Use four-particle phase space containing: "
call vector4_write_set (p_born, u, testflag = .true., ultra = .true.)
write (u, "(A)") "******************************"
write (u, "(A)")
x1 = 0.5_default; x2 = 0.25_default; x3 = 0.75_default
write (u, "(A)") "* Use random numbers: "
write (u, "(A,F3.2,1X,A,F3.2,1X,A,F3.2)") &
"x1: ", x1, "x2: ", x2, "x3: ", x3
allocate (generator%real_kinematics)
call generator%real_kinematics%init (nlegborn, 2, 2, 2)
allocate (generator%emitters (2))
generator%emitters(1) = 5; generator%emitters(2) = 6
allocate (generator%m2 (nlegborn))
generator%m2 = p_born**2
allocate (generator%is_massive (nlegborn))
generator%is_massive (1:2) = .false.
generator%is_massive (3:6) = .true.
phs_identifiers(1)%emitter = 5
phs_identifiers(2)%emitter = 6
do i_phs = 1, 2
allocate (phs_identifiers(i_phs)%contributors (2))
end do
allocate (resonance_lists (2, 2))
resonance_lists (1,:) = [3,5]
resonance_lists (2,:) = [4,6]
!!! Here is obviously some redundance. Surely we can improve on this.
do i_phs = 1, 2
phs_identifiers(i_phs)%contributors = resonance_lists(i_phs,:)
end do
do i_con = 1, 2
allocate (alr_contributors(i_con)%c (size (resonance_lists(i_con,:))))
alr_contributors(i_con)%c = resonance_lists(i_con,:)
end do
call generator%generate_radiation_variables &
([x1, x2, x3], p_born, phs_identifiers)
allocate (p_real(nlegborn + 1))
call generator%compute_xi_ref_momenta (p_born, alr_contributors)
!!! Keep the distinction between i_phs and i_con because in general,
!!! they are not the same.
do i_phs = 1, 2
i_con = i_phs
emitter = phs_identifiers(i_phs)%emitter
write (u, "(A,I1,1X,A,I1,A,I1,A)") &
"* Generate FSR phase space for emitter ", emitter, &
"and resonance pair (", resonance_lists (i_con, 1), ",", &
resonance_lists (i_con, 2), ")"
call generator%compute_xi_max (emitter, i_phs, p_born, &
generator%real_kinematics%xi_max(i_phs), i_con = i_con)
call generator%generate_fsr (emitter, i_phs, i_con, p_born, p_real)
call vector4_write_set (p_real, u, testflag = .true., ultra = .true.)
call write_separator(u)
write (u, "(A)") "* Check if resonance masses are conserved: "
m_inv_born = compute_resonance_mass (p_born, resonance_lists (i_con,:))
m_inv_real = compute_resonance_mass (p_real, resonance_lists (i_con,:), 7)
write (u, "(A,1X, " // fmt // ")") "m_inv_born = ", m_inv_born
write (u, "(A,1X, " // fmt // ")") "m_inv_real = ", m_inv_real
if (abs (m_inv_born - m_inv_real) < tiny_07) then
write (u, "(A)") " Success! "
else
write (u, "(A)") " Failure! "
end if
call write_separator(u)
call write_separator(u)
end do
deallocate (p_real)
write (u, "(A)")
write (u, "(A)") "* Test output end: phs_fks_generator_4"
end subroutine phs_fks_generator_4
@ %def phs_fks_generator_4
@
<<phs fks: test declarations>>=
public :: phs_fks_generator_5
<<phs fks: tests>>=
subroutine phs_fks_generator_5 (u)
use ttv_formfactors, only: init_parameters
integer, intent(in) :: u
type(phs_fks_generator_t) :: generator
type(vector4_t), dimension(:), allocatable :: p_born
type(vector4_t), dimension(:), allocatable :: p_born_onshell
type(vector4_t), dimension(:), allocatable :: p_real
real(default) :: x1, x2, x3
real(default) :: mB, mW, mtop, mcheck
integer :: i, emitter, i_phs
type(phs_identifier_t), dimension(2) :: phs_identifiers
type(lorentz_transformation_t) :: L_to_cms
real(default), parameter :: sqrts = 360._default
real(default), parameter :: momentum_tolerance = 1E-10_default
real(default) :: mpole, gam_out
write (u, "(A)") "* Test output: phs_fks_generator_5"
write (u, "(A)") "* Puropse: Perform threshold on-shell projection of "
write (u, "(A)") "* Born momenta and create a real phase-space "
write (u, "(A)") "* point from those. "
write (u, "(A)")
allocate (p_born(6), p_born_onshell(6))
p_born(1)%p(0) = sqrts / two
p_born(1)%p(1:2) = zero
p_born(1)%p(3) = sqrts / two
p_born(2)%p(0) = sqrts / two
p_born(2)%p(1:2) = zero
p_born(2)%p(3) = -sqrts / two
p_born(3)%p(0) = 117.1179139230_default
p_born(3)%p(1) = 56.91215483880_default
p_born(3)%p(2) = -40.02386013017_default
p_born(3)%p(3) = -49.07634310496_default
p_born(4)%p(0) = 98.91904548743_default
p_born(4)%p(1) = 56.02241403836_default
p_born(4)%p(2) = -8.302977504723_default
p_born(4)%p(3) = -10.50293716131_default
p_born(5)%p(0) = 62.25884689208_default
p_born(5)%p(1) = -60.00786540278_default
p_born(5)%p(2) = 4.753602375910_default
p_born(5)%p(3) = 15.32916731546_default
p_born(6)%p(0) = 81.70419369751_default
p_born(6)%p(1) = -52.92670347439_default
p_born(6)%p(2) = 43.57323525898_default
p_born(6)%p(3) = 44.25011295081_default
generator%n_in = 2
allocate (generator%isr_kinematics)
generator%isr_kinematics%isr_mode = SQRTS_FIXED
call generator%set_xi_and_y_bounds ()
mB = 4.2_default
mW = 80.376_default
mtop = 172._default
generator%sqrts = sqrts
!!! Dummy-initialization of the threshold model because generate_fsr_threshold
!!! uses m1s_to_mpole to determine if it is above or below threshold.
call init_parameters (mpole, gam_out, mtop, one, one / 1.5_default, 125._default, &
0.47_default, 0.118_default, 91._default, 80._default, 4.2_default, &
one, one, one, one, zero, zero, zero, zero, zero, zero, .false., zero)
write (u, "(A)") "* Use four-particle phase space containing: "
call vector4_write_set (p_born, u, testflag = .true., ultra = .true.)
call vector4_check_momentum_conservation &
(p_born, 2, unit = u, abs_smallness = momentum_tolerance, verbose = .true.)
write (u, "(A)") "**********************"
write (u, "(A)")
allocate (generator%real_kinematics)
call generator%real_kinematics%init (7, 2, 2, 2)
call generator%real_kinematics%init_onshell (7, 2)
generator%real_kinematics%p_born_cms%phs_point(1)%p = p_born
write (u, "(A)") "Get boost projection system -> CMS: "
L_to_cms = get_boost_for_threshold_projection (p_born, sqrts, mtop)
call L_to_cms%write (u, testflag = .true., ultra = .true.)
write (u, "(A)") "**********************"
write (u, "(A)")
write (u, "(A)") "* Perform onshell-projection:"
associate (p_born => generator%real_kinematics%p_born_cms%phs_point(1)%p, &
p_born_onshell => generator%real_kinematics%p_born_onshell%phs_point(1)%p)
call threshold_projection_born (mtop, L_to_cms, p_born, p_born_onshell)
end associate
call generator%real_kinematics%p_born_onshell%write (1, unit = u, testflag = .true., &
ultra = .true.)
associate (p => generator%real_kinematics%p_born_onshell%phs_point(1)%p)
p_born_onshell = p
call check_phsp (p, 0)
end associate
allocate (generator%emitters (2))
generator%emitters(1) = THR_POS_B; generator%emitters(2) = THR_POS_BBAR
allocate (generator%m2 (6), generator%is_massive(6))
generator%m2 = p_born**2
generator%is_massive (1:2) = .false.
generator%is_massive (3:6) = .true.
phs_identifiers(1)%emitter = THR_POS_B
phs_identifiers(2)%emitter = THR_POS_BBAR
x1 = 0.5_default; x2 = 0.25_default; x3 = 0.6_default
write (u, "(A)") "* Use random numbers: "
write (u, "(A,F3.2,1X,A,F3.2,A,1X,F3.2)") &
"x1: ", x1, "x2: ", x2, "x3: ", x3
call generator%generate_radiation_variables ([x1,x2,x3], p_born_onshell, phs_identifiers)
do i_phs = 1, 2
emitter = phs_identifiers(i_phs)%emitter
call generator%compute_xi_ref_momenta_threshold (p_born_onshell)
call generator%compute_xi_max (emitter, i_phs, p_born_onshell, &
generator%real_kinematics%xi_max(i_phs), i_con = thr_leg(emitter))
end do
write (u, "(A)") &
"* With these, the following radiation variables have been produced: "
associate (rad_var => generator%real_kinematics)
write (u, "(A,F4.2)") "xi_tilde: ", rad_var%xi_tilde
write (u, "(A)") "xi_max: "
write (u, "(2F5.2)") rad_var%xi_max(1), rad_var%xi_max(2)
write (u, "(A)") "y: "
write (u, "(2F5.2)") rad_var%y(1), rad_var%y(2)
write (u, "(A,F4.2)") "phi: ", rad_var%phi
end associate
call write_separator (u)
write (u, "(A)") "* Produce real momenta from on-shell phase space: "
allocate (p_real(7))
do i_phs = 1, 2
emitter = phs_identifiers(i_phs)%emitter
write (u, "(A,I1)") "emitter: ", emitter
call generator%generate_fsr_threshold (emitter, i_phs, p_born_onshell, p_real)
call check_phsp (p_real, emitter)
end do
call write_separator(u)
write (u, "(A)")
write (u, "(A)") "* Test output end: phs_fks_generator_5"
contains
subroutine check_phsp (p, emitter)
type(vector4_t), intent(inout), dimension(:) :: p
integer, intent(in) :: emitter
type(vector4_t) :: pp
real(default) :: E_tot
logical :: check
write (u, "(A)") "* Check momentum conservation: "
call vector4_check_momentum_conservation &
(p, 2, unit = u, abs_smallness = momentum_tolerance, verbose = .true.)
write (u, "(A)") "* Check invariant masses: "
write (u, "(A)", advance = "no") "inv(W+, b, gl): "
pp = p(THR_POS_WP) + p(THR_POS_B)
if (emitter == THR_POS_B) pp = pp + p(THR_POS_GLUON)
if (nearly_equal (pp**1, mtop)) then
write (u, "(A)") "CHECK"
else
write (u, "(A,F7.3)") "FAIL: ", pp**1
end if
write (u, "(A)", advance = "no") "inv(W-, bbar): "
pp = p(THR_POS_WM) + p(THR_POS_BBAR)
if (emitter == THR_POS_BBAR) pp = pp + p(THR_POS_GLUON)
if (nearly_equal (pp**1, mtop)) then
write (u, "(A)") "CHECK"
else
write (u, "(A,F7.3)") "FAIL: ", pp**1
end if
write (u, "(A)") "* Sum of energies equal to sqrts?"
E_tot = sum(p(1:2)%p(0)); check = nearly_equal (E_tot, sqrts)
write (u, "(A,L1)") "Initial state: ", check
if (.not. check) write (u, "(A,F7.3)") "E_tot: ", E_tot
if (emitter > 0) then
E_tot = sum(p(3:7)%p(0))
else
E_tot = sum(p(3:6)%p(0))
end if
check = nearly_equal (E_tot, sqrts)
write (u, "(A,L1)") "Final state : ", check
if (.not. check) write (u, "(A,F7.3)") "E_tot: ", E_tot
call pacify (p, 1E-6_default)
call vector4_write_set (p, u, testflag = .true., ultra = .true.)
end subroutine check_phsp
end subroutine phs_fks_generator_5
@ %def phs_fks_generator_5
@
<<phs fks: test declarations>>=
public :: phs_fks_generator_6
<<phs fks: tests>>=
subroutine phs_fks_generator_6 (u)
integer, intent(in) :: u
type(phs_fks_generator_t) :: generator
type(vector4_t), dimension(:), allocatable :: p_born
type(vector4_t), dimension(:), allocatable :: p_real
real(default) :: x1, x2, x3
real(default) :: mB, mW, mT
integer :: i, emitter, i_phs
type(phs_identifier_t), dimension(2) :: phs_identifiers
write (u, "(A)") "* Test output: phs_fks_generator_6"
write (u, "(A)") "* Puropse: Create real phase space for particle decays"
write (u, "(A)")
allocate (p_born(4))
p_born(1)%p(0) = 173.1_default
p_born(1)%p(1) = zero
p_born(1)%p(2) = zero
p_born(1)%p(3) = zero
p_born(2)%p(0) = 68.17074462929_default
p_born(2)%p(1) = -37.32578717617_default
p_born(2)%p(2) = 30.99675959336_default
p_born(2)%p(3) = -47.70321718398_default
p_born(3)%p(0) = 65.26639312326_default
p_born(3)%p(1) = -1.362927648502_default
p_born(3)%p(2) = -33.25327150840_default
p_born(3)%p(3) = 56.14324922494_default
p_born(4)%p(0) = 39.66286224745_default
p_born(4)%p(1) = 38.68871482467_default
p_born(4)%p(2) = 2.256511915049_default
p_born(4)%p(3) = -8.440032040958_default
generator%n_in = 1
allocate (generator%isr_kinematics)
generator%isr_kinematics%isr_mode = SQRTS_FIXED
call generator%set_xi_and_y_bounds ()
mB = 4.2_default
mW = 80.376_default
mT = 173.1_default
generator%sqrts = mT
write (u, "(A)") "* Use four-particle phase space containing: "
call vector4_write_set (p_born, u, testflag = .true., ultra = .true.)
write (u, "(A)") "**********************"
write (u, "(A)")
x1=0.5_default; x2=0.25_default; x3=0.6_default
write (u, "(A)") "* Use random numbers: "
write (u, "(A,F3.2,1X,A,F3.2,A,1X,F3.2)") &
"x1: ", x1, "x2: ", x2, "x3: ", x3
allocate (generator%real_kinematics)
call generator%real_kinematics%init (3, 2, 2, 1)
call generator%real_kinematics%p_born_lab%set_momenta (1, p_born)
allocate (generator%emitters(2))
generator%emitters(1) = 1
generator%emitters(2) = 2
allocate (generator%m2 (4), generator%is_massive(4))
generator%m2(1) = mT**2
generator%m2(2) = mB**2
generator%m2(3) = zero
generator%m2(4) = zero
generator%is_massive(1:2) = .true.
generator%is_massive(3:4) = .false.
phs_identifiers(1)%emitter = 1
phs_identifiers(2)%emitter = 2
call generator%generate_radiation_variables ([x1,x2,x3], p_born, phs_identifiers)
call generator%compute_xi_ref_momenta (p_born)
do i_phs = 1, 2
emitter = phs_identifiers(i_phs)%emitter
call generator%compute_xi_max (emitter, i_phs, p_born, &
generator%real_kinematics%xi_max(i_phs))
end do
write (u, "(A)") &
"* With these, the following radiation variables have been produced: "
associate (rad_var => generator%real_kinematics)
write (u, "(A,F4.2)") "xi_tilde: ", rad_var%xi_tilde
do i = 1, 2
write (u, "(A,I1,A,F5.2)") "i: ", i, "y: " , rad_var%y(i)
end do
write (u, "(A,F4.2)") "phi: ", rad_var%phi
end associate
call write_separator (u)
write (u, "(A)") "Produce real momenta via initial-state emission: "
i_phs = 1; emitter = phs_identifiers(i_phs)%emitter
write (u, "(A,I1)") "emitter: ", emitter
allocate (p_real(5))
call generator%generate_isr_fixed_beam_energy (i_phs, p_born, p_real)
call pacify (p_real, 1E-6_default)
call vector4_write_set (p_real, u, testflag = .true., ultra = .true.)
call write_separator(u)
write (u, "(A)") "Produce real momenta via final-state emisson: "
i_phs = 2; emitter = phs_identifiers(i_phs)%emitter
write (u, "(A,I1)") "emitter: ", emitter
call generator%generate_fsr (emitter, i_phs, p_born, p_real)
call pacify (p_real, 1E-6_default)
call vector4_write_set (p_real, u, testflag = .true., ultra = .true.)
write (u, "(A)")
write (u, "(A)") "* Test output end: phs_fks_generator_6"
end subroutine phs_fks_generator_6
@ %def phs_fks_generator_6
@
<<phs fks: test declarations>>=
public :: phs_fks_generator_7
<<phs fks: tests>>=
subroutine phs_fks_generator_7 (u)
integer, intent(in) :: u
type(phs_fks_generator_t) :: generator
type(vector4_t), dimension(:), allocatable :: p_born
type(vector4_t), dimension(:), allocatable :: p_real
real(default) :: x1, x2, x3
integer :: i, emitter, i_phs
type(phs_identifier_t), dimension(2) :: phs_identifiers
real(default), parameter :: sqrts = 1000.0_default
write (u, "(A)") "* Test output: phs_fks_generator_7"
write (u, "(A)") "* Puropse: Create real phase space for scattering ISR"
write (u, "(A)") "* keeping the beam energy fixed."
write (u, "(A)")
allocate (p_born(4))
p_born(1)%p(0) = 500._default
p_born(1)%p(1) = 0._default
p_born(1)%p(2) = 0._default
p_born(1)%p(3) = 500._default
p_born(2)%p(0) = 500._default
p_born(2)%p(1) = 0._default
p_born(2)%p(2) = 0._default
p_born(2)%p(3) = -500._default
p_born(3)%p(0) = 500._default
p_born(3)%p(1) = 11.275563070_default
p_born(3)%p(2) = -13.588797663_default
p_born(3)%p(3) = 486.93070588_default
p_born(4)%p(0) = 500._default
p_born(4)%p(1:3) = -p_born(3)%p(1:3)
phs_identifiers(1)%emitter = 1
phs_identifiers(2)%emitter = 2
allocate (generator%emitters(2))
generator%n_in = 2
allocate (generator%isr_kinematics)
generator%isr_kinematics%isr_mode = SQRTS_FIXED
call generator%set_xi_and_y_bounds ()
generator%emitters(1) = 1; generator%emitters(2) = 2
generator%sqrts = sqrts
write (u, "(A)") "* Use 2 -> 2 phase space containing: "
call vector4_write_set (p_born, u, testflag = .true., ultra = .true.)
write (u, "(A)") "**********************"
write (u, "(A)")
x1 = 0.5_default; x2 = 0.25_default; x3 = 0.6_default
write (u, "(A)") "* Use random numbers: "
write (u, "(A,F3.2,1X,A,F3.2,A,1X,F3.2)") &
"x1: ", x1, "x2: ", x2, "x3: ", x3
allocate (generator%real_kinematics)
call generator%real_kinematics%init (4, 2, 2, 1)
call generator%real_kinematics%p_born_lab%set_momenta (1, p_born)
allocate (generator%m2 (4))
generator%m2 = 0._default
allocate (generator%is_massive(4))
generator%is_massive = .false.
call generator%generate_radiation_variables ([x1,x2,x3], p_born, phs_identifiers)
call generator%compute_xi_ref_momenta (p_born)
do i_phs = 1, 2
emitter = phs_identifiers(i_phs)%emitter
call generator%compute_xi_max (emitter, i_phs, p_born, &
generator%real_kinematics%xi_max(i_phs))
end do
write (u, "(A)") &
"* With these, the following radiation variables have been produced: "
associate (rad_var => generator%real_kinematics)
write (u, "(A,F4.2)") "xi_tilde: ", rad_var%xi_tilde
do i = 1, 2
write (u, "(A,I1,A,F5.2)") "i: ", i, "y: " , rad_var%y(i)
end do
write (u, "(A,F4.2)") "phi: ", rad_var%phi
end associate
call write_separator (u)
write (u, "(A)") "Produce real momenta via initial-state emission: "
i_phs = 1; emitter = phs_identifiers(i_phs)%emitter
write (u, "(A,I1)") "emitter: ", emitter
allocate (p_real(5))
call generator%generate_isr_fixed_beam_energy (i_phs, p_born, p_real)
call pacify (p_real, 1E-6_default)
call vector4_write_set (p_real, u, testflag = .true., ultra = .true.)
call write_separator(u)
i_phs = 2; emitter = phs_identifiers(i_phs)%emitter
write (u, "(A,I1)") "emitter: ", emitter
call generator%generate_isr_fixed_beam_energy (i_phs, p_born, p_real)
call pacify (p_real, 1E-6_default)
call vector4_write_set (p_real, u, testflag = .true., ultra = .true.)
write (u, "(A)")
write (u, "(A)") "* Test output end: phs_fks_generator_7"
end subroutine phs_fks_generator_7
@ %def phs_fks_generator_3
@
\section{Dispatch}
<<[[dispatch_phase_space.f90]]>>=
<<File header>>
module dispatch_phase_space
<<Use kinds>>
<<Use strings>>
use io_units, only: free_unit
use variables, only: var_list_t
use os_interface, only: os_data_t
use diagnostics
use sf_mappings, only: sf_channel_t
use beam_structures, only: beam_structure_t
use dispatch_beams, only: sf_prop_t, strfun_mode
use mappings
use phs_forests, only: phs_parameters_t
use phs_base
use phs_none
use phs_single
use phs_rambo
use phs_wood
use phs_fks
<<Standard module head>>
<<Dispatch phs: public>>
contains
<<Dispatch phs: procedures>>
end module dispatch_phase_space
@ %def dispatch_phase_space
Allocate a phase-space object according to the variable [[$phs_method]].
<<Dispatch phs: public>>=
public :: dispatch_phs
<<Dispatch phs: procedures>>=
subroutine dispatch_phs (phs, var_list, os_data, process_id, &
mapping_defaults, phs_par, phs_method_in)
class(phs_config_t), allocatable, intent(inout) :: phs
type(var_list_t), intent(in) :: var_list
type(os_data_t), intent(in) :: os_data
type(string_t), intent(in) :: process_id
type(mapping_defaults_t), intent(in), optional :: mapping_defaults
type(phs_parameters_t), intent(in), optional :: phs_par
type(string_t), intent(in), optional :: phs_method_in
type(string_t) :: phs_method, phs_file, run_id
logical :: use_equivalences, vis_channels, fatal_beam_decay
integer :: u_phs
logical :: exist
if (present (phs_method_in)) then
phs_method = phs_method_in
else
phs_method = &
var_list%get_sval (var_str ("$phs_method"))
end if
phs_file = &
var_list%get_sval (var_str ("$phs_file"))
use_equivalences = &
var_list%get_lval (var_str ("?use_vamp_equivalences"))
vis_channels = &
var_list%get_lval (var_str ("?vis_channels"))
fatal_beam_decay = &
var_list%get_lval (var_str ("?fatal_beam_decay"))
run_id = &
var_list%get_sval (var_str ("$run_id"))
select case (char (phs_method))
case ("none")
allocate (phs_none_config_t :: phs)
case ("single")
allocate (phs_single_config_t :: phs)
if (vis_channels) then
call msg_warning ("Visualizing phase space channels not " // &
"available for method 'single'.")
end if
case ("rambo")
allocate (phs_rambo_config_t :: phs)
if (vis_channels) &
call msg_warning ("Visualizing phase space channels not " // &
"available for method 'rambo'.")
case ("fks")
- allocate (phs_fks_config_t :: phs)
+ allocate (phs_fks_config_t :: phs)
+ if (use_equivalences) then
+ select type (phs)
+ type is (phs_fks_config_t)
+ call phs%enable_equivalences ()
+ end select
+ end if
case ("wood", "default", "fast_wood")
call dispatch_wood ()
case default
call msg_fatal ("Phase space: parameterization method '" &
// char (phs_method) // "' not implemented")
end select
contains
<<Dispatch phs: dispatch phs: procedures>>
end subroutine dispatch_phs
@ %def dispatch_phs
@
<<Dispatch phs: dispatch phs: procedures>>=
subroutine dispatch_wood ()
allocate (phs_wood_config_t :: phs)
select type (phs)
type is (phs_wood_config_t)
if (phs_file /= "") then
inquire (file = char (phs_file), exist = exist)
if (exist) then
call msg_message ("Phase space: reading configuration from '" &
// char (phs_file) // "'")
u_phs = free_unit ()
open (u_phs, file = char (phs_file), &
action = "read", status = "old")
call phs%set_input (u_phs)
else
call msg_fatal ("Phase space: configuration file '" &
// char (phs_file) // "' not found")
end if
end if
if (present (phs_par)) &
call phs%set_parameters (phs_par)
if (use_equivalences) &
call phs%enable_equivalences ()
if (present (mapping_defaults)) &
call phs%set_mapping_defaults (mapping_defaults)
if (phs_method == "fast_wood") phs%use_cascades2 = .true.
phs%vis_channels = vis_channels
phs%fatal_beam_decay = fatal_beam_decay
phs%os_data = os_data
phs%run_id = run_id
end select
end subroutine dispatch_wood
@
@ Configure channel mappings, using some conditions
from the phase space configuration. If there are no structure
functions, we enable a default setup with a single (dummy)
structure-function channel. Otherwise, we look at the channel
collection that we got from the phase-space configuration step. Each
entry should be translated into an independent structure-function
channel, where typically there is one default entry, which could be
mapped using a standard s-channel mapping if the structure function
setup recommends this, and other entries with s-channel resonances.
The latter need to be translated into global mappings from the
structure-function chain.
<<Dispatch phs: public>>=
public :: dispatch_sf_channels
<<Dispatch phs: procedures>>=
subroutine dispatch_sf_channels (sf_channel, sf_string, sf_prop, coll, &
var_list, sqrts, beam_structure)
type(sf_channel_t), dimension(:), allocatable, intent(out) :: sf_channel
type(string_t), intent(out) :: sf_string
type(sf_prop_t), intent(in) :: sf_prop
type(phs_channel_collection_t), intent(in) :: coll
type(var_list_t), intent(in) :: var_list
real(default), intent(in) :: sqrts
type(beam_structure_t), intent(in) :: beam_structure
type(beam_structure_t) :: beam_structure_tmp
class(channel_prop_t), allocatable :: prop
integer :: n_strfun, n_sf_channel, i
logical :: sf_allow_s_mapping, circe1_map, circe1_generate
logical :: s_mapping_enable, endpoint_mapping, power_mapping
logical :: single_parameter
integer, dimension(:), allocatable :: s_mapping, single_mapping
real(default) :: s_mapping_power
real(default) :: circe1_mapping_slope, endpoint_mapping_slope
real(default) :: power_mapping_eps
beam_structure_tmp = beam_structure
call beam_structure_tmp%expand (strfun_mode)
n_strfun = beam_structure_tmp%get_n_record ()
sf_string = beam_structure_tmp%to_string (sf_only = .true.)
sf_allow_s_mapping = &
var_list%get_lval (var_str ("?sf_allow_s_mapping"))
circe1_generate = &
var_list%get_lval (var_str ("?circe1_generate"))
circe1_map = &
var_list%get_lval (var_str ("?circe1_map"))
circe1_mapping_slope = &
var_list%get_rval (var_str ("circe1_mapping_slope"))
s_mapping_enable = .false.
s_mapping_power = 1
endpoint_mapping = .false.
endpoint_mapping_slope = 1
power_mapping = .false.
single_parameter = .false.
select case (char (sf_string))
case ("", "[any particles]")
case ("pdf_builtin, none", &
"pdf_builtin_photon, none", &
"none, pdf_builtin", &
"none, pdf_builtin_photon", &
"lhapdf, none", &
"lhapdf_photon, none", &
"none, lhapdf", &
"none, lhapdf_photon")
single_parameter = .true.
case ("pdf_builtin, none => none, pdf_builtin", &
"pdf_builtin, none => none, pdf_builtin_photon", &
"pdf_builtin_photon, none => none, pdf_builtin", &
"pdf_builtin_photon, none => none, pdf_builtin_photon", &
"lhapdf, none => none, lhapdf", &
"lhapdf, none => none, lhapdf_photon", &
"lhapdf_photon, none => none, lhapdf", &
"lhapdf_photon, none => none, lhapdf_photon")
allocate (s_mapping (2), source = [1, 2])
s_mapping_enable = .true.
s_mapping_power = 2
case ("pdf_builtin, none => none, pdf_builtin => epa, none => none, epa", &
"pdf_builtin, none => none, pdf_builtin => ewa, none => none, ewa", &
"pdf_builtin, none => none, pdf_builtin => ewa, none => none, epa", &
"pdf_builtin, none => none, pdf_builtin => epa, none => none, ewa")
allocate (s_mapping (2), source = [1, 2])
s_mapping_enable = .true.
s_mapping_power = 2
case ("isr, none", &
"none, isr")
allocate (single_mapping (1), source = [1])
single_parameter = .true.
case ("isr, none => none, isr")
allocate (s_mapping (2), source = [1, 2])
power_mapping = .true.
power_mapping_eps = minval (sf_prop%isr_eps)
case ("isr, none => none, isr => epa, none => none, epa", &
"isr, none => none, isr => ewa, none => none, ewa", &
"isr, none => none, isr => ewa, none => none, epa", &
"isr, none => none, isr => epa, none => none, ewa")
allocate (s_mapping (2), source = [1, 2])
power_mapping = .true.
power_mapping_eps = minval (sf_prop%isr_eps)
case ("circe1 => isr, none => none, isr => epa, none => none, epa", &
"circe1 => isr, none => none, isr => ewa, none => none, ewa", &
"circe1 => isr, none => none, isr => ewa, none => none, epa", &
"circe1 => isr, none => none, isr => epa, none => none, ewa")
if (circe1_generate) then
allocate (s_mapping (2), source = [2, 3])
else
allocate (s_mapping (3), source = [1, 2, 3])
endpoint_mapping = .true.
endpoint_mapping_slope = circe1_mapping_slope
end if
power_mapping = .true.
power_mapping_eps = minval (sf_prop%isr_eps)
case ("pdf_builtin, none => none, isr", &
"pdf_builtin_photon, none => none, isr", &
"lhapdf, none => none, isr", &
"lhapdf_photon, none => none, isr")
allocate (single_mapping (1), source = [2])
case ("isr, none => none, pdf_builtin", &
"isr, none => none, pdf_builtin_photon", &
"isr, none => none, lhapdf", &
"isr, none => none, lhapdf_photon")
allocate (single_mapping (1), source = [1])
case ("epa, none", &
"none, epa")
allocate (single_mapping (1), source = [1])
single_parameter = .true.
case ("epa, none => none, epa")
allocate (single_mapping (2), source = [1, 2])
case ("epa, none => none, isr", &
"isr, none => none, epa", &
"ewa, none => none, isr", &
"isr, none => none, ewa")
allocate (single_mapping (2), source = [1, 2])
case ("pdf_builtin, none => none, epa", &
"pdf_builtin_photon, none => none, epa", &
"lhapdf, none => none, epa", &
"lhapdf_photon, none => none, epa")
allocate (single_mapping (1), source = [2])
case ("pdf_builtin, none => none, ewa", &
"pdf_builtin_photon, none => none, ewa", &
"lhapdf, none => none, ewa", &
"lhapdf_photon, none => none, ewa")
allocate (single_mapping (1), source = [2])
case ("epa, none => none, pdf_builtin", &
"epa, none => none, pdf_builtin_photon", &
"epa, none => none, lhapdf", &
"epa, none => none, lhapdf_photon")
allocate (single_mapping (1), source = [1])
case ("ewa, none => none, pdf_builtin", &
"ewa, none => none, pdf_builtin_photon", &
"ewa, none => none, lhapdf", &
"ewa, none => none, lhapdf_photon")
allocate (single_mapping (1), source = [1])
case ("ewa, none", &
"none, ewa")
allocate (single_mapping (1), source = [1])
single_parameter = .true.
case ("ewa, none => none, ewa")
allocate (single_mapping (2), source = [1, 2])
case ("energy_scan, none => none, energy_scan")
allocate (s_mapping (2), source = [1, 2])
case ("sf_test_1, none => none, sf_test_1")
allocate (s_mapping (2), source = [1, 2])
case ("circe1")
if (circe1_generate) then
!!! no mapping
else if (circe1_map) then
allocate (s_mapping (1), source = [1])
endpoint_mapping = .true.
endpoint_mapping_slope = circe1_mapping_slope
else
allocate (s_mapping (1), source = [1])
s_mapping_enable = .true.
end if
case ("circe1 => isr, none => none, isr")
if (circe1_generate) then
allocate (s_mapping (2), source = [2, 3])
else
allocate (s_mapping (3), source = [1, 2, 3])
endpoint_mapping = .true.
endpoint_mapping_slope = circe1_mapping_slope
end if
power_mapping = .true.
power_mapping_eps = minval (sf_prop%isr_eps)
case ("circe1 => isr, none", &
"circe1 => none, isr")
allocate (single_mapping (1), source = [2])
case ("circe1 => epa, none => none, epa")
if (circe1_generate) then
allocate (single_mapping (2), source = [2, 3])
else
call msg_fatal ("CIRCE/EPA: supported with ?circe1_generate=true &
&only")
end if
case ("circe1 => ewa, none => none, ewa")
if (circe1_generate) then
allocate (single_mapping (2), source = [2, 3])
else
call msg_fatal ("CIRCE/EWA: supported with ?circe1_generate=true &
&only")
end if
case ("circe1 => epa, none", &
"circe1 => none, epa")
if (circe1_generate) then
allocate (single_mapping (1), source = [2])
else
call msg_fatal ("CIRCE/EPA: supported with ?circe1_generate=true &
&only")
end if
case ("circe1 => epa, none => none, isr", &
"circe1 => isr, none => none, epa", &
"circe1 => ewa, none => none, isr", &
"circe1 => isr, none => none, ewa")
if (circe1_generate) then
allocate (single_mapping (2), source = [2, 3])
else
call msg_fatal ("CIRCE/EPA: supported with ?circe1_generate=true &
&only")
end if
case ("circe2", &
"gaussian", &
"beam_events")
!!! no mapping
case ("circe2 => isr, none => none, isr", &
"gaussian => isr, none => none, isr", &
"beam_events => isr, none => none, isr")
allocate (s_mapping (2), source = [2, 3])
power_mapping = .true.
power_mapping_eps = minval (sf_prop%isr_eps)
case ("circe2 => isr, none", &
"circe2 => none, isr", &
"gaussian => isr, none", &
"gaussian => none, isr", &
"beam_events => isr, none", &
"beam_events => none, isr")
allocate (single_mapping (1), source = [2])
case ("circe2 => epa, none => none, epa", &
"gaussian => epa, none => none, epa", &
"beam_events => epa, none => none, epa")
allocate (single_mapping (2), source = [2, 3])
case ("circe2 => epa, none", &
"circe2 => none, epa", &
"circe2 => ewa, none", &
"circe2 => none, ewa", &
"gaussian => epa, none", &
"gaussian => none, epa", &
"gaussian => ewa, none", &
"gaussian => none, ewa", &
"beam_events => epa, none", &
"beam_events => none, epa", &
"beam_events => ewa, none", &
"beam_events => none, ewa")
allocate (single_mapping (1), source = [2])
case ("circe2 => epa, none => none, isr", &
"circe2 => isr, none => none, epa", &
"circe2 => ewa, none => none, isr", &
"circe2 => isr, none => none, ewa", &
"gaussian => epa, none => none, isr", &
"gaussian => isr, none => none, epa", &
"gaussian => ewa, none => none, isr", &
"gaussian => isr, none => none, ewa", &
"beam_events => epa, none => none, isr", &
"beam_events => isr, none => none, epa", &
"beam_events => ewa, none => none, isr", &
"beam_events => isr, none => none, ewa")
allocate (single_mapping (2), source = [2, 3])
case ("energy_scan")
case default
call msg_fatal ("Beam structure: " &
// char (sf_string) // " not supported")
end select
if (sf_allow_s_mapping .and. coll%n > 0) then
n_sf_channel = coll%n
allocate (sf_channel (n_sf_channel))
do i = 1, n_sf_channel
call sf_channel(i)%init (n_strfun)
if (allocated (single_mapping)) then
call sf_channel(i)%activate_mapping (single_mapping)
end if
if (allocated (prop)) deallocate (prop)
call coll%get_entry (i, prop)
if (allocated (prop)) then
if (endpoint_mapping .and. power_mapping) then
select type (prop)
type is (resonance_t)
call sf_channel(i)%set_eir_mapping (s_mapping, &
a = endpoint_mapping_slope, eps = power_mapping_eps, &
m = prop%mass / sqrts, w = prop%width / sqrts)
type is (on_shell_t)
call sf_channel(i)%set_eio_mapping (s_mapping, &
a = endpoint_mapping_slope, eps = power_mapping_eps, &
m = prop%mass / sqrts)
end select
else if (endpoint_mapping) then
select type (prop)
type is (resonance_t)
call sf_channel(i)%set_epr_mapping (s_mapping, &
a = endpoint_mapping_slope, &
m = prop%mass / sqrts, w = prop%width / sqrts)
type is (on_shell_t)
call sf_channel(i)%set_epo_mapping (s_mapping, &
a = endpoint_mapping_slope, &
m = prop%mass / sqrts)
end select
else if (power_mapping) then
select type (prop)
type is (resonance_t)
call sf_channel(i)%set_ipr_mapping (s_mapping, &
eps = power_mapping_eps, &
m = prop%mass / sqrts, w = prop%width / sqrts)
type is (on_shell_t)
call sf_channel(i)%set_ipo_mapping (s_mapping, &
eps = power_mapping_eps, &
m = prop%mass / sqrts)
end select
else if (allocated (s_mapping)) then
select type (prop)
type is (resonance_t)
call sf_channel(i)%set_res_mapping (s_mapping, &
m = prop%mass / sqrts, w = prop%width / sqrts, &
single = single_parameter)
type is (on_shell_t)
call sf_channel(i)%set_os_mapping (s_mapping, &
m = prop%mass / sqrts, &
single = single_parameter)
end select
else if (allocated (single_mapping)) then
select type (prop)
type is (resonance_t)
call sf_channel(i)%set_res_mapping (single_mapping, &
m = prop%mass / sqrts, w = prop%width / sqrts, &
single = single_parameter)
type is (on_shell_t)
call sf_channel(i)%set_os_mapping (single_mapping, &
m = prop%mass / sqrts, &
single = single_parameter)
end select
end if
else if (endpoint_mapping .and. power_mapping) then
call sf_channel(i)%set_ei_mapping (s_mapping, &
a = endpoint_mapping_slope, eps = power_mapping_eps)
else if (endpoint_mapping .and. .not. allocated (single_mapping)) then
call sf_channel(i)%set_ep_mapping (s_mapping, &
a = endpoint_mapping_slope)
else if (power_mapping .and. .not. allocated (single_mapping)) then
call sf_channel(i)%set_ip_mapping (s_mapping, &
eps = power_mapping_eps)
else if (s_mapping_enable .and. .not. allocated (single_mapping)) then
call sf_channel(i)%set_s_mapping (s_mapping, &
power = s_mapping_power)
end if
end do
else if (sf_allow_s_mapping) then
allocate (sf_channel (1))
call sf_channel(1)%init (n_strfun)
if (allocated (single_mapping)) then
call sf_channel(1)%activate_mapping (single_mapping)
else if (endpoint_mapping .and. power_mapping) then
call sf_channel(i)%set_ei_mapping (s_mapping, &
a = endpoint_mapping_slope, eps = power_mapping_eps)
else if (endpoint_mapping) then
call sf_channel(1)%set_ep_mapping (s_mapping, &
a = endpoint_mapping_slope)
else if (power_mapping) then
call sf_channel(1)%set_ip_mapping (s_mapping, &
eps = power_mapping_eps)
else if (s_mapping_enable) then
call sf_channel(1)%set_s_mapping (s_mapping, &
power = s_mapping_power)
end if
else
allocate (sf_channel (1))
call sf_channel(1)%init (n_strfun)
if (allocated (single_mapping)) then
call sf_channel(1)%activate_mapping (single_mapping)
end if
end if
end subroutine dispatch_sf_channels
@ %def dispatch_sf_channels
@
@
\subsection{Unit tests}
Test module, followed by the corresponding implementation module.
<<[[dispatch_phs_ut.f90]]>>=
<<File header>>
module dispatch_phs_ut
use unit_tests
use dispatch_phs_uti
<<Standard module head>>
<<Dispatch phs: public test>>
contains
<<Dispatch phs: test driver>>
end module dispatch_phs_ut
@ %def dispatch_phs_ut
@
<<[[dispatch_phs_uti.f90]]>>=
<<File header>>
module dispatch_phs_uti
<<Use kinds>>
<<Use strings>>
use variables
use io_units, only: free_unit
use os_interface, only: os_data_t
use process_constants
use model_data
use models
use phs_base
use phs_none
use phs_forests
use phs_wood
use mappings
use dispatch_phase_space
<<Standard module head>>
<<Dispatch phs: test declarations>>
contains
<<Dispatch phs: tests>>
end module dispatch_phs_uti
@ %def dispatch_phs_ut
@ API: driver for the unit tests below.
<<Dispatch phs: public test>>=
public ::dispatch_phs_test
<<Dispatch phs: test driver>>=
subroutine dispatch_phs_test (u, results)
integer, intent(in) :: u
type(test_results_t), intent(inout) :: results
<<Dispatch phs: execute tests>>
end subroutine dispatch_phs_test
@ %def dispatch_phs_test
@
\subsubsection{Select type: phase-space configuration object}
<<Dispatch phs: execute tests>>=
call test (dispatch_phs_1, "dispatch_phs_1", &
"phase-space configuration", &
u, results)
<<Dispatch phs: test declarations>>=
public :: dispatch_phs_1
<<Dispatch phs: tests>>=
subroutine dispatch_phs_1 (u)
integer, intent(in) :: u
type(var_list_t) :: var_list
class(phs_config_t), allocatable :: phs
type(phs_parameters_t) :: phs_par
type(os_data_t) :: os_data
type(mapping_defaults_t) :: mapping_defs
write (u, "(A)") "* Test output: dispatch_phs_1"
write (u, "(A)") "* Purpose: select phase-space configuration method"
write (u, "(A)")
call var_list%init_defaults (0)
write (u, "(A)") "* Allocate PHS as phs_none_t"
write (u, "(A)")
call var_list%set_string (&
var_str ("$phs_method"), &
var_str ("none"), is_known = .true.)
call dispatch_phs (phs, var_list, os_data, var_str ("dispatch_phs_1"))
call phs%write (u)
call phs%final ()
deallocate (phs)
write (u, "(A)")
write (u, "(A)") "* Allocate PHS as phs_single_t"
write (u, "(A)")
call var_list%set_string (&
var_str ("$phs_method"), &
var_str ("single"), is_known = .true.)
call dispatch_phs (phs, var_list, os_data, var_str ("dispatch_phs_1"))
call phs%write (u)
call phs%final ()
deallocate (phs)
write (u, "(A)")
write (u, "(A)") "* Allocate PHS as phs_wood_t"
write (u, "(A)")
call var_list%set_string (&
var_str ("$phs_method"), &
var_str ("wood"), is_known = .true.)
call dispatch_phs (phs, var_list, os_data, var_str ("dispatch_phs_1"))
call phs%write (u)
call phs%final ()
deallocate (phs)
write (u, "(A)")
write (u, "(A)") "* Setting parameters for phs_wood_t"
write (u, "(A)")
phs_par%m_threshold_s = 123
phs_par%m_threshold_t = 456
phs_par%t_channel = 42
phs_par%off_shell = 17
phs_par%keep_nonresonant = .false.
mapping_defs%energy_scale = 987
mapping_defs%invariant_mass_scale = 654
mapping_defs%momentum_transfer_scale = 321
mapping_defs%step_mapping = .false.
mapping_defs%step_mapping_exp = .false.
mapping_defs%enable_s_mapping = .true.
call dispatch_phs (phs, var_list, os_data, var_str ("dispatch_phs_1"), &
mapping_defs, phs_par)
call phs%write (u)
call phs%final ()
call var_list%final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: dispatch_phs_1"
end subroutine dispatch_phs_1
@ %def dispatch_phs_1
@
\subsubsection{Phase-space configuration with file}
<<Dispatch phs: execute tests>>=
call test (dispatch_phs_2, "dispatch_phs_2", &
"configure phase space using file", &
u, results)
<<Dispatch phs: test declarations>>=
public :: dispatch_phs_2
<<Dispatch phs: tests>>=
subroutine dispatch_phs_2 (u)
use phs_base_ut, only: init_test_process_data
use phs_wood_ut, only: write_test_phs_file
use phs_forests
integer, intent(in) :: u
type(var_list_t) :: var_list
type(os_data_t) :: os_data
type(process_constants_t) :: process_data
type(model_list_t) :: model_list
type(model_t), pointer :: model
class(phs_config_t), allocatable :: phs
integer :: u_phs
write (u, "(A)") "* Test output: dispatch_phs_2"
write (u, "(A)") "* Purpose: select 'wood' phase-space &
&for a test process"
write (u, "(A)") "* and read phs configuration from file"
write (u, "(A)")
write (u, "(A)") "* Initialize a process"
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 ("Test"), var_str ("Test.mdl"), os_data, model)
call syntax_phs_forest_init ()
call init_test_process_data (var_str ("dispatch_phs_2"), process_data)
write (u, "(A)") "* Write phase-space file"
u_phs = free_unit ()
open (u_phs, file = "dispatch_phs_2.phs", action = "write", status = "replace")
call write_test_phs_file (u_phs, var_str ("dispatch_phs_2"))
close (u_phs)
write (u, "(A)")
write (u, "(A)") "* Allocate PHS as phs_wood_t"
write (u, "(A)")
call var_list%set_string (&
var_str ("$phs_method"), &
var_str ("wood"), is_known = .true.)
call var_list%set_string (&
var_str ("$phs_file"), &
var_str ("dispatch_phs_2.phs"), is_known = .true.)
call dispatch_phs (phs, var_list, os_data, var_str ("dispatch_phs_2"))
call phs%init (process_data, model)
call phs%configure (sqrts = 1000._default)
call phs%write (u)
write (u, "(A)")
select type (phs)
type is (phs_wood_config_t)
call phs%write_forest (u)
end select
call phs%final ()
call var_list%final ()
call syntax_model_file_final ()
write (u, "(A)")
write (u, "(A)") "* Test output end: dispatch_phs_2"
end subroutine dispatch_phs_2
@ %def dispatch_phs_2
@%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{A lexer for O'Mega's phase-space output}
This module provides three data types. One of them is the type
[[dag_string_t]] which should contain the information of all Feynman
diagrams in the factorized form which is provided by O'Mega in its
phase-space outout. This output is translated into a string of tokens (in
the form of an a array of the type [[dag_token_t]]) which have a certain
meaning. The purpose of this module is only to identify these tokens
correctly and to provide some procedures and interfaces which allow us to
use these strings in a similar way as variables of the basic character
type or the type [[iso_varying_string]]. Both [[character]] and
[[iso_varying_string]] have some disadvantages at least if one wants to
keep support for some older compiler versions. These can be circumvented
by the [[dag_string_t]] type. Finally the [[dag_chain_t]] type is used
to create a larger string in several steps without always recreating the
string, which is done in the form of a simple linked list. In the end
one can create a single [[dag_string]] out of this list, which is more
useful.
<<[[cascades2_lexer.f90]]>>=
<<File header>>
module cascades2_lexer
<<Use kinds>>
use kinds, only: TC, i8
<<Standard module head>>
<<Cascades2 lexer: public>>
<<Cascades2 lexer: parameters>>
<<Cascades2 lexer: types>>
<<Cascades2 lexer: interfaces>>
contains
<<Cascades2 lexer: procedures>>
end module cascades2_lexer
@ %def cascades2_lexer
@ This is the token type. By default the variable [[type]] is [[EMPTY_TK]]
but can obtain other values corresponding to the parameters defined below.
The type of the token corresponds to a particular sequence of characters.
When the token corresponds to a node of a tree, i.e. some particle in the
Feynman diagram, the type is [[NODE_TK]] and the [[particle_name]] variable
is holding the name of the particle. O'Megas output contains in
addition to the particle name some numbers which indicate the external
momenta that are flowing through this line. These numbers are translated
into a binary code and saved in the variable [[bincode]]. In this case
the number 1 corresponds to a bit set at position 0, 2 corresponds to a
bit set at position 1, etc. Instead of numbers which are composed out of
several digits, letters are used, i.e. A instead of 10 (bit at position 9),
B instead of 11 (bit at position 10), etc.\\
When the DAG is reconstructed from a [[dag_string]] which was built from
O'Mega's output, this string is modified such that a substring (a set of
tokens) is replaced by a single token where the type variable is one of
the three parameters [[DAG_NODE_TK]], [[DAG_OPTIONS_TK]] and
[[DAG_COMBINATION_TK]]. These parameters correspond to the three types
[[dag_node_t]], [[dag_options_t]] and [[dag_combination_t]] (see [[cascades2]]
for more information. In this case, since these objects are organized
in arrays, the [[index]] variable holds the corresponding position in
the array.\\
In any case, we want to be able to reproduce the character string from
which a token (or a string) has been created. The variable [[char_len]]
is the length of this string. For tokens with the type [[DAG_NODE_TK]],
[[DAG_OPTIONS_TK]] and [[DAG_COMBINATION_TK]] we use output of the form
[[<N23>]], [[<O23>]] or [[<C23>]] which is useful for debugging the parser.
Here 23 is the [[index]] and [[N]], [[O]] or [[C]] obviously corresponds
to the [[type]].
<<Cascades2 lexer: parameters>>=
integer, parameter :: PRT_NAME_LEN = 20
@ %def PRT_NAME_LEN
<<Cascades2 lexer: public>>=
public :: dag_token_t
<<Cascades2 lexer: types>>=
type :: dag_token_t
integer :: type = EMPTY_TK
integer :: char_len = 0
integer(TC) :: bincode = 0
character (PRT_NAME_LEN) :: particle_name=""
integer :: index = 0
contains
<<Cascades2 lexer: dag token: TBP>>
end type dag_token_t
@ %def dag_token_t
@ This is the string type. It also holds the number of characters in the
corresponding character string. It contains an array of tokens. If the
[[dag_string]] is constructed using the type [[dag_chain_t]], which creates
a linked list, we also need the pointer [[next]].
<<Cascades2 lexer: public>>=
public :: dag_string_t
<<Cascades2 lexer: types>>=
type :: dag_string_t
integer :: char_len = 0
type (dag_token_t), dimension(:), allocatable :: t
type (dag_string_t), pointer :: next => null ()
contains
<<Cascades2 lexer: dag string: TBP>>
end type dag_string_t
@ %def dag_string_t
@ This is the chain of [[dag_strings]]. It allows us to construct a large
string by appending new strings to the linked list, which can later be
merged to a single string. This is very useful because the file written
by O'Mega contains large strings where each string contains all Feynman
diagrams in a factorized form, but these large strings are cut into
several pieces and distributed over many lines. As the file can become
large, rewriting a new [[dag_string]] (or [[iso_varying_string]]) would
consume more and more time with each additional line. For recreating a
single [[dag_string]] out of this chain, we need the total character
length and the sum of all sizes of the [[dag_token]] arrays [[t]].
<<Cascades2 lexer: public>>=
public :: dag_chain_t
<<Cascades2 lexer: types>>=
type :: dag_chain_t
integer :: char_len = 0
integer :: t_size = 0
type (dag_string_t), pointer :: first => null ()
type (dag_string_t), pointer :: last => null ()
contains
<<Cascades2 lexer: dag chain: TBP>>
end type dag_chain_t
@ %def dag_chain_t
@ We define two parameters holding the characters corresponding to a
backslash and a blanc space.
<<Cascades2 lexer: parameters>>=
character(len=1), parameter, public :: BACKSLASH_CHAR = "\\"
character(len=1), parameter :: BLANC_CHAR = " "
@ %def BACKSLASH_CHAR BLANC_CHAR
@ These are the parameters which correspond to meaningful types
of [[token]].
<<Cascades2 lexer: parameters>>=
integer, parameter, public :: NEW_LINE_TK = -2
integer, parameter :: BLANC_SPACE_TK = -1
integer, parameter :: EMPTY_TK = 0
integer, parameter, public :: NODE_TK = 1
integer, parameter, public :: DAG_NODE_TK = 2
integer, parameter, public :: DAG_OPTIONS_TK = 3
integer, parameter, public :: DAG_COMBINATION_TK = 4
integer, parameter, public :: COLON_TK = 11
integer, parameter, public :: COMMA_TK = 12
integer, parameter, public :: VERTICAL_BAR_TK = 13
integer, parameter, public :: OPEN_PAR_TK = 21
integer, parameter, public :: CLOSED_PAR_TK = 22
integer, parameter, public :: OPEN_CURLY_TK = 31
integer, parameter, public :: CLOSED_CURLY_TK = 32
@ %def NEW_LINE_TK BLANC_SPACE_TK EMPTY_TK NODE_TK
@ %def COLON_TK COMMA_TK VERTICAL_LINE_TK OPEN_PAR_TK
@ %def CLOSED_PAR_TK OPEN_CURLY_TK CLOSED_CURLY_TK
@ Different sorts of assignment. This contains the conversion
of a [[character]] variable into a [[dag_token]] or [[dag_string]].
<<Cascades2 lexer: public>>=
public :: assignment (=)
<<Cascades2 lexer: interfaces>>=
interface assignment (=)
module procedure dag_token_assign_from_char_string
module procedure dag_token_assign_from_dag_token
module procedure dag_string_assign_from_dag_token
module procedure dag_string_assign_from_char_string
module procedure dag_string_assign_from_dag_string
module procedure dag_string_assign_from_dag_token_array
end interface assignment (=)
@ %def interfaces
<<Cascades2 lexer: dag token: TBP>>=
procedure :: init_dag_object_token => dag_token_init_dag_object_token
<<Cascades2 lexer: procedures>>=
subroutine dag_token_init_dag_object_token (dag_token, type, index)
class (dag_token_t), intent (out) :: dag_token
integer, intent (in) :: index
integer :: type
dag_token%type = type
dag_token%char_len = integer_n_dec_digits (index) + 3
dag_token%index = index
contains
function integer_n_dec_digits (number) result (n_digits)
integer, intent (in) :: number
integer :: n_digits
integer :: div_number
n_digits = 0
div_number = number
do
div_number = div_number / 10
n_digits = n_digits + 1
if (div_number == 0) exit
enddo
end function integer_n_dec_digits
end subroutine dag_token_init_dag_object_token
@ %def dag_token_init_dag_object_token
<<Cascades2 lexer: procedures>>=
elemental subroutine dag_token_assign_from_char_string (dag_token, char_string)
type (dag_token_t), intent (out) :: dag_token
character (len=*), intent (in) :: char_string
integer :: i, j
logical :: set_bincode
integer :: bit_pos
character (len=10) :: index_char
dag_token%char_len = len (char_string)
if (dag_token%char_len == 1) then
select case (char_string(1:1))
case (BACKSLASH_CHAR)
dag_token%type = NEW_LINE_TK
case (" ")
dag_token%type = BLANC_SPACE_TK
case (":")
dag_token%type = COLON_TK
case (",")
dag_token%type = COMMA_TK
case ("|")
dag_token%type = VERTICAL_BAR_TK
case ("(")
dag_token%type = OPEN_PAR_TK
case (")")
dag_token%type = CLOSED_PAR_TK
case ("{")
dag_token%type = OPEN_CURLY_TK
case ("}")
dag_token%type = CLOSED_CURLY_TK
end select
else if (char_string(1:1) == "<") then
select case (char_string(2:2))
case ("N")
dag_token%type = DAG_NODE_TK
case ("O")
dag_token%type = DAG_OPTIONS_TK
case ("C")
dag_token%type = DAG_COMBINATION_TK
end select
read(char_string(3:dag_token%char_len-1), fmt="(I10)") dag_token%index
else
dag_token%bincode = 0
set_bincode = .false.
do i=1, dag_token%char_len
select case (char_string(i:i))
case ("[")
dag_token%type = NODE_TK
if (i > 1) then
do j = 1, i - 1
dag_token%particle_name(j:j) = char_string(j:j)
enddo
end if
set_bincode = .true.
case ("]")
set_bincode = .false.
case default
dag_token%type = NODE_TK
if (set_bincode) then
select case (char_string(i:i))
case ("1", "2", "3", "4", "5", "6", "7", "8", "9")
read (char_string(i:i), fmt="(I1)") bit_pos
case ("A")
bit_pos = 10
case ("B")
bit_pos = 11
case ("C")
bit_pos = 12
end select
dag_token%bincode = ibset(dag_token%bincode, bit_pos - 1)
end if
end select
if (dag_token%type /= NODE_TK) exit
enddo
end if
end subroutine dag_token_assign_from_char_string
@ %def dag_token_assign_from_char_string
<<Cascades2 lexer: procedures>>=
elemental subroutine dag_token_assign_from_dag_token (token_out, token_in)
type (dag_token_t), intent (out) :: token_out
type (dag_token_t), intent (in) :: token_in
token_out%type = token_in%type
token_out%char_len = token_in%char_len
token_out%bincode = token_in%bincode
token_out%particle_name = token_in%particle_name
token_out%index = token_in%index
end subroutine dag_token_assign_from_dag_token
@ %def dag_token_assign_from_dag_token
<<Cascades2 lexer: procedures>>=
elemental subroutine dag_string_assign_from_dag_token (dag_string, dag_token)
type (dag_string_t), intent (out) :: dag_string
type (dag_token_t), intent (in) :: dag_token
allocate (dag_string%t(1))
dag_string%t(1) = dag_token
dag_string%char_len = dag_token%char_len
end subroutine dag_string_assign_from_dag_token
@ %def dag_string_assign_from_dag_token
<<Cascades2 lexer: procedures>>=
subroutine dag_string_assign_from_dag_token_array (dag_string, dag_token)
type (dag_string_t), intent (out) :: dag_string
type (dag_token_t), dimension(:), intent (in) :: dag_token
allocate (dag_string%t(size(dag_token)))
dag_string%t = dag_token
dag_string%char_len = sum(dag_token%char_len)
end subroutine dag_string_assign_from_dag_token_array
@ %def dag_string_assign_from_dag_token_array
<<Cascades2 lexer: procedures>>=
elemental subroutine dag_string_assign_from_char_string (dag_string, char_string)
type (dag_string_t), intent (out) :: dag_string
character (len=*), intent (in) :: char_string
type (dag_token_t), dimension(:), allocatable :: token
integer :: token_pos
integer :: i
character (len=len(char_string)) :: node_char
integer :: node_char_len
node_char = ""
dag_string%char_len = len (char_string)
if (dag_string%char_len > 0) then
allocate (token(dag_string%char_len))
token_pos = 0
node_char_len = 0
do i=1, dag_string%char_len
select case (char_string(i:i))
case (BACKSLASH_CHAR, " ", ":", ",", "|", "(", ")", "{", "}")
if (node_char_len > 0) then
token_pos = token_pos + 1
token(token_pos) = node_char(:node_char_len)
node_char_len = 0
end if
token_pos = token_pos + 1
token(token_pos) = char_string(i:i)
case default
node_char_len = node_char_len + 1
node_char(node_char_len:node_char_len) = char_string(i:i)
end select
enddo
if (node_char_len > 0) then
token_pos = token_pos + 1
token(token_pos) = node_char(:node_char_len)
end if
if (token_pos > 0) then
allocate (dag_string%t(token_pos))
dag_string%t = token(:token_pos)
deallocate (token)
end if
end if
end subroutine dag_string_assign_from_char_string
@ %def dag_string_assign_from_char_string
<<Cascades2 lexer: procedures>>=
elemental subroutine dag_string_assign_from_dag_string (string_out, string_in)
type (dag_string_t), intent (out) :: string_out
type (dag_string_t), intent (in) :: string_in
if (allocated (string_in%t)) then
allocate (string_out%t (size(string_in%t)))
string_out%t = string_in%t
end if
string_out%char_len = string_in%char_len
end subroutine dag_string_assign_from_dag_string
@ %def dag_string_assign_from_dag_string
@ Concatenate strings/tokens. The result is always a [[dag_string]].
<<Cascades2 lexer: public>>=
public :: operator (//)
<<Cascades2 lexer: interfaces>>=
interface operator (//)
module procedure concat_dag_token_dag_token
module procedure concat_dag_string_dag_token
module procedure concat_dag_token_dag_string
module procedure concat_dag_string_dag_string
end interface operator (//)
@ %def interfaces
<<Cascades2 lexer: procedures>>=
function concat_dag_token_dag_token (token1, token2) result (res_string)
type (dag_token_t), intent (in) :: token1, token2
type (dag_string_t) :: res_string
if (token1%type == EMPTY_TK) then
res_string = token2
else if (token2%type == EMPTY_TK) then
res_string = token1
else
allocate (res_string%t(2))
res_string%t(1) = token1
res_string%t(2) = token2
res_string%char_len = token1%char_len + token2%char_len
end if
end function concat_dag_token_dag_token
@ %def concat_dag_token_dag_token
<<Cascades2 lexer: procedures>>=
function concat_dag_string_dag_token (dag_string, dag_token) result (res_string)
type (dag_string_t), intent (in) :: dag_string
type (dag_token_t), intent (in) :: dag_token
type (dag_string_t) :: res_string
integer :: t_size
if (dag_string%char_len == 0) then
res_string = dag_token
else if (dag_token%type == EMPTY_TK) then
res_string = dag_string
else
t_size = size (dag_string%t)
allocate (res_string%t(t_size+1))
res_string%t(:t_size) = dag_string%t
res_string%t(t_size+1) = dag_token
res_string%char_len = dag_string%char_len + dag_token%char_len
end if
end function concat_dag_string_dag_token
@ %def concat_dag_string_dag_token
<<Cascades2 lexer: procedures>>=
function concat_dag_token_dag_string (dag_token, dag_string) result (res_string)
type (dag_token_t), intent (in) :: dag_token
type (dag_string_t), intent (in) :: dag_string
type (dag_string_t) :: res_string
integer :: t_size
if (dag_token%type == EMPTY_TK) then
res_string = dag_string
else if (dag_string%char_len == 0) then
res_string = dag_token
else
t_size = size (dag_string%t)
allocate (res_string%t(t_size+1))
res_string%t(2:t_size+1) = dag_string%t
res_string%t(1) = dag_token
res_string%char_len = dag_token%char_len + dag_string%char_len
end if
end function concat_dag_token_dag_string
@ %def concat_dag_token_dag_string
<<Cascades2 lexer: procedures>>=
function concat_dag_string_dag_string (string1, string2) result (res_string)
type (dag_string_t), intent (in) :: string1, string2
type (dag_string_t) :: res_string
integer :: t1_size, t2_size, t_size
if (string1%char_len == 0) then
res_string = string2
else if (string2%char_len == 0) then
res_string = string1
else
t1_size = size (string1%t)
t2_size = size (string2%t)
t_size = t1_size + t2_size
if (t_size > 0) then
allocate (res_string%t(t_size))
res_string%t(:t1_size) = string1%t
res_string%t(t1_size+1:) = string2%t
res_string%char_len = string1%char_len + string2%char_len
end if
end if
end function concat_dag_string_dag_string
@ %def concat_dag_string_dag_string
@ Compare strings/tokens/characters. Each character is relevant, including
all blanc spaces. An exception is the [[newline]] character which is not
treated by the types used in this module (not to confused with the type
parameter [[NEW_LINE_TK]] which corresponds to the backslash character
and simply tells us that the string continues on the next line in the file).
<<Cascades2 lexer: public>>=
public :: operator (==)
<<Cascades2 lexer: interfaces>>=
interface operator (==)
module procedure dag_token_eq_dag_token
module procedure dag_string_eq_dag_string
module procedure dag_token_eq_dag_string
module procedure dag_string_eq_dag_token
module procedure dag_token_eq_char_string
module procedure char_string_eq_dag_token
module procedure dag_string_eq_char_string
module procedure char_string_eq_dag_string
end interface operator (==)
@ %def interfaces
<<Cascades2 lexer: procedures>>=
elemental function dag_token_eq_dag_token (token1, token2) result (flag)
type (dag_token_t), intent (in) :: token1, token2
logical :: flag
flag = (token1%type == token2%type) .and. &
(token1%char_len == token2%char_len) .and. &
(token1%bincode == token2%bincode) .and. &
(token1%index == token2%index) .and. &
(token1%particle_name == token2%particle_name)
end function dag_token_eq_dag_token
@ %def dag_token_eq_dag_token
<<Cascades2 lexer: procedures>>=
elemental function dag_string_eq_dag_string (string1, string2) result (flag)
type (dag_string_t), intent (in) :: string1, string2
logical :: flag
flag = (string1%char_len == string2%char_len) .and. &
(allocated (string1%t) .eqv. allocated (string2%t))
if (flag) then
if (allocated (string1%t)) flag = all (string1%t == string2%t)
end if
end function dag_string_eq_dag_string
@ %def dag_string_eq_dag_string
<<Cascades2 lexer: procedures>>=
elemental function dag_token_eq_dag_string (dag_token, dag_string) result (flag)
type (dag_token_t), intent (in) :: dag_token
type (dag_string_t), intent (in) :: dag_string
logical :: flag
flag = size (dag_string%t) == 1 .and. &
dag_string%char_len == dag_token%char_len
if (flag) flag = (dag_string%t(1) == dag_token)
end function dag_token_eq_dag_string
@ %def dag_token_eq_dag_string
<<Cascades2 lexer: procedures>>=
elemental function dag_string_eq_dag_token (dag_string, dag_token) result (flag)
type (dag_token_t), intent (in) :: dag_token
type (dag_string_t), intent (in) :: dag_string
logical :: flag
flag = (dag_token == dag_string)
end function dag_string_eq_dag_token
@ %def dag_string_eq_dag_token
<<Cascades2 lexer: procedures>>=
elemental function dag_token_eq_char_string (dag_token, char_string) result (flag)
type (dag_token_t), intent (in) :: dag_token
character (len=*), intent (in) :: char_string
logical :: flag
flag = (char (dag_token) == char_string)
end function dag_token_eq_char_string
@ %def dag_token_eq_char_string
<<Cascades2 lexer: procedures>>=
elemental function char_string_eq_dag_token (char_string, dag_token) result (flag)
type (dag_token_t), intent (in) :: dag_token
character (len=*), intent (in) :: char_string
logical :: flag
flag = (char (dag_token) == char_string)
end function char_string_eq_dag_token
@ %def char_string_eq_dag_token
<<Cascades2 lexer: procedures>>=
elemental function dag_string_eq_char_string (dag_string, char_string) result (flag)
type (dag_string_t), intent (in) :: dag_string
character (len=*), intent (in) :: char_string
logical :: flag
flag = (char (dag_string) == char_string)
end function dag_string_eq_char_string
@ %def dag_string_eq_char_string
<<Cascades2 lexer: procedures>>=
elemental function char_string_eq_dag_string (char_string, dag_string) result (flag)
type (dag_string_t), intent (in) :: dag_string
character (len=*), intent (in) :: char_string
logical :: flag
flag = (char (dag_string) == char_string)
end function char_string_eq_dag_string
@ %def char_string_eq_dag_string
<<Cascades2 lexer: public>>=
public :: operator (/=)
<<Cascades2 lexer: interfaces>>=
interface operator (/=)
module procedure dag_token_ne_dag_token
module procedure dag_string_ne_dag_string
module procedure dag_token_ne_dag_string
module procedure dag_string_ne_dag_token
module procedure dag_token_ne_char_string
module procedure char_string_ne_dag_token
module procedure dag_string_ne_char_string
module procedure char_string_ne_dag_string
end interface operator (/=)
@ %def interfaces
<<Cascades2 lexer: procedures>>=
elemental function dag_token_ne_dag_token (token1, token2) result (flag)
type (dag_token_t), intent (in) :: token1, token2
logical :: flag
flag = .not. (token1 == token2)
end function dag_token_ne_dag_token
@ %def dag_token_ne_dag_token
<<Cascades2 lexer: procedures>>=
elemental function dag_string_ne_dag_string (string1, string2) result (flag)
type (dag_string_t), intent (in) :: string1, string2
logical :: flag
flag = .not. (string1 == string2)
end function dag_string_ne_dag_string
@ %def dag_string_ne_dag_string
<<Cascades2 lexer: procedures>>=
elemental function dag_token_ne_dag_string (dag_token, dag_string) result (flag)
type (dag_token_t), intent (in) :: dag_token
type (dag_string_t), intent (in) :: dag_string
logical :: flag
flag = .not. (dag_token == dag_string)
end function dag_token_ne_dag_string
@ %def dag_token_ne_dag_string
<<Cascades2 lexer: procedures>>=
elemental function dag_string_ne_dag_token (dag_string, dag_token) result (flag)
type (dag_token_t), intent (in) :: dag_token
type (dag_string_t), intent (in) :: dag_string
logical :: flag
flag = .not. (dag_string == dag_token)
end function dag_string_ne_dag_token
@ %def dag_string_ne_dag_token
<<Cascades2 lexer: procedures>>=
elemental function dag_token_ne_char_string (dag_token, char_string) result (flag)
type (dag_token_t), intent (in) :: dag_token
character (len=*), intent (in) :: char_string
logical :: flag
flag = .not. (dag_token == char_string)
end function dag_token_ne_char_string
@ %def dag_token_ne_char_string
<<Cascades2 lexer: procedures>>=
elemental function char_string_ne_dag_token (char_string, dag_token) result (flag)
type (dag_token_t), intent (in) :: dag_token
character (len=*), intent (in) :: char_string
logical :: flag
flag = .not. (char_string == dag_token)
end function char_string_ne_dag_token
@ %def char_string_ne_dag_token
<<Cascades2 lexer: procedures>>=
elemental function dag_string_ne_char_string (dag_string, char_string) result (flag)
type (dag_string_t), intent (in) :: dag_string
character (len=*), intent (in) :: char_string
logical :: flag
flag = .not. (dag_string == char_string)
end function dag_string_ne_char_string
@ %def dag_string_ne_char_string
<<Cascades2 lexer: procedures>>=
elemental function char_string_ne_dag_string (char_string, dag_string) result (flag)
type (dag_string_t), intent (in) :: dag_string
character (len=*), intent (in) :: char_string
logical :: flag
flag = .not. (char_string == dag_string)
end function char_string_ne_dag_string
@ %def char_string_ne_dag_string
@ Convert a [[dag_token]] or [[dag_string]] to character.
<<Cascades2 lexer: public>>=
public :: char
<<Cascades2 lexer: interfaces>>=
interface char
module procedure char_dag_token
module procedure char_dag_string
end interface char
@ %def interfaces
<<Cascades2 lexer: procedures>>=
pure function char_dag_token (dag_token) result (char_string)
type (dag_token_t), intent (in) :: dag_token
character (dag_token%char_len) :: char_string
integer :: i
integer :: name_len
integer :: bc_pos
integer :: n_digits
character (len=9) :: fmt_spec
select case (dag_token%type)
case (EMPTY_TK)
char_string = ""
case (NEW_LINE_TK)
char_string = BACKSLASH_CHAR
case (BLANC_SPACE_TK)
char_string = " "
case (COLON_TK)
char_string = ":"
case (COMMA_TK)
char_string = ","
case (VERTICAL_BAR_TK)
char_string = "|"
case (OPEN_PAR_TK)
char_string = "("
case (CLOSED_PAR_TK)
char_string = ")"
case (OPEN_CURLY_TK)
char_string = "{"
case (CLOSED_CURLY_TK)
char_string = "}"
case (DAG_NODE_TK, DAG_OPTIONS_TK, DAG_COMBINATION_TK)
n_digits = dag_token%char_len - 3
fmt_spec = ""
if (n_digits > 9) then
write (fmt_spec, fmt="(A,I2,A)") "(A,I", n_digits, ",A)"
else
write (fmt_spec, fmt="(A,I1,A)") "(A,I", n_digits, ",A)"
end if
select case (dag_token%type)
case (DAG_NODE_TK)
write (char_string, fmt=fmt_spec) "<N", dag_token%index, ">"
case (DAG_OPTIONS_TK)
write (char_string, fmt=fmt_spec) "<O", dag_token%index, ">"
case (DAG_COMBINATION_TK)
write (char_string, fmt=fmt_spec) "<C", dag_token%index, ">"
end select
case (NODE_TK)
name_len = len_trim (dag_token%particle_name)
char_string = dag_token%particle_name
bc_pos = name_len + 1
char_string(bc_pos:bc_pos) = "["
do i=0, bit_size (dag_token%bincode) - 1
if (btest (dag_token%bincode, i)) then
bc_pos = bc_pos + 1
select case (i)
case (0, 1, 2, 3, 4, 5, 6, 7, 8)
write (char_string(bc_pos:bc_pos), fmt="(I1)") i + 1
case (9)
write (char_string(bc_pos:bc_pos), fmt="(A1)") "A"
case (10)
write (char_string(bc_pos:bc_pos), fmt="(A1)") "B"
case (11)
write (char_string(bc_pos:bc_pos), fmt="(A1)") "C"
end select
bc_pos = bc_pos + 1
if (bc_pos == dag_token%char_len) then
write (char_string(bc_pos:bc_pos), fmt="(A1)") "]"
return
else
write (char_string(bc_pos:bc_pos), fmt="(A1)") "/"
end if
end if
enddo
end select
end function char_dag_token
@ %def char_dag_token
<<Cascades2 lexer: procedures>>=
pure function char_dag_string (dag_string) result (char_string)
type (dag_string_t), intent (in) :: dag_string
character (dag_string%char_len) :: char_string
integer :: pos
integer :: i
char_string = ""
pos = 0
do i=1, size(dag_string%t)
char_string(pos+1:pos+dag_string%t(i)%char_len) = char (dag_string%t(i))
pos = pos + dag_string%t(i)%char_len
enddo
end function char_dag_string
@ %def char_dag_string
@ Remove all tokens which are irrelevant for parsing. These are of type
[[NEW_LINE_TK]], [[BLANC_SPACE_TK]] and [[EMTPY_TK]].
<<Cascades2 lexer: dag string: TBP>>=
procedure :: clean => dag_string_clean
<<Cascades2 lexer: procedures>>=
subroutine dag_string_clean (dag_string)
class (dag_string_t), intent (inout) :: dag_string
type (dag_token_t), dimension(:), allocatable :: tmp_token
integer :: n_keep
integer :: i
n_keep = 0
dag_string%char_len = 0
allocate (tmp_token (size(dag_string%t)))
do i=1, size (dag_string%t)
select case (dag_string%t(i)%type)
case(NEW_LINE_TK, BLANC_SPACE_TK, EMPTY_TK)
case default
n_keep = n_keep + 1
tmp_token(n_keep) = dag_string%t(i)
dag_string%char_len = dag_string%char_len + dag_string%t(i)%char_len
end select
enddo
deallocate (dag_string%t)
allocate (dag_string%t(n_keep))
dag_string%t = tmp_token(:n_keep)
end subroutine dag_string_clean
@ %def dag_string_clean
@ If we operate explicitly on the [[token]] array [[t]] of a [[dag_string]],
the variable [[char_len]] is not automatically modified. It can however be
determined afterwards using the following subroutine.
<<Cascades2 lexer: dag string: TBP>>=
procedure :: update_char_len => dag_string_update_char_len
<<Cascades2 lexer: procedures>>=
subroutine dag_string_update_char_len (dag_string)
class (dag_string_t), intent (inout) :: dag_string
integer :: char_len
integer :: i
char_len = 0
if (allocated (dag_string%t)) then
do i=1, size (dag_string%t)
char_len = char_len + dag_string%t(i)%char_len
enddo
end if
dag_string%char_len = char_len
end subroutine dag_string_update_char_len
@ %def dag_string_update_char_len
@ Append a [[dag_string]] to a [[dag_chain]]. The argument [[char_string]]
is of type [[character]] because the subroutine is used for reading from
the file produced by O'Mega which is first read line by line to a character
variable.
<<Cascades2 lexer: dag chain: TBP>>=
procedure :: append => dag_chain_append_string
<<Cascades2 lexer: procedures>>=
subroutine dag_chain_append_string (dag_chain, char_string)
class (dag_chain_t), intent (inout) :: dag_chain
character (len=*), intent (in) :: char_string
if (.not. associated (dag_chain%first)) then
allocate (dag_chain%first)
dag_chain%last => dag_chain%first
else
allocate (dag_chain%last%next)
dag_chain%last => dag_chain%last%next
end if
dag_chain%last = char_string
dag_chain%char_len = dag_chain%char_len + dag_chain%last%char_len
dag_chain%t_size = dag_chain%t_size + size (dag_chain%last%t)
end subroutine dag_chain_append_string
@ %def dag_chain_append_string
@ Reduce the linked list of [[dag_string]] objects which are attached
to a given [[dag_chain]] object to a single [[dag_string]].
<<Cascades2 lexer: dag chain: TBP>>=
procedure :: compress => dag_chain_compress
<<Cascades2 lexer: procedures>>=
subroutine dag_chain_compress (dag_chain)
class (dag_chain_t), intent (inout) :: dag_chain
type (dag_string_t), pointer :: current
type (dag_string_t), pointer :: remove
integer :: filled_t
current => dag_chain%first
dag_chain%first => null ()
allocate (dag_chain%first)
dag_chain%last => dag_chain%first
dag_chain%first%char_len = dag_chain%char_len
allocate (dag_chain%first%t (dag_chain%t_size))
filled_t = 0
do while (associated (current))
dag_chain%first%t(filled_t+1:filled_t+size(current%t)) = current%t
filled_t = filled_t + size (current%t)
remove => current
current => current%next
deallocate (remove)
enddo
end subroutine dag_chain_compress
@ %def dag_chain_compress
@ Finalizer for [[dag_string_t]].
<<Cascades2 lexer: dag string: TBP>>=
procedure :: final => dag_string_final
<<Cascades2 lexer: procedures>>=
subroutine dag_string_final (dag_string)
class (dag_string_t), intent (inout) :: dag_string
if (allocated (dag_string%t)) deallocate (dag_string%t)
dag_string%next => null ()
end subroutine dag_string_final
@ %def dag_string_final
@ Finalizer for [[dag_chain_t]].
<<Cascades2 lexer: dag chain: TBP>>=
procedure :: final => dag_chain_final
<<Cascades2 lexer: procedures>>=
subroutine dag_chain_final (dag_chain)
class (dag_chain_t), intent (inout) :: dag_chain
type (dag_string_t), pointer :: current
current => dag_chain%first
do while (associated (current))
dag_chain%first => dag_chain%first%next
call current%final ()
deallocate (current)
current => dag_chain%first
enddo
dag_chain%last => null ()
end subroutine dag_chain_final
@ %def dag_chain_final
<<[[cascades2_lexer_ut.f90]]>>=
<<File header>>
module cascades2_lexer_ut
use unit_tests
use cascades2_lexer_uti
<<Standard module head>>
<<Cascades2 lexer: public test>>
contains
<<Cascades2 lexer: test driver>>
end module cascades2_lexer_ut
@ %def cascades2_lexer_ut
@
<<[[cascades2_lexer_uti.f90]]>>=
<<File header>>
module cascades2_lexer_uti
<<Use kinds>>
<<Use strings>>
use numeric_utils
use cascades2_lexer
<<Standard module head>>
<<Cascades2 lexer: test declarations>>
contains
<<Cascades2 lexer: tests>>
end module cascades2_lexer_uti
@ %def cascades2_lexer_uti
@ API: driver for the unit tests below.
<<Cascades2 lexer: public test>>=
public :: cascades2_lexer_test
<<Cascades2 lexer: test driver>>=
subroutine cascades2_lexer_test (u, results)
integer, intent(in) :: u
type(test_results_t), intent(inout) :: results
<<Cascades2 lexer: execute tests>>
end subroutine cascades2_lexer_test
@ %def cascades2_lexer_test
@
<<Cascades2 lexer: execute tests>>=
call test (cascades2_lexer_1, "cascades2_lexer_1", &
"make phase-space", u, results)
<<Cascades2 lexer: test declarations>>=
public :: cascades2_lexer_1
<<Cascades2 lexer: tests>>=
subroutine cascades2_lexer_1 (u)
integer, intent(in) :: u
integer :: u_in = 8
character (len=300) :: line
integer :: stat
logical :: fail
type (dag_string_t) :: dag_string
write (u, "(A)") "* Test output: cascades2_lexer_1"
write (u, "(A)") "* Purpose: read lines of O'Mega's phase space output, translate"
write (u, "(A)") "* to dag_string, retranslate to character string and"
write (u, "(A)") "* compare"
write (u, "(A)")
open (unit=u_in, file="cascades2_lexer_1.fds", status='old', action='read')
stat = 0
fail = .false.
read (unit=u_in, fmt="(A)", iostat=stat) line
do while (stat == 0 .and. .not. fail)
read (unit=u_in, fmt="(A)", iostat=stat) line
if (stat /= 0) exit
dag_string = line
fail = (char(dag_string) /= line)
enddo
if (fail) then
write (u, "(A)") "* Test result: Test failed!"
else
write (u, "(A)") "* Test result: Test passed"
end if
close (u_in)
write (u, *)
write (u, "(A)") "* Test output end: cascades2_lexer_1"
end subroutine cascades2_lexer_1
@ %def cascades2_lexer_1
@%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{An alternative cascades module}
This module might replace the module [[cascades]], which generates
suitable phase space parametrizations and generates the phase space file.
The mappings, as well as the criteria to determine these, do not change.
The advantage of this module is that it makes use of the [[O'Mega]] matrix
element generator which provides the relevant Feynman diagrams (the ones
which can be constructed only from 3-vertices). In principle, the
construction of these diagrams is also one of the tasks of the existing
[[cascades]] module, in which the diagrams would correspond to a set of
cascades. It starts by creating cascades which correspond to the
outgoing particles. These are combined to a new cascade using the
vertices of the model. In this way, since each cascade knows the
daughter cascades from which it is built, complete Feynman diagrams are
represented by sets of cascades, as soon as the existing cascades can be
recombined with the incoming particle(s).
In this module, the Feynman diagrams are represented by the type
[[feyngraph_t]], which represents the Feynman diagrams as a tree of
nodes. The object which contains the necessary kinematical information
to determine mappings, and hence sensible phase space parametrizations
is of another type, called [[kingraph_t]], which is built from a
corresponding [[feyngraph]] object.
There are two types of output which can be produced by [[O'Mega]] and
are potentially relevant here. The first type contains all tree
diagrams for the process under consideration, where each line of the
output corresponds to one Feynman diagram. This output is easy to read,
but can be very large, depending on the number of particles involved in
the process. Moreover, it repeats substructures of the diagrams which
are part of more than one diagram. One could in principle work with
this output and construct a [[feyngraph]] from each line, if allowed,
i.e. if there are only 3-vertices.
The other output contains also all of these Feynman diagrams, but in
a factorized form. This means that the substructures which appear in
several Feynman diagrams, are written only once, if possible. This
leads to a much shorter input file, which speeds up the parsing
process. Furthermore it makes it possible to reconstruct the
[[feyngraphs]] in such a way that the calculations concerning
subdiagrams which reappear in other [[feyngraphs]] have to be
performed only once. This is already the case in the existing
[[cascades]] module but can be exploited more efficiently here
because the possible graphs are well known from the input file, whereas
the [[cascades]] module would create a large number of [[cascades]]
which do not lead to a complete Feynman diagram of the given process.
<<[[cascades2.f90]]>>=
<<File header>>
module cascades2
<<Use kinds>>
use kinds, only: TC, i8
<<Use debug>>
use cascades2_lexer
use sorting
use flavors
use model_data
use iso_varying_string, string_t => varying_string
use io_units
use physics_defs, only: SCALAR, SPINOR, VECTOR, VECTORSPINOR, TENSOR
use phs_forests, only: phs_parameters_t
use diagnostics
use hashes
use cascades, only: phase_space_vanishes, MAX_WARN_RESONANCE
use, intrinsic :: iso_fortran_env, only : input_unit, output_unit, error_unit
use resonances, only: resonance_info_t
use resonances, only: resonance_history_t
use resonances, only: resonance_history_set_t
<<Standard module head>>
<<Cascades2: public>>
<<Cascades2: parameters>>
<<Cascades2: types>>
<<Cascades2: interfaces>>
contains
<<Cascades2: procedures>>
end module cascades2
@ %def cascades2
@
\subsection{Particle properties}
We define a type holding the properties of the particles which are needed
for parsing and finding the phase space parametrizations and mappings.
The properties of all particles which appear in the parsed
Feynman diagrams for the given process will be stored in a central place,
and only pointers to these objects are used.
<<Cascades2: types>>=
type :: part_prop_t
character (len=LABEL_LEN) :: particle_label
integer :: pdg = 0
real(default) :: mass = 0.
real :: width = 0.
integer :: spin_type = 0
logical :: is_vector = .false.
logical :: empty = .true.
type (part_prop_t), pointer :: anti => null ()
type (string_t) :: tex_name
contains
<<Cascades2: part prop: TBP>>
end type part_prop_t
@ %def part_prop_t
@ The [[particle_label]] in [[part_prop_t]] is simply the particle name
(e.g. 'W+'). The corresponding variable in the type [[f_node_t]] contains
some additional information related to the external momenta, see below.
The length of the [[character]] variable is fixed as:
<<Cascades2: parameters>>=
integer, parameter :: LABEL_LEN=30
@ %def LABEL_LEN
<<Cascades2: part prop: TBP>>=
procedure :: final => part_prop_final
<<Cascades2: procedures>>=
subroutine part_prop_final (part)
class(part_prop_t), intent(inout) :: part
part%anti => null ()
end subroutine part_prop_final
@ %def part_prop_final
@
\subsection{The mapping modes}
The possible mappings are essentially the same as in [[cascades]], but we
introduce in addition the mapping constant [[NON_RESONANT]], which does
not refer to a new mapping; it corresponds to the nonresonant version of
a potentially resonant particle (or [[k_node]]). This becomes relevant
when we compare [[k_nodes]] to eliminate equivalences.
<<Cascades2: parameters>>=
integer, parameter :: &
& NONRESONANT = -2, EXTERNAL_PRT = -1, &
& NO_MAPPING = 0, S_CHANNEL = 1, T_CHANNEL = 2, U_CHANNEL = 3, &
& RADIATION = 4, COLLINEAR = 5, INFRARED = 6, &
& STEP_MAPPING_E = 11, STEP_MAPPING_H = 12, &
& ON_SHELL = 99
@ %def NONRESONANT EXTERNAL_PRT
@ %def NO_MAPPING S_CHANNEL T_CHANNEL U_CHANNEL
@ %def RADIATION COLLINEAR INFRARED
@ %def STEP_MAPPING_E STEP_MAPPING_H
@ %def ON_SHELL
@
\subsection{Grove properties}
The channels or [[kingraphs]] will be grouped in groves, i.e. sets of
channels, which share some characteristic numbers. These numbers are
stored in the following type:
<<Cascades2: types>>=
type :: grove_prop_t
integer :: multiplicity = 0
integer :: n_resonances = 0
integer :: n_log_enhanced = 0
integer :: n_off_shell = 0
integer :: n_t_channel = 0
integer :: res_hash = 0
end type grove_prop_t
@ %def grove_prop_t
@
\subsection{The tree type}
This type contains all the information which is needed to
reconstruct a [[feyngraph]] or [[kingraph]]. We store bincodes, pdg codes
and mappings for all nodes of a valid [[kingraph]]. If we label the
external particles as given in the process definition with integer
numbers representing their position in the process definition, the bincode
would be the number that one obtains by setting the bit at the position
that is given by this number. If we combine two particles/nodes to a third
one (using a three-vertex of the given model), the bincode is the number which
one obtains by setting all the bits which are set for the two particles.
The [[pdg]] and [[mapping]] are simply the pdg-code and mapping at the
position (i.e. propagator or external particle) which is specified by the
corresponding bincode. We use [[tree_t]] not only for completed [[kingraphs]],
but also for all [[k_nodes]], which are a subtree of a [[kingraph]].
<<Cascades2: types>>=
type :: tree_t
integer(TC), dimension(:), allocatable :: bc
integer, dimension(:), allocatable :: pdg
integer, dimension(:), allocatable :: mapping
integer :: n_entries = 0
logical :: keep = .true.
logical :: empty = .true.
contains
<<Cascades2: tree: TBP>>
end type tree_t
@ %def tree_t
<<Cascades2: tree: TBP>>=
procedure :: final => tree_final
<<Cascades2: procedures>>=
subroutine tree_final (tree)
class (tree_t), intent (inout) :: tree
if (allocated (tree%bc)) deallocate (tree%bc)
if (allocated (tree%pdg)) deallocate (tree%pdg)
if (allocated (tree%mapping)) deallocate (tree%mapping)
end subroutine tree_final
@ %def tree_final
<<Cascades2: interfaces>>=
interface assignment (=)
module procedure tree_assign
end interface assignment (=)
<<Cascades2: procedures>>=
subroutine tree_assign (tree1, tree2)
type (tree_t), intent (inout) :: tree1
type (tree_t), intent (in) :: tree2
if (allocated (tree2%bc)) then
allocate (tree1%bc(size(tree2%bc)))
tree1%bc = tree2%bc
end if
if (allocated (tree2%pdg)) then
allocate (tree1%pdg(size(tree2%pdg)))
tree1%pdg = tree2%pdg
end if
if (allocated (tree2%mapping)) then
allocate (tree1%mapping(size(tree2%mapping)))
tree1%mapping = tree2%mapping
end if
tree1%n_entries = tree2%n_entries
tree1%keep = tree2%keep
tree1%empty = tree2%empty
end subroutine tree_assign
@ %def tree_assign
@
\subsection{Add entries to the tree}
The following procedures fill the arrays in [[tree_t]] with entries
resulting from the bincode and mapping assignment.
<<Cascades2: tree: TBP>>=
procedure :: add_entry_from_numbers => tree_add_entry_from_numbers
procedure :: add_entry_from_node => tree_add_entry_from_node
generic :: add_entry => add_entry_from_numbers, add_entry_from_node
@ Here we add a single entry to each of the arrays. This will exclusively
be used for external particles.
<<Cascades2: procedures>>=
subroutine tree_add_entry_from_numbers (tree, bincode, pdg, mapping)
class (tree_t), intent (inout) :: tree
integer(TC), intent (in) :: bincode
integer, intent (in) :: pdg
integer, intent (in) :: mapping
integer :: pos
if (tree%empty) then
allocate (tree%bc(1))
allocate (tree%pdg(1))
allocate (tree%mapping(1))
pos = tree%n_entries + 1
tree%bc(pos) = bincode
tree%pdg(pos) = pdg
tree%mapping(pos) = mapping
tree%n_entries = pos
tree%empty = .false.
end if
end subroutine tree_add_entry_from_numbers
@ %def tree_add_entry_from_numbers
@ Here we merge two existing subtrees and a single entry (bc, pdg and
mapping).
<<Cascades2: procedures>>=
subroutine tree_merge (tree, tree1, tree2, bc, pdg, mapping)
class (tree_t), intent (inout) :: tree
type (tree_t), intent (in) :: tree1, tree2
integer(TC), intent (in) :: bc
integer, intent (in) :: pdg, mapping
integer :: tree_size
integer :: i1, i2
if (tree%empty) then
i1 = tree1%n_entries
i2 = tree1%n_entries + tree2%n_entries
!! Proof: tree_size > 0 (always)
tree_size = tree1%n_entries + tree2%n_entries + 1
allocate (tree%bc (tree_size))
allocate (tree%pdg (tree_size))
allocate (tree%mapping (tree_size))
if (.not. tree1%empty) then
tree%bc(:i1) = tree1%bc
tree%pdg(:i1) = tree1%pdg
tree%mapping(:i1) = tree1%mapping
end if
if (.not. tree2%empty) then
tree%bc(i1+1:i2) = tree2%bc
tree%pdg(i1+1:i2) = tree2%pdg
tree%mapping(i1+1:i2) = tree2%mapping
end if
tree%bc(tree_size) = bc
tree%pdg(tree_size) = pdg
tree%mapping(tree_size) = mapping
tree%n_entries = tree_size
tree%empty = .false.
end if
end subroutine tree_merge
@ %def tree_merge
@ Here we add entries to a tree for a given [[k_node]], which means that
we first have to determine whether the node is external or internal.
The arrays are sorted after the entries have been added (see below for
details).
<<Cascades2: procedures>>=
subroutine tree_add_entry_from_node (tree, node)
class (tree_t), intent (inout) :: tree
type (k_node_t), intent (in) :: node
integer :: pdg
if (node%t_line) then
pdg = abs (node%particle%pdg)
else
pdg = node%particle%pdg
end if
if (associated (node%daughter1) .and. &
associated (node%daughter2)) then
call tree_merge (tree, node%daughter1%subtree, &
node%daughter2%subtree, node%bincode, &
node%particle%pdg, node%mapping)
else
call tree_add_entry_from_numbers (tree, node%bincode, &
node%particle%pdg, node%mapping)
end if
call tree%sort ()
end subroutine tree_add_entry_from_node
@ %def tree_add_entry_from_node
@ For a well-defined order of the elements of the arrays in [[tree_t]],
the elements can be sorted. The bincodes (entries of [[bc]]) are
simply ordered by size, the [[pdg]] and [[mapping]] entries go to the
positions of the corresponding [[bc]] values.
<<Cascades2: tree: TBP>>=
procedure :: sort => tree_sort
<<Cascades2: procedures>>=
subroutine tree_sort (tree)
class (tree_t), intent (inout) :: tree
integer(TC), dimension(size(tree%bc)) :: bc_tmp
integer, dimension(size(tree%pdg)) :: pdg_tmp, mapping_tmp
integer, dimension(1) :: pos
integer :: i
bc_tmp = tree%bc
pdg_tmp = tree%pdg
mapping_tmp = tree%mapping
do i = size(tree%bc),1,-1
pos = maxloc (bc_tmp)
tree%bc(i) = bc_tmp (pos(1))
tree%pdg(i) = pdg_tmp (pos(1))
tree%mapping(i) = mapping_tmp (pos(1))
bc_tmp(pos(1)) = 0
end do
end subroutine tree_sort
@ %def tree_sort
@
\subsection{Graph types}
We define an abstract type which will give rise to two different types:
The type [[feyngraph_t]] contains the pure information of the
corresponding Feynman diagram, but also a list of objects of the
[[kingraph]] type which contain the kinematically relevant data for the
mapping calculation as well as the mappings themselves. Every graph
should have an index which is unique. Graphs which are not needed any
more can be disabled by setting the [[keep]] variable to [[false]].
<<Cascades2: types>>=
type, abstract :: graph_t
integer :: index = 0
integer :: n_nodes = 0
logical :: keep = .true.
end type graph_t
@ %def graph_t
@ This is the type representing the Feynman diagrams which are read from
an input file created by O'Mega. It is a tree of nodes, which we call
[[f_nodes]], so that [[feyngraph_t]] contains a pointer to the root of
this tree, and each node can have two daughter nodes. The case of only
one associated daughter should never appear, because in the method of
phase space parametrization which is used here, we combine always two
particle momenta to a third one. The [[feyngraphs]] will be arranged in
a linked list. This is why we have a pointer to the next graph. The
[[kingraphs]] on the other hand are arranged in linked lists which are
attached to the corresponding [[feyngraph]]. In general, a [[feyngraph]]
can give rise to more than one [[kingraph]] because we make a copy
every time a particle can be resonant, so that in the copy we keep
the particle nonresonant.
<<Cascades2: types>>=
type, extends (graph_t) :: feyngraph_t
type (string_t) :: omega_feyngraph_output
type (f_node_t), pointer :: root => null ()
type (feyngraph_t), pointer :: next => null()
type (kingraph_t), pointer :: kin_first => null ()
type (kingraph_t), pointer :: kin_last => null ()
contains
<<Cascades2: feyngraph: TBP>>
end type feyngraph_t
@ %def feyngraph_t
@ A container for a pointer of type [[feyngraph_t]]. This is used to
realize arrays of these pointers.
<<Cascades2: types>>=
type :: feyngraph_ptr_t
type (feyngraph_t), pointer :: graph => null ()
end type feyngraph_ptr_t
@ %def feyngraph_ptr_t
@
The length of a string describing a Feynman diagram which is produced by
O'Mega is fixed by the parameter
<<Cascades2: parameters>>=
integer, parameter :: FEYNGRAPH_LEN=300
@ %def feyngraph_len
<<Cascades2: feyngraph: TBP>>=
procedure :: final => feyngraph_final
<<Cascades2: procedures>>=
subroutine feyngraph_final (graph)
class(feyngraph_t), intent(inout) :: graph
type (kingraph_t), pointer :: current
graph%root => null ()
graph%kin_last => null ()
do while (associated (graph%kin_first))
current => graph%kin_first
graph%kin_first => graph%kin_first%next
call current%final ()
deallocate (current)
enddo
end subroutine feyngraph_final
@ %def feyngraph_final
This is the type of graph which is used to find the phase space channels,
or in other words, each kingraph could correspond to a channel, if it is
not eliminated for kinematical reasons or due to an equivalence. For the
linked list which is attached to the corresponding [[feyngraph]], we
need the [[next]] pointer, whereas [[grove_next]] points to the next
[[kingraph]] within a grove. The information which is relevant for the
specification of a channel is stored in [[tree]]. We use [[grove_prop]]
to sort the [[kingraph]] in a grove in which all [[kingraphs]] are
characterized by the numbers contained in [[grove_prop]]. Later these
groves are further subdevided using the resonance hash. A [[kingraph]]
which is constructed directly from the output of O'Mega, is not
[[inverse]]. In this case the first incoming particle is the root ofthe
tree. In a scattering process, we can also construct a [[kingraph]]
where the root of the tree is the second incoming particle. In this
case the value of [[inverse]] is [[.true.]].
<<Cascades2: types>>=
type, extends (graph_t) :: kingraph_t
type (k_node_t), pointer :: root => null ()
type (kingraph_t), pointer :: next => null()
type (kingraph_t), pointer :: grove_next => null ()
type (tree_t) :: tree
type (grove_prop_t) :: grove_prop
logical :: inverse = .false.
integer :: prc_component = 0
contains
<<Cascades2: kingraph: TBP>>
end type kingraph_t
@ %def kingraph_t
@ Another container for a pointer to emulate arrays of pointers:
<<Cascades2: types>>=
type :: kingraph_ptr_t
type (kingraph_t), pointer :: graph => null ()
end type kingraph_ptr_t
@ %def kingraph_ptr_t
@
<<Cascades2: kingraph: TBP>>=
procedure :: final => kingraph_final
<<Cascades2: procedures>>=
subroutine kingraph_final (graph)
class(kingraph_t), intent(inout) :: graph
graph%root => null ()
graph%next => null ()
graph%grove_next => null ()
call graph%tree%final ()
end subroutine kingraph_final
@ %def kingraph_final
@
\subsection{The node types}
We define an abstract type containing variables which are needed for
[[f_node_t]] as well as [[k_node_t]]. We say that a node is on the
t-line if it lies between the two nodes which correspond to the two
incoming particles. [[incoming]] and [[tline]] are used only for
scattering processes and remain [[.false.]] in decay processes. The
variable [[n_subtree_nodes]] holds the number of nodes (including the
node itself) of the subtree of which the node is the root.
<<Cascades2: types>>=
type, abstract :: node_t
type (part_prop_t), pointer :: particle => null ()
logical :: incoming = .false.
logical :: t_line = .false.
integer :: index = 0
logical :: keep = .true.
integer :: n_subtree_nodes = 1
end type node_t
@ %def node_t
@ We use two different list types for the different kinds of nodes. We
therefore start with an abstract type:
<<Cascades2: types>>=
type, abstract :: list_t
integer :: n_entries = 0
end type list_t
@ %def list_t
@ Since the contents of the lists are different, we introduce two
different entry types. Since the trees of nodes use pointers, the nodes
should only be allocated by a type-bound procedure of the corresponding
list type, such that we can keep track of all nodes, eventually reuse
and in the end deallocate nodes correctly, without forgetting any nodes.
Here is the type for the [[k_nodes]]. The list is a linked list. We want
to reuse (recycle) the [[k_nodes]] which are neither [[incoming]] nore
[[t_line]].
<<Cascades2: types>>=
type :: k_node_entry_t
type (k_node_t), pointer :: node => null ()
type (k_node_entry_t), pointer :: next => null ()
logical :: recycle = .false.
contains
<<Cascades2: k node entry: TBP>>
end type k_node_entry_t
@ %def k_node_entry_t
<<Cascades2: k node entry: TBP>>=
procedure :: final => k_node_entry_final
<<Cascades2: procedures>>=
subroutine k_node_entry_final (entry)
class(k_node_entry_t), intent(inout) :: entry
if (associated (entry%node)) then
call entry%node%final
deallocate (entry%node)
end if
entry%next => null ()
end subroutine k_node_entry_final
@ %def k_node_entry_final
<<Cascades2: k node entry: TBP>>=
procedure :: write => k_node_entry_write
<<Cascades2: procedures>>=
subroutine k_node_entry_write (k_node_entry, u)
class (k_node_entry_t), intent (in) :: k_node_entry
integer, intent (in) :: u
end subroutine k_node_entry_write
@ %def k_node_entry_write
@ Here is the list type for [[k_nodes]]. A [[k_node_list]] can be
declared to be an observer. In this case it does not create any nodes by
itself, but the entries set their pointers to existing nodes. In this
way we can use the list structure and the type bound procedures for
existing nodes.
<<Cascades2: types>>=
type, extends (list_t) :: k_node_list_t
type (k_node_entry_t), pointer :: first => null ()
type (k_node_entry_t), pointer :: last => null ()
integer :: n_recycle
logical :: observer = .false.
contains
<<Cascades2: k node list: TBP>>
end type k_node_list_t
@ %def k_node_list_t
<<Cascades2: k node list: TBP>>=
procedure :: final => k_node_list_final
<<Cascades2: procedures>>=
subroutine k_node_list_final (list)
class(k_node_list_t), intent(inout) :: list
type (k_node_entry_t), pointer :: current
do while (associated (list%first))
current => list%first
list%first => list%first%next
if (list%observer) current%node => null ()
call current%final ()
deallocate (current)
enddo
end subroutine k_node_list_final
@ %def k_node_list_final
@ The [[f_node_t]] type contains the [[particle_label]] variable which is
extracted from the input file. It consists not only of the particle
name, but also of some numbers in brackets. These numbers indicate which
external particles are part of the subtree of this node. The [[f_node]]
contains also a list of [[k_nodes]]. Therefore, if the nodes are not
[[incoming]] or [[t_line]], the mapping calculations for these
[[k_nodes]] which can appear in several [[kingraphs]] have to be
performed only once.
<<Cascades2: types>>=
type, extends (node_t) :: f_node_t
type (f_node_t), pointer :: daughter1 => null ()
type (f_node_t), pointer :: daughter2 => null ()
character (len=LABEL_LEN) :: particle_label
type (k_node_list_t) :: k_node_list
contains
<<Cascades2: f node: TBP>>
end type f_node_t
@ %def f_node_t
@ The finalizer nullifies the daughter pointers, since they are
deallocated, like the [[f_node]] itself, with the finalizer of the
[[f_node_list]].
<<Cascades2: f node: TBP>>=
procedure :: final => f_node_final
<<Cascades2: procedures>>=
recursive subroutine f_node_final (node)
class(f_node_t), intent(inout) :: node
call node%k_node_list%final ()
node%daughter1 => null ()
node%daughter2 => null ()
end subroutine f_node_final
@ %def f_node_final
@ Finaliser for [[f_node_entry]].
<<Cascades2: f node entry: TBP>>=
procedure :: final => f_node_entry_final
<<Cascades2: procedures>>=
subroutine f_node_entry_final (entry)
class(f_node_entry_t), intent(inout) :: entry
if (associated (entry%node)) then
call entry%node%final ()
deallocate (entry%node)
end if
entry%next => null ()
end subroutine f_node_entry_final
@ %def f_node_entry_final
@ Set index if not yet done, i.e. if it is zero.
<<Cascades2: f node: TBP>>=
procedure :: set_index => f_node_set_index
<<Cascades2: procedures>>=
subroutine f_node_set_index (f_node)
class (f_node_t), intent (inout) :: f_node
integer, save :: counter = 0
if (f_node%index == 0) then
counter = counter + 1
f_node%index = counter
end if
end subroutine f_node_set_index
@ %def f_node_set_index
@
Type for the nodes of the tree (lines of the Feynman diagrams). We also need a type containing a
pointer to a node, which is needed for creating arrays of pointers. This will be used for scattering
processes where we can take either the first or the second particle to be the root of the tree. Since
we need both cases for the calculations and O'Mega only gives us one of these, we have to perform a
transformation of the graph in which some nodes (on the line which we hereafter call t-line) need
to know their mother and sister nodes, which become their daughters within this transformation.
<<Cascades2: types>>=
type :: f_node_ptr_t
type (f_node_t), pointer :: node => null ()
contains
<<Cascades2: f node ptr: TBP>>
end type f_node_ptr_t
@ %def f_node_ptr_t
<<Cascades2: f node ptr: TBP>>=
procedure :: final => f_node_ptr_final
<<Cascades2: procedures>>=
subroutine f_node_ptr_final (f_node_ptr)
class (f_node_ptr_t), intent (inout) :: f_node_ptr
f_node_ptr%node => null ()
end subroutine f_node_ptr_final
@ %def f_node_ptr_final
<<Cascades2: interfaces>>=
interface assignment (=)
module procedure f_node_ptr_assign
end interface assignment (=)
<<Cascades2: procedures>>=
subroutine f_node_ptr_assign (ptr1, ptr2)
type (f_node_ptr_t), intent (out) :: ptr1
type (f_node_ptr_t), intent (in) :: ptr2
ptr1%node => ptr2%node
end subroutine f_node_ptr_assign
@ %def f_node_ptr_assign
@
<<Cascades2: types>>=
type :: k_node_ptr_t
type (k_node_t), pointer :: node => null ()
end type k_node_ptr_t
@ %def k_node_ptr_t
@
<<Cascades2: types>>=
type, extends (node_t) :: k_node_t
type (k_node_t), pointer :: daughter1 => null ()
type (k_node_t), pointer :: daughter2 => null ()
type (k_node_t), pointer :: inverse_daughter1 => null ()
type (k_node_t), pointer :: inverse_daughter2 => null ()
type (f_node_t), pointer :: f_node => null ()
type (tree_t) :: subtree
real (default) :: ext_mass_sum = 0.
real (default) :: effective_mass = 0.
logical :: resonant = .false.
logical :: on_shell = .false.
logical :: log_enhanced = .false.
integer :: mapping = NO_MAPPING
integer(TC) :: bincode = 0
logical :: mapping_assigned = .false.
logical :: is_nonresonant_copy = .false.
logical :: subtree_checked = .false.
integer :: n_off_shell = 0
integer :: n_log_enhanced = 0
integer :: n_resonances = 0
integer :: multiplicity = 0
integer :: n_t_channel = 0
integer :: f_node_index = 0
contains
<<Cascades2: k node: TBP>>
end type k_node_t
@ %def k_node_t
@
Subroutine for [[k_node]] assignment.
<<Cascades2: interfaces>>=
interface assignment (=)
module procedure k_node_assign
end interface assignment (=)
<<Cascades2: procedures>>=
subroutine k_node_assign (k_node1, k_node2)
type (k_node_t), intent (inout) :: k_node1
type (k_node_t), intent (in) :: k_node2
k_node1%f_node => k_node2%f_node
k_node1%particle => k_node2%particle
k_node1%incoming = k_node2%incoming
k_node1%t_line = k_node2%t_line
k_node1%keep = k_node2%keep
k_node1%n_subtree_nodes = k_node2%n_subtree_nodes
k_node1%ext_mass_sum = k_node2%ext_mass_sum
k_node1%effective_mass = k_node2%effective_mass
k_node1%resonant = k_node2%resonant
k_node1%on_shell = k_node2%on_shell
k_node1%log_enhanced = k_node2%log_enhanced
k_node1%mapping = k_node2%mapping
k_node1%bincode = k_node2%bincode
k_node1%mapping_assigned = k_node2%mapping_assigned
k_node1%is_nonresonant_copy = k_node2%is_nonresonant_copy
k_node1%n_off_shell = k_node2%n_off_shell
k_node1%n_log_enhanced = k_node2%n_log_enhanced
k_node1%n_resonances = k_node2%n_resonances
k_node1%multiplicity = k_node2%multiplicity
k_node1%n_t_channel = k_node2%n_t_channel
k_node1%f_node_index = k_node2%f_node_index
end subroutine k_node_assign
@ %def k_node_assign
@ The finalizer of [[k_node_t]] nullifies all pointers to nodes, since the
deallocation of these nodes takes place in the finalizer of the list by which
they were created.
<<Cascades2: k node: TBP>>=
procedure :: final => k_node_final
<<Cascades2: procedures>>=
recursive subroutine k_node_final (k_node)
class(k_node_t), intent(inout) :: k_node
k_node%daughter1 => null ()
k_node%daughter2 => null ()
k_node%inverse_daughter1 => null ()
k_node%inverse_daughter2 => null ()
k_node%f_node => null ()
end subroutine k_node_final
@ %def k_node_final
@ Set an index to a [[k_node]], if not yet done, i.e. if it is zero. The
indices are simply positive integer numbers starting from 1.
<<Cascades2: k node: TBP>>=
procedure :: set_index => k_node_set_index
<<Cascades2: procedures>>=
subroutine k_node_set_index (k_node)
class (k_node_t), intent (inout) :: k_node
integer, save :: counter = 0
if (k_node%index == 0) then
counter = counter + 1
k_node%index = counter
end if
end subroutine k_node_set_index
@ %def k_node_set_index
@ The process type (decay or scattering) is given by an integer which is
equal to the number of incoming particles.
<<Cascades2: public>>=
public :: DECAY, SCATTERING
<<Cascades2: parameters>>=
integer, parameter :: DECAY=1, SCATTERING=2
@ %def decay scattering
@ The entries of the [[f_node_list]] contain the substring of the input
file from which the node's subtree will be constructed (or a modified
string containing placeholders for substrings). We use the
length of this string for fast comparison to find the nodes in the
[[f_node_list]] which we want to reuse.
<<Cascades2: types>>=
type :: f_node_entry_t
character (len=FEYNGRAPH_LEN) :: subtree_string
integer :: string_len = 0
type (f_node_t), pointer :: node => null ()
type (f_node_entry_t), pointer :: next => null ()
integer :: subtree_size = 0
contains
<<Cascades2: f node entry: TBP>>
end type f_node_entry_t
@ %def f_node_entry_t
@ A write method for [[f_node_entry]].
<<Cascades2: f node entry: TBP>>=
procedure :: write => f_node_entry_write
<<Cascades2: procedures>>=
subroutine f_node_entry_write (f_node_entry, u)
class (f_node_entry_t), intent (in) :: f_node_entry
integer, intent (in) :: u
write (unit=u, fmt='(A)') trim(f_node_entry%subtree_string)
end subroutine f_node_entry_write
@ %def f_node_entry_write
<<Cascades2: interfaces>>=
interface assignment (=)
module procedure f_node_entry_assign
end interface assignment (=)
<<Cascades2: procedures>>=
subroutine f_node_entry_assign (entry1, entry2)
type (f_node_entry_t), intent (out) :: entry1
type (f_node_entry_t), intent (in) :: entry2
entry1%node => entry2%node
entry1%subtree_string = entry2%subtree_string
entry1%string_len = entry2%string_len
entry1%subtree_size = entry2%subtree_size
end subroutine f_node_entry_assign
@ %def f_node_entry_assign
@ This is the list type for [[f_nodes]]. The variable [[max_tree_size]]
is the number of nodes which appear in a complete graph.
<<Cascades2: types>>=
type, extends (list_t) :: f_node_list_t
type (f_node_entry_t), pointer :: first => null ()
type (f_node_entry_t), pointer :: last => null ()
type (k_node_list_t), pointer :: k_node_list => null ()
integer :: max_tree_size = 0
contains
<<Cascades2: f node list: TBP>>
end type f_node_list_t
@ %def f_node_list_t
@ Add an entry to the [[f_node_list]]. If the node might be reused, we check first
using the [[subtree_string]] if there is already a node in the list which
is the root of exactly the same subtree. Otherwise we add an entry to the
list and allocate the node. In both cases we return a pointer to the node
which allows to access the node.
<<Cascades2: f node list: TBP>>=
procedure :: add_entry => f_node_list_add_entry
<<Cascades2: procedures>>=
subroutine f_node_list_add_entry (list, subtree_string, ptr_to_node, &
recycle, subtree_size)
class (f_node_list_t), intent (inout) :: list
character (len=*), intent (in) :: subtree_string
type (f_node_t), pointer, intent (out) :: ptr_to_node
logical, intent (in) :: recycle
integer, intent (in), optional :: subtree_size
type (f_node_entry_t), pointer :: current
type (f_node_entry_t), pointer :: second
integer :: subtree_len
ptr_to_node => null ()
if (recycle) then
subtree_len = len_trim (subtree_string)
current => list%first
do while (associated (current))
if (present (subtree_size)) then
if (current%subtree_size /= subtree_size) exit
end if
if (current%string_len == subtree_len) then
if (trim (current%subtree_string) == trim (subtree_string)) then
ptr_to_node => current%node
exit
end if
end if
current => current%next
enddo
end if
if (.not. associated (ptr_to_node)) then
if (list%n_entries == 0) then
allocate (list%first)
list%last => list%first
else
second => list%first
list%first => null ()
allocate (list%first)
list%first%next => second
end if
list%n_entries = list%n_entries + 1
list%first%subtree_string = trim(subtree_string)
list%first%string_len = subtree_len
if (present (subtree_size)) list%first%subtree_size = subtree_size
allocate (list%first%node)
call list%first%node%set_index ()
ptr_to_node => list%first%node
end if
end subroutine f_node_list_add_entry
@ %def f_node_list_add_entry
@ A write method for debugging.
<<Cascades2: f node list: TBP>>=
procedure :: write => f_node_list_write
<<Cascades2: procedures>>=
subroutine f_node_list_write (f_node_list, u)
class (f_node_list_t), intent (in) :: f_node_list
integer, intent (in) :: u
type (f_node_entry_t), pointer :: current
integer :: pos = 0
current => f_node_list%first
do while (associated (current))
pos = pos + 1
write (unit=u, fmt='(A,I10)') 'entry #: ', pos
call current%write (u)
write (unit=u, fmt=*)
current => current%next
enddo
end subroutine f_node_list_write
@ %def f_node_list_write
<<Cascades2: interfaces>>=
interface assignment (=)
module procedure k_node_entry_assign
end interface assignment (=)
<<Cascades2: procedures>>=
subroutine k_node_entry_assign (entry1, entry2)
type (k_node_entry_t), intent (out) :: entry1
type (k_node_entry_t), intent (in) :: entry2
entry1%node => entry2%node
entry1%recycle = entry2%recycle
end subroutine k_node_entry_assign
@ %def k_node_entry_assign
@ Add an entry to the [[k_node_list]]. We have to specify if the
node can be reused. The check for existing reusable nodes happens with
[[k_node_list_get_nodes]] (see below).
<<Cascades2: k node list: TBP>>=
procedure :: add_entry => k_node_list_add_entry
<<Cascades2: procedures>>=
recursive subroutine k_node_list_add_entry (list, ptr_to_node, recycle)
class (k_node_list_t), intent (inout) :: list
type (k_node_t), pointer, intent (out) :: ptr_to_node
logical, intent (in) :: recycle
if (list%n_entries == 0) then
allocate (list%first)
list%last => list%first
else
allocate (list%last%next)
list%last => list%last%next
end if
list%n_entries = list%n_entries + 1
list%last%recycle = recycle
allocate (list%last%node)
call list%last%node%set_index ()
ptr_to_node => list%last%node
end subroutine k_node_list_add_entry
@ %def k_node_list_add_entry
@ We need a similar subroutine for adding only a pointer to a list. This
is needed for a [[k_node_list]] which is only an observer, i.e. it does
not create any nodes by itself.
<<Cascades2: k node list: TBP>>=
procedure :: add_pointer => k_node_list_add_pointer
<<Cascades2: procedures>>=
subroutine k_node_list_add_pointer (list, ptr_to_node, recycle)
class (k_node_list_t), intent (inout) :: list
type (k_node_t), pointer, intent (in) :: ptr_to_node
logical, optional, intent (in) :: recycle
logical :: rec
if (present (recycle)) then
rec = recycle
else
rec = .false.
end if
if (list%n_entries == 0) then
allocate (list%first)
list%last => list%first
else
allocate (list%last%next)
list%last => list%last%next
end if
list%n_entries = list%n_entries + 1
list%last%recycle = rec
list%last%node => ptr_to_node
end subroutine k_node_list_add_pointer
@ %def k_node_list_add_pointer
@ The [[k_node_list]] can also be used to collect [[k_nodes]] which belong to
different [[f_nodes]] in order to compare these. This is done only for nodes
which have the same number of subtree nodes. We compare all nodes of the
list with each other (as long as the node is not deactivated, i.e. if
the [[keep]] variable is set to [[.true.]]) using the subroutine
[[subtree_select]]. If it turns out that two nodes are equivalent, we
keep only one of them. The term equivalent in this module refers to trees
or subtrees which differ in the pdg codes at positions where
the trivial mapping is used ([[NO_MAPPING]] or [[NON_RESONANT]]) so that
the mass of the particle does not matter. Depending on the available
couplings, two equivalent subtrees could eventually lead to the same phase
space channels, which is why only one of them is kept.
<<Cascades2: k node list: TBP>>=
procedure :: check_subtree_equivalences => k_node_list_check_subtree_equivalences
<<Cascades2: procedures>>=
subroutine k_node_list_check_subtree_equivalences (list, model)
class (k_node_list_t), intent (inout) :: list
type (model_data_t), intent (in) :: model
type (k_node_ptr_t), dimension (:), allocatable :: set
type (k_node_entry_t), pointer :: current
integer :: pos
integer :: i,j
if (list%n_entries == 0) return
allocate (set (list%n_entries))
current => list%first
pos = 0
do while (associated (current))
pos = pos + 1
set(pos)%node => current%node
current => current%next
enddo
do i=1, list%n_entries
if (set(i)%node%keep) then
do j=i+1, list%n_entries
if (set(j)%node%keep) then
if (set(i)%node%bincode == set(j)%node%bincode) then
call subtree_select (set(i)%node%subtree,set(j)%node%subtree, model)
if (.not. set(i)%node%subtree%keep) then
set(i)%node%keep = .false.
exit
else if (.not. set(j)%node%subtree%keep) then
set(j)%node%keep = .false.
end if
end if
end if
enddo
end if
enddo
deallocate (set)
end subroutine k_node_list_check_subtree_equivalences
@ %def k_node_list_check_subtree_equivalences
@ This subroutine is used to obtain all [[k_nodes]] of a [[k_node_list]]
which can be recycled and are not disabled for some reason. We pass an
allocatable array of the type [[k_node_ptr_t]] which will be allocated
if there are any such nodes in the list and the pointers will be
associated with these nodes.
<<Cascades2: k node list: TBP>>=
procedure :: get_nodes => k_node_list_get_nodes
<<Cascades2: procedures>>=
subroutine k_node_list_get_nodes (list, nodes)
class (k_node_list_t), intent (inout) :: list
type (k_node_ptr_t), dimension(:), allocatable, intent (out) :: nodes
integer :: n_nodes
integer :: pos
type (k_node_entry_t), pointer :: current, garbage
n_nodes = 0
current => list%first
do while (associated (current))
if (current%recycle .and. current%node%keep) n_nodes = n_nodes + 1
current => current%next
enddo
if (n_nodes /= 0) then
pos = 1
allocate (nodes (n_nodes))
do while (associated (list%first) .and. .not. list%first%node%keep)
garbage => list%first
list%first => list%first%next
call garbage%final ()
deallocate (garbage)
enddo
current => list%first
do while (associated (current))
do while (associated (current%next))
if (.not. current%next%node%keep) then
garbage => current%next
current%next => current%next%next
call garbage%final
deallocate (garbage)
else
exit
end if
enddo
if (current%recycle .and. current%node%keep) then
nodes(pos)%node => current%node
pos = pos + 1
end if
current => current%next
enddo
end if
end subroutine k_node_list_get_nodes
@ %def k_node_list_get_nodes
<<Cascades2: f node list: TBP>>=
procedure :: final => f_node_list_final
<<Cascades2: procedures>>=
subroutine f_node_list_final (list)
class (f_node_list_t) :: list
type (f_node_entry_t), pointer :: current
list%k_node_list => null ()
do while (associated (list%first))
current => list%first
list%first => list%first%next
call current%final ()
deallocate (current)
enddo
end subroutine f_node_list_final
@ %def f_node_list_final
@
\subsection{The grove list}
First a type is introduced in order to speed up the comparison of kingraphs
with the purpose to quickly find the graphs that might be equivalent.
This is done solely on the basis of a number (which is given
by the value of [[depth]] in [[compare_tree_t]]) of bincodes, which are
the highest ones that do not belong to external particles.
The highest such value determines the index of the element in the [[entry]]
array of the [[compare_tree]]. The next lower such value determines
the index of the element in the [[entry]] array of this [[entry]], and so
on and so forth. This results in a tree structure where the number of
levels is given by [[depth]] and should not be too large for reasons of
memory.
This is the entry type.
<<Cascades2: types>>=
type :: compare_tree_entry_t
type (compare_tree_entry_t), dimension(:), pointer :: entry => null ()
type (kingraph_ptr_t), dimension(:), allocatable :: graph_entry
contains
<<Cascades2: compare tree entry: TBP>>
end type compare_tree_entry_t
@ %def compare_tree_entry_t
@ This is the tree type.
<<Cascades2: types>>=
type :: compare_tree_t
integer :: depth = 3
type (compare_tree_entry_t), dimension(:), pointer :: entry => null ()
contains
<<Cascades2: compare tree: TBP>>
end type compare_tree_t
@ %def compare_tree_t
@ Finalizers for both types. The one for the entry type has to be recursive.
<<Cascades2: compare tree: TBP>>=
procedure :: final => compare_tree_final
<<Cascades2: procedures>>=
subroutine compare_tree_final (ctree)
class (compare_tree_t), intent (inout) :: ctree
integer :: i
if (associated (ctree%entry)) then
do i=1, size (ctree%entry)
call ctree%entry(i)%final ()
deallocate (ctree%entry)
end do
end if
end subroutine compare_tree_final
@ %def compare_tree_final
<<Cascades2: compare tree entry: TBP>>=
procedure :: final => compare_tree_entry_final
<<Cascades2: procedures>>=
recursive subroutine compare_tree_entry_final (ct_entry)
class (compare_tree_entry_t), intent (inout) :: ct_entry
integer :: i
if (associated (ct_entry%entry)) then
do i=1, size (ct_entry%entry)
call ct_entry%entry(i)%final ()
enddo
deallocate (ct_entry%entry)
else
deallocate (ct_entry%graph_entry)
end if
end subroutine compare_tree_entry_final
@ %def compare_tree_entry_final
@ Check the presence of a graph which is considered as equivalent and
select between the two. If there is no such graph, the current one
is added to the list. First the entry has to be found:
<<Cascades2: compare tree: TBP>>=
procedure :: check_kingraph => compare_tree_check_kingraph
<<Cascades2: procedures>>=
subroutine compare_tree_check_kingraph (ctree, kingraph, model, preliminary)
class (compare_tree_t), intent (inout) :: ctree
type (kingraph_t), intent (inout), pointer :: kingraph
type (model_data_t), intent (in) :: model
logical, intent (in) :: preliminary
integer :: i
integer :: pos
integer(TC) :: sz
integer(TC), dimension(:), allocatable :: identifier
if (.not. associated (ctree%entry)) then
sz = 0_TC
do i = size(kingraph%tree%bc), 1, -1
sz = ior (sz, kingraph%tree%bc(i))
enddo
if (sz > 0) then
allocate (ctree%entry (sz))
else
call msg_bug ("Compare tree could not be created")
end if
end if
allocate (identifier (ctree%depth))
pos = 0
do i = size(kingraph%tree%bc), 1, -1
if (popcnt (kingraph%tree%bc(i)) /= 1) then
pos = pos + 1
identifier(pos) = kingraph%tree%bc(i)
if (pos == ctree%depth) exit
end if
enddo
if (size (identifier) > 1) then
call ctree%entry(identifier(1))%check_kingraph (kingraph, model, &
preliminary, identifier(1), identifier(2:))
else if (size (identifier) == 1) then
call ctree%entry(identifier(1))%check_kingraph (kingraph, model, preliminary)
end if
deallocate (identifier)
end subroutine compare_tree_check_kingraph
@ %def compare_tree_check_kingraph
@ Then the graphs of the entry are checked.
<<Cascades2: compare tree entry: TBP>>=
procedure :: check_kingraph => compare_tree_entry_check_kingraph
<<Cascades2: procedures>>=
recursive subroutine compare_tree_entry_check_kingraph (ct_entry, kingraph, &
model, preliminary, subtree_size, identifier)
class (compare_tree_entry_t), intent (inout) :: ct_entry
type (kingraph_t), pointer, intent (inout) :: kingraph
type (model_data_t), intent (in) :: model
logical, intent (in) :: preliminary
integer, intent (in), optional :: subtree_size
integer, dimension (:), intent (in), optional :: identifier
if (present (identifier)) then
if (.not. associated (ct_entry%entry)) &
allocate (ct_entry%entry(subtree_size))
if (size (identifier) > 1) then
call ct_entry%entry(identifier(1))%check_kingraph (kingraph, &
model, preliminary, identifier(1), identifier(2:))
else if (size (identifier) == 1) then
call ct_entry%entry(identifier(1))%check_kingraph (kingraph, &
model, preliminary)
end if
else
if (allocated (ct_entry%graph_entry)) then
call perform_check
else
allocate (ct_entry%graph_entry(1))
ct_entry%graph_entry(1)%graph => kingraph
end if
end if
contains
subroutine perform_check
integer :: i
logical :: rebuild
rebuild = .true.
do i=1, size(ct_entry%graph_entry)
if (ct_entry%graph_entry(i)%graph%keep) then
if (preliminary .or. &
ct_entry%graph_entry(i)%graph%prc_component /= kingraph%prc_component) then
call kingraph_select (ct_entry%graph_entry(i)%graph, kingraph, model, preliminary)
if (.not. kingraph%keep) then
return
else if (rebuild .and. .not. ct_entry%graph_entry(i)%graph%keep) then
ct_entry%graph_entry(i)%graph => kingraph
rebuild = .false.
end if
end if
end if
enddo
if (rebuild) call rebuild_graph_entry
end subroutine perform_check
subroutine rebuild_graph_entry
type (kingraph_ptr_t), dimension(:), allocatable :: tmp_ptr
integer :: i
integer :: pos
allocate (tmp_ptr(size(ct_entry%graph_entry)+1))
pos = 0
do i=1, size(ct_entry%graph_entry)
pos = pos + 1
tmp_ptr(pos)%graph => ct_entry%graph_entry(i)%graph
enddo
pos = pos + 1
tmp_ptr(pos)%graph => kingraph
deallocate (ct_entry%graph_entry)
allocate (ct_entry%graph_entry (pos))
do i=1, pos
ct_entry%graph_entry(i)%graph => tmp_ptr(i)%graph
enddo
deallocate (tmp_ptr)
end subroutine rebuild_graph_entry
end subroutine compare_tree_entry_check_kingraph
@ %def compare_tree_entry_check_kingraph
@ The grove to which a completed [[kingraph]] will be added is determined by the
entries of [[grove_prop]]. We use another list type (linked list) to
arrange the groves. Each [[grove]] contains again a linked list of
[[kingraphs]].
<<Cascades2: types>>=
type :: grove_t
type (grove_prop_t) :: grove_prop
type (grove_t), pointer :: next => null ()
type (kingraph_t), pointer :: first => null ()
type (kingraph_t), pointer :: last => null ()
type (compare_tree_t) :: compare_tree
contains
<<Cascades2: grove: TBP>>
end type grove_t
@ %def grove_t
@ Container for a pointer of type [[grove_t]]:
<<Cascades2: types>>=
type :: grove_ptr_t
type (grove_t), pointer :: grove => null ()
end type grove_ptr_t
@ %def grove_ptr_t
<<Cascades2: grove: TBP>>=
procedure :: final => grove_final
<<Cascades2: procedures>>=
subroutine grove_final (grove)
class(grove_t), intent(inout) :: grove
grove%first => null ()
grove%last => null ()
grove%next => null ()
end subroutine grove_final
@ %def grove_final
@ This is the list type:
<<Cascades2: types>>=
type :: grove_list_t
type (grove_t), pointer :: first => null ()
contains
<<Cascades2: grove list: TBP>>
end type grove_list_t
@ %def grove_list_t
<<Cascades2: grove list: TBP>>=
procedure :: final => grove_list_final
<<Cascades2: procedures>>=
subroutine grove_list_final (list)
class(grove_list_t), intent(inout) :: list
class(grove_t), pointer :: current
do while (associated (list%first))
current => list%first
list%first => list%first%next
call current%final ()
deallocate (current)
end do
end subroutine grove_list_final
@ %def grove_list_final
@
\subsection{The feyngraph set}
The fundament of the module is the public type [[feyngraph_set_t]]. It
is not only a linked list of all [[feyngraphs]] but contains an array
of all particle properties ([[particle]]), an [[f_node_list]] and a
pointer of the type [[grove_list_t]], since several [[feyngraph_sets]]
can share a common [[grove_list]]. In addition it keeps the data which
unambiguously specifies the process, as well as the model which
provides information which allows us to choose between equivalent
subtrees or complete [[kingraphs]].
<<Cascades2: public>>=
public :: feyngraph_set_t
<<Cascades2: types>>=
type :: feyngraph_set_t
type (model_data_t), pointer :: model => null ()
type(flavor_t), dimension(:,:), allocatable :: flv
integer :: n_in = 0
integer :: n_out = 0
integer :: process_type = DECAY
type (phs_parameters_t) :: phs_par
logical :: fatal_beam_decay = .true.
type (part_prop_t), dimension (:), pointer :: particle => null ()
type (f_node_list_t) :: f_node_list
type (feyngraph_t), pointer :: first => null ()
type (feyngraph_t), pointer :: last => null ()
integer :: n_graphs = 0
type (grove_list_t), pointer :: grove_list => null ()
logical :: use_dag = .true.
type (dag_t), pointer :: dag => null ()
type (feyngraph_set_t), dimension (:), pointer :: fset => null ()
contains
<<Cascades2: feyngraph set: TBP>>
end type feyngraph_set_t
@ %def feyngraph_set_t
@ This final procedure contains calls to all other necessary final
procedures.
<<Cascades2: feyngraph set: TBP>>=
procedure :: final => feyngraph_set_final
<<Cascades2: procedures>>=
recursive subroutine feyngraph_set_final (set)
class(feyngraph_set_t), intent(inout) :: set
class(feyngraph_t), pointer :: current
integer :: i
if (associated (set%fset)) then
do i=1, size (set%fset)
call set%fset(i)%final ()
enddo
deallocate (set%fset)
else
set%particle => null ()
set%grove_list => null ()
end if
set%model => null ()
if (allocated (set%flv)) deallocate (set%flv)
set%last => null ()
do while (associated (set%first))
current => set%first
set%first => set%first%next
call current%final ()
deallocate (current)
end do
if (associated (set%particle)) then
do i = 1, size (set%particle)
call set%particle(i)%final ()
end do
deallocate (set%particle)
end if
if (associated (set%grove_list)) then
if (debug_on) call msg_debug (D_PHASESPACE, "grove_list: final")
call set%grove_list%final ()
deallocate (set%grove_list)
end if
if (debug_on) call msg_debug (D_PHASESPACE, "f_node_list: final")
call set%f_node_list%final ()
if (associated (set%dag)) then
if (debug_on) call msg_debug (D_PHASESPACE, "dag: final")
if (associated (set%dag)) then
call set%dag%final ()
deallocate (set%dag)
end if
end if
end subroutine feyngraph_set_final
@ %def feyngraph_set_final
@
\subsection{Construct the feyngraph set}
We construct the [[feyngraph_set]] from an input file. Therefore we pass
a unit to [[feyngraph_set_build]]. The parsing subroutines are chosen
depending on the value of [[use_dag]]. In the DAG output, which is the one
that is produced by default, we have to work on a string of one line,
where the lenght of this string becomes larger the more particles are
involved in the process. The other output (which is now only used in a
unit test) contains one Feynman diagram per line and each line starts with an open
parenthesis so that we read the file line per line and create a
[[feyngraph]] for every line. Only after this, nodes are created. In both
decay and scattering processes the diagrams are represented like in a decay
process, i.e. in a scattering process one of the incoming particles appears
as an outgoing particle.
<<Cascades2: feyngraph set: TBP>>=
procedure :: build => feyngraph_set_build
<<Cascades2: procedures>>=
subroutine feyngraph_set_build (feyngraph_set, u_in)
class (feyngraph_set_t), intent (inout) :: feyngraph_set
integer, intent (in) :: u_in
integer :: stat = 0
character (len=FEYNGRAPH_LEN) :: omega_feyngraph_output
type (feyngraph_t), pointer :: current_graph
type (feyngraph_t), pointer :: compare_graph
logical :: present
if (feyngraph_set%use_dag) then
allocate (feyngraph_set%dag)
if (.not. associated (feyngraph_set%first)) then
call feyngraph_set%dag%read_string (u_in, feyngraph_set%flv(:,1))
call feyngraph_set%dag%construct (feyngraph_set)
call feyngraph_set%dag%make_feyngraphs (feyngraph_set)
end if
else
if (.not. associated (feyngraph_set%first)) then
read (unit=u_in, fmt='(A)', iostat=stat, advance='yes') omega_feyngraph_output
if (omega_feyngraph_output(1:1) == '(') then
allocate (feyngraph_set%first)
feyngraph_set%first%omega_feyngraph_output = trim(omega_feyngraph_output)
feyngraph_set%last => feyngraph_set%first
feyngraph_set%n_graphs = feyngraph_set%n_graphs + 1
else
call msg_fatal ("Invalid input file")
end if
read (unit=u_in, fmt='(A)', iostat=stat, advance='yes') omega_feyngraph_output
do while (stat == 0)
if (omega_feyngraph_output(1:1) == '(') then
compare_graph => feyngraph_set%first
present = .false.
do while (associated (compare_graph))
if (len_trim(compare_graph%omega_feyngraph_output) &
== len_trim(omega_feyngraph_output)) then
if (compare_graph%omega_feyngraph_output == omega_feyngraph_output) then
present = .true.
exit
end if
end if
compare_graph => compare_graph%next
enddo
if (.not. present) then
allocate (feyngraph_set%last%next)
feyngraph_set%last => feyngraph_set%last%next
feyngraph_set%last%omega_feyngraph_output = trim(omega_feyngraph_output)
feyngraph_set%n_graphs = feyngraph_set%n_graphs + 1
end if
read (unit=u_in, fmt='(A)', iostat=stat, advance='yes') omega_feyngraph_output
else
exit
end if
enddo
current_graph => feyngraph_set%first
do while (associated (current_graph))
call feyngraph_construct (feyngraph_set, current_graph)
current_graph => current_graph%next
enddo
feyngraph_set%f_node_list%max_tree_size = feyngraph_set%first%n_nodes
end if
end if
end subroutine feyngraph_set_build
@ %def feyngraph_set_build
@ Read the string from the file. The output which is produced by O'Mega
contains the DAG in a factorised form as a long string, distributed over
several lines (in addition, in the case of a scattering process, it
contains a similar string for the same process, but with the other
incoming particle as the root of the tree structure). In general, such a
file can contain many of these strings, belonging to different process
components. Therefore we first have to find the correct position of the
string for the process in question. Therefore we look for a line
containing a pair of colons, in which case the line contains a process
string. Then we check if the process string describes the correct
process, which is done by checking for all the incoming and outgoing
particle names. If the process is correct, the dag output should start
in the following line. As long as we do not find the correct process
string, we continue searching. If we reach the end of the file, we
rewind the unit once, and repeat searching. If the process is still not
found, there must be some sort of error.
<<Cascades2: dag: TBP>>=
procedure :: read_string => dag_read_string
<<Cascades2: procedures>>=
subroutine dag_read_string (dag, u_in, flv)
class (dag_t), intent (inout) :: dag
integer, intent (in) :: u_in
type(flavor_t), dimension(:), intent(in) :: flv
character (len=BUFFER_LEN) :: process_string
logical :: process_found
logical :: rewound
!!! find process string in file
process_found = .false.
rewound = .false.
do while (.not. process_found)
process_string = ""
read (unit=u_in, fmt='(A)') process_string
if (len_trim(process_string) /= 0) then
if (index (process_string, "::") > 0) then
process_found = process_string_match (trim (process_string), flv)
end if
else if (.not. rewound) then
rewind (u_in)
rewound = .true.
else
call msg_bug ("Process string not found in O'Mega input file.")
end if
enddo
call fds_file_get_line (u_in, dag%string)
call dag%string%clean ()
if (.not. allocated (dag%string%t) .or. dag%string%char_len == 0) &
call msg_bug ("Process string not found in O'Mega input file.")
end subroutine dag_read_string
@ %def dag_read_string
@ The output of factorized Feynman diagrams which is created by O'Mega
for a given process could in principle be written to a single line in
the file. This can however lead to different problems with different
compilers as soon as such lines become too long. This is the reason why
the line is cut into smaller pieces. This means that a new line starts
after each vertical bar. For this long string the type [[dag_string_t]]
has been introduced. In order to read the file quickly into such a
[[dag_string]] we use another type, [[dag_chain_t]] which is a linked
list of such [[dag_strings]]. This has the advantage that we do not
have to recreate a new [[dag_string]] for every line which has been
read from file. Only in the end of this operation we compress the
list of strings to a single string, removing useless [[dag_tokens]],
such as blanc space tokens. This subroutine reads all lines starting
from the position in the file the unit is connected to, until no
backslash character is found at the end of a line (the backslash
means that the next line also belongs to the current string).
<<Cascades2: parameters>>=
integer, parameter :: BUFFER_LEN = 1000
integer, parameter :: STACK_SIZE = 100
@ %def BUFFER_LEN STACK_SIZE
<<Cascades2: procedures>>=
subroutine fds_file_get_line (u, string)
integer, intent (in) :: u
type (dag_string_t), intent (out) :: string
type (dag_chain_t) :: chain
integer :: string_size, current_len
character (len=BUFFER_LEN) :: buffer
integer :: fragment_len
integer :: stat
current_len = 0
stat = 0
string_size = 0
do while (stat == 0)
read (unit=u, fmt='(A)', iostat=stat) buffer
if (stat /= 0) exit
fragment_len = len_trim (buffer)
if (fragment_len == 0) then
exit
else if (buffer (fragment_len:fragment_len) == BACKSLASH_CHAR) then
fragment_len = fragment_len - 1
end if
call chain%append (buffer(:fragment_len))
if (buffer(fragment_len+1:fragment_len+1) /= BACKSLASH_CHAR) exit
enddo
if (associated (chain%first)) then
call chain%compress ()
string = chain%first
call chain%final ()
end if
end subroutine fds_file_get_line
@ %def fds_file_get_line
@ We check, if the process string which has been read from file
corresponds to the process for which we want to extract the Feynman
diagrams.
<<Cascades2: procedures>>=
function process_string_match (string, flv) result (match)
character (len=*), intent(in) :: string
type(flavor_t), dimension(:), intent(in) :: flv
logical :: match
integer :: pos
integer :: occurence
integer :: i
pos = 1
match = .false.
do i=1, size (flv)
occurence = index (string(pos:), char(flv(i)%get_name()))
if (occurence > 0) then
pos = pos + occurence
match = .true.
else
match = .false.
exit
end if
enddo
end function process_string_match
@ %def process_string_match
@
\subsection{Particle properties}
This subroutine initializes a model instance with the Standard Model
data. It is only relevant for a unit test.
We do not have to care about the model initialization in this module
because the [[model]] is passed to [[feyngraph_set_generate]] when
it is called.
<<Cascades2: public>>=
public :: init_sm_full_test
<<Cascades2: procedures>>=
subroutine init_sm_full_test (model)
class(model_data_t), intent(out) :: model
type(field_data_t), pointer :: field
integer, parameter :: n_real = 17
integer, parameter :: n_field = 21
integer, parameter :: n_vtx = 56
integer :: i
call model%init (var_str ("SM_vertex_test"), &
n_real, 0, n_field, n_vtx)
call model%init_par (1, var_str ("mZ"), 91.1882_default)
call model%init_par (2, var_str ("mW"), 80.419_default)
call model%init_par (3, var_str ("mH"), 125._default)
call model%init_par (4, var_str ("me"), 0.000510997_default)
call model%init_par (5, var_str ("mmu"), 0.105658389_default)
call model%init_par (6, var_str ("mtau"), 1.77705_default)
call model%init_par (7, var_str ("ms"), 0.095_default)
call model%init_par (8, var_str ("mc"), 1.2_default)
call model%init_par (9, var_str ("mb"), 4.2_default)
call model%init_par (10, var_str ("mtop"), 173.1_default)
call model%init_par (11, var_str ("wtop"), 1.523_default)
call model%init_par (12, var_str ("wZ"), 2.443_default)
call model%init_par (13, var_str ("wW"), 2.049_default)
call model%init_par (14, var_str ("wH"), 0.004143_default)
call model%init_par (15, var_str ("ee"), 0.3079561542961_default)
call model%init_par (16, var_str ("cw"), 8.819013863636E-01_default)
call model%init_par (17, var_str ("sw"), 4.714339240339E-01_default)
i = 0
i = i + 1
field => model%get_field_ptr_by_index (i)
call field%init (var_str ("D_QUARK"), 1)
call field%set (spin_type=2, color_type=3, charge_type=-2, isospin_type=-2)
call field%set (name = [var_str ("d")], anti = [var_str ("dbar")])
i = i + 1
field => model%get_field_ptr_by_index (i)
call field%init (var_str ("U_QUARK"), 2)
call field%set (spin_type=2, color_type=3, charge_type=3, isospin_type=2)
call field%set (name = [var_str ("u")], anti = [var_str ("ubar")])
i = i + 1
field => model%get_field_ptr_by_index (i)
call field%init (var_str ("S_QUARK"), 3)
call field%set (spin_type=2, color_type=3, charge_type=-2, isospin_type=-2)
call field%set (mass_data=model%get_par_real_ptr (7))
call field%set (name = [var_str ("s")], anti = [var_str ("sbar")])
i = i + 1
field => model%get_field_ptr_by_index (i)
call field%init (var_str ("C_QUARK"), 4)
call field%set (spin_type=2, color_type=3, charge_type=3, isospin_type=2)
call field%set (mass_data=model%get_par_real_ptr (8))
call field%set (name = [var_str ("c")], anti = [var_str ("cbar")])
i = i + 1
field => model%get_field_ptr_by_index (i)
call field%init (var_str ("B_QUARK"), 5)
call field%set (spin_type=2, color_type=3, charge_type=-2, isospin_type=-2)
call field%set (mass_data=model%get_par_real_ptr (9))
call field%set (name = [var_str ("b")], anti = [var_str ("bbar")])
i = i + 1
field => model%get_field_ptr_by_index (i)
call field%init (var_str ("T_QUARK"), 6)
call field%set (spin_type=2, color_type=3, charge_type=3, isospin_type=2)
call field%set (mass_data=model%get_par_real_ptr (10))
call field%set (width_data=model%get_par_real_ptr (11))
call field%set (name = [var_str ("t")], anti = [var_str ("tbar")])
i = i + 1
field => model%get_field_ptr_by_index (i)
call field%init (var_str ("E_LEPTON"), 11)
call field%set (spin_type=2)
call field%set (mass_data=model%get_par_real_ptr (4))
call field%set (name = [var_str ("e-")], anti = [var_str ("e+")])
i = i + 1
field => model%get_field_ptr_by_index (i)
call field%init (var_str ("E_NEUTRINO"), 12)
call field%set (spin_type=2, is_left_handed=.true.)
call field%set (name = [var_str ("nue")], anti = [var_str ("nuebar")])
i = i + 1
field => model%get_field_ptr_by_index (i)
call field%init (var_str ("MU_LEPTON"), 13)
call field%set (spin_type=2)
call field%set (mass_data=model%get_par_real_ptr (5))
call field%set (name = [var_str ("mu-")], anti = [var_str ("mu+")])
i = i + 1
field => model%get_field_ptr_by_index (i)
call field%init (var_str ("MU_NEUTRINO"), 14)
call field%set (spin_type=2, is_left_handed=.true.)
call field%set (name = [var_str ("numu")], anti = [var_str ("numubar")])
i = i + 1
field => model%get_field_ptr_by_index (i)
call field%init (var_str ("TAU_LEPTON"), 15)
call field%set (spin_type=2)
call field%set (mass_data=model%get_par_real_ptr (6))
call field%set (name = [var_str ("tau-")], anti = [var_str ("tau+")])
i = i + 1
field => model%get_field_ptr_by_index (i)
call field%init (var_str ("TAU_NEUTRINO"), 16)
call field%set (spin_type=2, is_left_handed=.true.)
call field%set (name = [var_str ("nutau")], anti = [var_str ("nutaubar")])
i = i + 1
field => model%get_field_ptr_by_index (i)
call field%init (var_str ("GLUON"), 21)
call field%set (spin_type=3, color_type=8)
call field%set (name = [var_str ("gl")])
i = i + 1
field => model%get_field_ptr_by_index (i)
call field%init (var_str ("PHOTON"), 22)
call field%set (spin_type=3)
call field%set (name = [var_str ("A")])
i = i + 1
field => model%get_field_ptr_by_index (i)
call field%init (var_str ("Z_BOSON"), 23)
call field%set (spin_type=3)
call field%set (mass_data=model%get_par_real_ptr (1))
call field%set (width_data=model%get_par_real_ptr (12))
call field%set (name = [var_str ("Z")])
i = i + 1
field => model%get_field_ptr_by_index (i)
call field%init (var_str ("W_BOSON"), 24)
call field%set (spin_type=3)
call field%set (mass_data=model%get_par_real_ptr (2))
call field%set (width_data=model%get_par_real_ptr (13))
call field%set (name = [var_str ("W+")], anti = [var_str ("W-")])
i = i + 1
field => model%get_field_ptr_by_index (i)
call field%init (var_str ("HIGGS"), 25)
call field%set (spin_type=1)
call field%set (mass_data=model%get_par_real_ptr (3))
call field%set (width_data=model%get_par_real_ptr (14))
call field%set (name = [var_str ("H")])
i = i + 1
field => model%get_field_ptr_by_index (i)
call field%init (var_str ("PROTON"), 2212)
call field%set (spin_type=2)
call field%set (name = [var_str ("p")], anti = [var_str ("pbar")])
! call field%set (mass_data=model%get_par_real_ptr (12))
i = i + 1
field => model%get_field_ptr_by_index (i)
call field%init (var_str ("HADRON_REMNANT_SINGLET"), 91)
call field%set (color_type=1)
call field%set (name = [var_str ("hr1")])
i = i + 1
field => model%get_field_ptr_by_index (i)
call field%init (var_str ("HADRON_REMNANT_TRIPLET"), 92)
call field%set (color_type=3)
call field%set (name = [var_str ("hr3")], anti = [var_str ("hr3bar")])
i = i + 1
field => model%get_field_ptr_by_index (i)
call field%init (var_str ("HADRON_REMNANT_OCTET"), 93)
call field%set (color_type=8)
call field%set (name = [var_str ("hr8")])
call model%freeze_fields ()
i = 0
i = i + 1
!!! QED
call model%set_vertex (i, [var_str ("dbar"), var_str ("d"), var_str ("A")])
i = i + 1
call model%set_vertex (i, [var_str ("ubar"), var_str ("u"), var_str ("A")])
i = i + 1
call model%set_vertex (i, [var_str ("sbar"), var_str ("s"), var_str ("A")])
i = i + 1
call model%set_vertex (i, [var_str ("cbar"), var_str ("c"), var_str ("A")])
i = i + 1
call model%set_vertex (i, [var_str ("bbar"), var_str ("b"), var_str ("A")])
i = i + 1
call model%set_vertex (i, [var_str ("tbar"), var_str ("t"), var_str ("A")])
i = i + 1
!!!
call model%set_vertex (i, [var_str ("e+"), var_str ("e-"), var_str ("A")])
i = i + 1
call model%set_vertex (i, [var_str ("mu+"), var_str ("mu-"), var_str ("A")])
i = i + 1
call model%set_vertex (i, [var_str ("tau+"), var_str ("tau-"), var_str ("A")])
i = i + 1
!!! QCD
call model%set_vertex (i, [var_str ("gl"), var_str ("gl"), var_str ("gl")])
i = i + 1
call model%set_vertex (i, [var_str ("gl"), var_str ("gl"), &
var_str ("gl"), var_str ("gl")])
i = i + 1
!!!
call model%set_vertex (i, [var_str ("dbar"), var_str ("d"), var_str ("gl")])
i = i + 1
call model%set_vertex (i, [var_str ("ubar"), var_str ("u"), var_str ("gl")])
i = i + 1
call model%set_vertex (i, [var_str ("sbar"), var_str ("s"), var_str ("gl")])
i = i + 1
call model%set_vertex (i, [var_str ("cbar"), var_str ("c"), var_str ("gl")])
i = i + 1
call model%set_vertex (i, [var_str ("bbar"), var_str ("b"), var_str ("gl")])
i = i + 1
call model%set_vertex (i, [var_str ("tbar"), var_str ("t"), var_str ("gl")])
i = i + 1
!!! Neutral currents
call model%set_vertex (i, [var_str ("dbar"), var_str ("d"), var_str ("Z")])
i = i + 1
call model%set_vertex (i, [var_str ("ubar"), var_str ("u"), var_str ("Z")])
i = i + 1
call model%set_vertex (i, [var_str ("sbar"), var_str ("s"), var_str ("Z")])
i = i + 1
call model%set_vertex (i, [var_str ("cbar"), var_str ("c"), var_str ("Z")])
i = i + 1
call model%set_vertex (i, [var_str ("bbar"), var_str ("b"), var_str ("Z")])
i = i + 1
call model%set_vertex (i, [var_str ("tbar"), var_str ("t"), var_str ("Z")])
i = i + 1
!!!
call model%set_vertex (i, [var_str ("e+"), var_str ("e-"), var_str ("Z")])
i = i + 1
call model%set_vertex (i, [var_str ("mu+"), var_str ("muu-"), var_str ("Z")])
i = i + 1
call model%set_vertex (i, [var_str ("tau+"), var_str ("tau-"), var_str ("Z")])
i = i + 1
call model%set_vertex (i, [var_str ("nuebar"), var_str ("nue"), var_str ("Z")])
i = i + 1
call model%set_vertex (i, [var_str ("numubar"), var_str ("numu"), var_str ("Z")])
i = i + 1
call model%set_vertex (i, [var_str ("nutaubar"), var_str ("nutau"), &
var_str ("Z")])
i = i + 1
!!! Charged currents
call model%set_vertex (i, [var_str ("ubar"), var_str ("d"), var_str ("W+")])
i = i + 1
call model%set_vertex (i, [var_str ("cbar"), var_str ("s"), var_str ("W+")])
i = i + 1
call model%set_vertex (i, [var_str ("tbar"), var_str ("b"), var_str ("W+")])
i = i + 1
call model%set_vertex (i, [var_str ("dbar"), var_str ("u"), var_str ("W-")])
i = i + 1
call model%set_vertex (i, [var_str ("sbar"), var_str ("c"), var_str ("W-")])
i = i + 1
call model%set_vertex (i, [var_str ("bbar"), var_str ("t"), var_str ("W-")])
i = i + 1
!!!
call model%set_vertex (i, [var_str ("nuebar"), var_str ("e-"), var_str ("W+")])
i = i + 1
call model%set_vertex (i, [var_str ("numubar"), var_str ("mu-"), var_str ("W+")])
i = i + 1
call model%set_vertex (i, [var_str ("nutaubar"), var_str ("tau-"), var_str ("W+")])
i = i + 1
call model%set_vertex (i, [var_str ("e+"), var_str ("nue"), var_str ("W-")])
i = i + 1
call model%set_vertex (i, [var_str ("mu+"), var_str ("numu"), var_str ("W-")])
i = i + 1
call model%set_vertex (i, [var_str ("tau+"), var_str ("nutau"), var_str ("W-")])
i = i + 1
!!! Yukawa
!!! keeping only 3rd generation for the moment
! call model%set_vertex (i, [var_str ("sbar"), var_str ("s"), var_str ("H")])
! i = i + 1
! call model%set_vertex (i, [var_str ("cbar"), var_str ("c"), var_str ("H")])
! i = i + 1
call model%set_vertex (i, [var_str ("bbar"), var_str ("b"), var_str ("H")])
i = i + 1
call model%set_vertex (i, [var_str ("tbar"), var_str ("t"), var_str ("H")])
i = i + 1
! call model%set_vertex (i, [var_str ("mubar"), var_str ("mu"), var_str ("H")])
! i = i + 1
call model%set_vertex (i, [var_str ("taubar"), var_str ("tau"), var_str ("H")])
i = i + 1
!!! Vector-boson self-interactions
call model%set_vertex (i, [var_str ("W+"), var_str ("W-"), var_str ("A")])
i = i + 1
call model%set_vertex (i, [var_str ("W+"), var_str ("W-"), var_str ("Z")])
i = i + 1
!!!
call model%set_vertex (i, [var_str ("W+"), var_str ("W-"), var_str ("Z"), var_str ("Z")])
i = i + 1
call model%set_vertex (i, [var_str ("W+"), var_str ("W+"), var_str ("W-"), var_str ("W-")])
i = i + 1
call model%set_vertex (i, [var_str ("W+"), var_str ("W-"), var_str ("Z"), var_str ("A")])
i = i + 1
call model%set_vertex (i, [var_str ("W+"), var_str ("W-"), var_str ("A"), var_str ("A")])
i = i + 1
!!! Higgs - vector boson
! call model%set_vertex (i, [var_str ("H"), var_str ("Z"), var_str ("A")])
! i = i + 1
! call model%set_vertex (i, [var_str ("H"), var_str ("A"), var_str ("A")])
! i = i + 1
! call model%set_vertex (i, [var_str ("H"), var_str ("gl"), var_str ("gl")])
! i = i + 1
!!!
call model%set_vertex (i, [var_str ("H"), var_str ("W+"), var_str ("W-")])
i = i + 1
call model%set_vertex (i, [var_str ("H"), var_str ("Z"), var_str ("Z")])
i = i + 1
call model%set_vertex (i, [var_str ("H"), var_str ("H"), var_str ("W+"), var_str ("W-")])
i = i + 1
call model%set_vertex (i, [var_str ("H"), var_str ("H"), var_str ("Z"), var_str ("Z")])
i = i + 1
!!! Higgs self-interactions
call model%set_vertex (i, [var_str ("H"), var_str ("H"), var_str ("H")])
i = i + 1
call model%set_vertex (i, [var_str ("H"), var_str ("H"), var_str ("H"), var_str ("H")])
i = i + 1
call model%freeze_vertices ()
end subroutine init_sm_full_test
@ %def init_sm_full_test
@ Initialize a [[part_prop]] object by passing a [[particle_label]],
which is simply the particle name. [[part_prop]] should be part of the
[[particle]] array of [[feyngraph_set]]. We use the [[model]] of
[[feyngraph_set]] to obtain the relevant data of the particle which is
needed to find [[phase_space]] parametrizations. When a [[part_prop]]
is initialized, we add and initialize also the corresponding anti-
particle [[part_prop]] if it is not yet in the array.
<<Cascades2: part prop: TBP>>=
procedure :: init => part_prop_init
<<Cascades2: procedures>>=
recursive subroutine part_prop_init (part_prop, feyngraph_set, particle_label)
class (part_prop_t), intent (out), target :: part_prop
type (feyngraph_set_t), intent (inout) :: feyngraph_set
character (len=*), intent (in) :: particle_label
type (flavor_t) :: flv, anti
type (string_t) :: name
integer :: i
name = particle_label
call flv%init (name, feyngraph_set%model)
part_prop%particle_label = particle_label
part_prop%pdg = flv%get_pdg ()
part_prop%mass = flv%get_mass ()
part_prop%width = flv%get_width()
part_prop%spin_type = flv%get_spin_type ()
part_prop%is_vector = flv%get_spin_type () == VECTOR
part_prop%empty = .false.
part_prop%tex_name = flv%get_tex_name ()
anti = flv%anti ()
if (flv%get_pdg() == anti%get_pdg()) then
select type (part_prop)
type is (part_prop_t)
part_prop%anti => part_prop
end select
else
do i=1, size (feyngraph_set%particle)
if (feyngraph_set%particle(i)%pdg == (- part_prop%pdg)) then
part_prop%anti => feyngraph_set%particle(i)
exit
else if (feyngraph_set%particle(i)%empty) then
part_prop%anti => feyngraph_set%particle(i)
call feyngraph_set%particle(i)%init (feyngraph_set, char(anti%get_name()))
exit
end if
enddo
end if
end subroutine part_prop_init
@ %def part_prop_init
@ This subroutine assigns to a node the particle properties. Since these
properties do not change and are simply read from the model file, we
use pointers to the elements of the [[particle]] array of the
[[feyngraph_set]]. If there is no corresponding array element, we
have to initialize the first empty element of the array.
<<Cascades2: parameters>>=
integer, parameter :: PRT_ARRAY_SIZE = 200
<<Cascades2: f node: TBP>>=
procedure :: assign_particle_properties => f_node_assign_particle_properties
<<Cascades2: procedures>>=
subroutine f_node_assign_particle_properties (node, feyngraph_set)
class (f_node_t), intent (inout ) :: node
type (feyngraph_set_t), intent (inout) :: feyngraph_set
character (len=LABEL_LEN) :: particle_label
integer :: i
particle_label = node%particle_label(1:index (node%particle_label, '[')-1)
if (.not. associated (feyngraph_set%particle)) then
allocate (feyngraph_set%particle (PRT_ARRAY_SIZE))
end if
do i = 1, size (feyngraph_set%particle)
if (particle_label == feyngraph_set%particle(i)%particle_label) then
node%particle => feyngraph_set%particle(i)
exit
else if (feyngraph_set%particle(i)%empty) then
call feyngraph_set%particle(i)%init (feyngraph_set, particle_label)
node%particle => feyngraph_set%particle(i)
exit
end if
enddo
!!! Since the O'Mega output uses the anti-particles instead of the particles specified
!!! in the process definition, we revert this here. An exception is the first particle
!!! in the parsable DAG output
node%particle => node%particle%anti
end subroutine f_node_assign_particle_properties
@ %def f_node_assign_particle_properties
@ From the output of a Feynman diagram (in the non-factorized output)
we need to find out how many daughter nodes would be required to
reconstruct it correctly, to make sure that we keep
only those [[feyngraphs]] which are constructed solely on the basis of
the 3-vertices which are provided by the model. The number of daughter
particles can easily be determined from the syntax of O'Mega's output:
The particle which appears before the colon ':' is the mother particle.
The particles or subtrees (i.e. whole parentheses) follow after the
colon and are separated by commas.
<<Cascades2: procedures>>=
function get_n_daughters (subtree_string, pos_first_colon) &
result (n_daughters)
character (len=*), intent (in) :: subtree_string
integer, intent (in) :: pos_first_colon
integer :: n_daughters
integer :: n_open_par
integer :: i
n_open_par = 1
n_daughters = 0
if (len_trim(subtree_string) > 0) then
if (pos_first_colon > 0) then
do i=pos_first_colon, len_trim(subtree_string)
if (subtree_string(i:i) == ',') then
if (n_open_par == 1) n_daughters = n_daughters + 1
else if (subtree_string(i:i) == '(') then
n_open_par = n_open_par + 1
else if (subtree_string(i:i) == ')') then
n_open_par = n_open_par - 1
end if
end do
if (n_open_par == 0) then
n_daughters = n_daughters + 1
end if
end if
end if
end function get_n_daughters
@ %def get_n_daughters
@
\subsection{Reconstruction of trees}
The reconstruction of a tree or subtree with the non-factorized input can
be done recursively, i.e. we first find the root of the tree in the
string and create an [[f_node]]. Then we look for daughters, which in the
string appear either as single particles or subtrees (which are of the
same form as the tree which we want to reconstruct. Therefore the
subroutine can simply be called again and again until there are no more
daughter nodes to create. When we meet a vertex which requires more than
two daughter particles, we stop the recursion and disable the node using
its [[keep]] variable. Whenever a daughter node is not kept, we do not
keep the mother node as well.
<<Cascades2: procedures>>=
recursive subroutine node_construct_subtree_rec (feyngraph_set, &
feyngraph, subtree_string, mother_node)
type (feyngraph_set_t), intent (inout) :: feyngraph_set
type (feyngraph_t), intent (inout) :: feyngraph
character (len=*), intent (in) :: subtree_string
type (f_node_t), pointer, intent (inout) :: mother_node
integer :: n_daughters
integer :: pos_first_colon
integer :: current_daughter
integer :: pos_subtree_begin, pos_subtree_end
integer :: i
integer :: n_open_par
if (.not. associated (mother_node)) then
call feyngraph_set%f_node_list%add_entry (subtree_string, mother_node, .true.)
current_daughter = 1
n_open_par = 1
pos_first_colon = index (subtree_string, ':')
n_daughters = get_n_daughters (subtree_string, pos_first_colon)
if (pos_first_colon == 0) then
mother_node%particle_label = subtree_string
else
mother_node%particle_label = subtree_string(2:pos_first_colon-1)
end if
if (.not. associated (mother_node%particle)) then
call mother_node%assign_particle_properties (feyngraph_set)
end if
if (n_daughters /= 2 .and. n_daughters /= 0) then
mother_node%keep = .false.
feyngraph%keep = .false.
return
end if
pos_subtree_begin = pos_first_colon + 1
do i = pos_first_colon + 1, len(trim(subtree_string))
if (current_daughter == 2) then
pos_subtree_end = len(trim(subtree_string)) - 1
call node_construct_subtree_rec (feyngraph_set, feyngraph, &
subtree_string(pos_subtree_begin:pos_subtree_end), &
mother_node%daughter2)
exit
else if (subtree_string(i:i) == ',') then
if (n_open_par == 1) then
pos_subtree_end = i - 1
call node_construct_subtree_rec (feyngraph_set, feyngraph, &
subtree_string(pos_subtree_begin:pos_subtree_end), &
mother_node%daughter1)
current_daughter = 2
pos_subtree_begin = i + 1
end if
else if (subtree_string(i:i) == '(') then
n_open_par = n_open_par + 1
else if (subtree_string(i:i) == ')') then
n_open_par = n_open_par - 1
end if
end do
end if
if (associated (mother_node%daughter1)) then
if (.not. mother_node%daughter1%keep) then
mother_node%keep = .false.
end if
end if
if (associated (mother_node%daughter2)) then
if (.not. mother_node%daughter2%keep) then
mother_node%keep = .false.
end if
end if
if (associated (mother_node%daughter1) .and. &
associated (mother_node%daughter2)) then
mother_node%n_subtree_nodes = &
mother_node%daughter1%n_subtree_nodes &
+ mother_node%daughter2%n_subtree_nodes + 1
end if
if (.not. mother_node%keep) then
feyngraph%keep = .false.
end if
end subroutine node_construct_subtree_rec
@ %def node_construct_subtree_rec
@ When the non-factorized version of the O'Mega output is used, the
[[feyngraph]] is reconstructed from the contents of its [[string_t]]
variable [[omega_feyngraph_output]]. This can be used for the recursive
reconstruction of the tree of [[k_nodes]] with
[[node_construct_subtree_rec]].
<<Cascades2: procedures>>=
subroutine feyngraph_construct (feyngraph_set, feyngraph)
type (feyngraph_set_t), intent (inout) :: feyngraph_set
type (feyngraph_t), pointer, intent (inout) :: feyngraph
call node_construct_subtree_rec (feyngraph_set, feyngraph, &
char(feyngraph%omega_feyngraph_output), feyngraph%root)
feyngraph%n_nodes = feyngraph%root%n_subtree_nodes
end subroutine feyngraph_construct
@ %def feyngraph_construct
@ We introduce another node type, which is called [[dag_node_t]] and
is used to reproduce the dag structure which is represented by the input.
The [[dag_nodes]] can have several combinations of daughters 1 and 2.
The [[dag]] type contains an array of [[dag_nodes]] and is only used
for the reconstruction of [[feyngraphs]] which are factorized as well, but
in the other direction as the original output. This means in particular
that the outgoing particles in the output file (which there can appear
many times) exist only once as [[f_nodes]]. To represent combinations of
daughters and alternatives (options), we further use the types
[[dag_options_t]] and [[dag_combination_t]]. The [[dag_nodes]],
[[dag_options]] and [[dag_combinations]] correspond to a substring of
the string which has been read from file (and transformed into an object
of type [[dag_string_t]], which is simply another compact representation
of this string), or a modified version of this substring. The aim is to
create only one object for a given substring, even if it appears several
times in the original string and then create trees of [[f_nodes]], which
build up the [[feyngraph]], such that as many [[f_nodes]] as possible can be reused.
An outgoing particle (always interpreting the input as a decay) is
called a [[leaf]] in the context of a [[dag]].
<<Cascades2: types>>=
type :: dag_node_t
integer :: string_len
type (dag_string_t) :: string
logical :: leaf = .false.
type (f_node_ptr_t), dimension (:), allocatable :: f_node
integer :: subtree_size = 0
contains
<<Cascades2: dag node: TBP>>
end type dag_node_t
@ %def dag_node_t
<<Cascades2: dag node: TBP>>=
procedure :: final => dag_node_final
<<Cascades2: procedures>>=
subroutine dag_node_final (dag_node)
class (dag_node_t), intent (inout) :: dag_node
integer :: i
call dag_node%string%final ()
if (allocated (dag_node%f_node)) then
do i=1, size (dag_node%f_node)
if (associated (dag_node%f_node(i)%node)) then
call dag_node%f_node(i)%node%final ()
deallocate (dag_node%f_node(i)%node)
end if
enddo
deallocate (dag_node%f_node)
end if
end subroutine dag_node_final
@ %def dag_node_final
@ Whenever there are more than one possible subtrees (represented by
a [[dag_node]]) or combinations of subtrees to daughters (represented
by [[dag_combination_t]]), we use the type [[dag_options_t]]. In the
syntax of the factorized output, options are listed within curly
braces, separated by horizontal bars.
<<Cascades2: types>>=
type :: dag_options_t
integer :: string_len
type (dag_string_t) :: string
type (f_node_ptr_t), dimension (:), allocatable :: f_node_ptr1
type (f_node_ptr_t), dimension (:), allocatable :: f_node_ptr2
contains
<<Cascades2: dag options: TBP>>
end type dag_options_t
@ %def dag_node_options_t
<<Cascades2: dag options: TBP>>=
procedure :: final => dag_options_final
<<Cascades2: procedures>>=
subroutine dag_options_final (dag_options)
class (dag_options_t), intent (inout) :: dag_options
integer :: i
call dag_options%string%final ()
if (allocated (dag_options%f_node_ptr1)) then
do i=1, size (dag_options%f_node_ptr1)
dag_options%f_node_ptr1(i)%node => null ()
enddo
deallocate (dag_options%f_node_ptr1)
end if
if (allocated (dag_options%f_node_ptr2)) then
do i=1, size (dag_options%f_node_ptr2)
dag_options%f_node_ptr2(i)%node => null ()
enddo
deallocate (dag_options%f_node_ptr2)
end if
end subroutine dag_options_final
@ %def dag_options_final
@ A pair of two daughters (which can be [[dag_nodes]] or [[dag_options]])
is represented by the type [[dag_combination_t]]. In the original string,
a [[dag_combination]] appears between parentheses, which contain a comma,
but not a colon. If we find a colon between these parentheses, it is a
a [[dag_node]] instead.
<<Cascades2: types>>=
type :: dag_combination_t
integer :: string_len
type (dag_string_t) :: string
integer, dimension (2) :: combination
type (f_node_ptr_t), dimension (:), allocatable :: f_node_ptr1
type (f_node_ptr_t), dimension (:), allocatable :: f_node_ptr2
contains
<<Cascades2: dag combination: TBP>>
end type dag_combination_t
@ %def dag_combination_t
<<Cascades2: dag combination: TBP>>=
procedure :: final => dag_combination_final
<<Cascades2: procedures>>=
subroutine dag_combination_final (dag_combination)
class (dag_combination_t), intent (inout) :: dag_combination
integer :: i
call dag_combination%string%final ()
if (allocated (dag_combination%f_node_ptr1)) then
do i=1, size (dag_combination%f_node_ptr1)
dag_combination%f_node_ptr1(i)%node => null ()
enddo
deallocate (dag_combination%f_node_ptr1)
end if
if (allocated (dag_combination%f_node_ptr2)) then
do i=1, size (dag_combination%f_node_ptr2)
dag_combination%f_node_ptr2(i)%node => null ()
enddo
deallocate (dag_combination%f_node_ptr2)
end if
end subroutine dag_combination_final
@ %def dag_combination_final
@ Here is the type representing the DAG, i.e. it holds arrays of the
[[dag_nodes]], [[dag_options]] and [[dag_combinations]]. The root node
of the [[dag]] is the last filled element of the [[node]] array.
<<Cascades2: types>>=
type :: dag_t
type (dag_string_t) :: string
type (dag_node_t), dimension (:), allocatable :: node
type (dag_options_t), dimension (:), allocatable :: options
type (dag_combination_t), dimension (:), allocatable :: combination
integer :: n_nodes = 0
integer :: n_options = 0
integer :: n_combinations = 0
contains
<<Cascades2: dag: TBP>>
end type dag_t
@ %def dag_t
<<Cascades2: dag: TBP>>=
procedure :: final => dag_final
<<Cascades2: procedures>>=
subroutine dag_final (dag)
class (dag_t), intent (inout) :: dag
integer :: i
call dag%string%final ()
if (allocated (dag%node)) then
do i=1, size (dag%node)
call dag%node(i)%final ()
enddo
deallocate (dag%node)
end if
if (allocated (dag%options)) then
do i=1, size (dag%options)
call dag%options(i)%final ()
enddo
deallocate (dag%options)
end if
if (allocated (dag%combination)) then
do i=1, size (dag%combination)
call dag%combination(i)%final ()
enddo
deallocate (dag%combination)
end if
end subroutine dag_final
@ %def dag_final
@ We construct the DAG from the given [[dag_string]] which is modified
several times so that in the end the remaining string corresponds to a
simple [[dag_node]], the root of the factorized tree. This means that
we first identify the leaves, i.e. outgoing particles. Then we identify
[[dag_nodes]], [[dag_combinations]] and [[options]] until the number of
these objects does not change any more. Identifying means that we add
a corresponding object to the array (if not yet present), which can be identified
with the corresponding substring, and replace the substring in the
original [[dag_string]] by a [[dag_token]] of the corresponding type
(in the char output of this token, this corresponds to a place holder
like e.g. '<O23>' which in this particular case corresponds to an option
and can be found at the position 23 in the array). The character output
of the substrings turns out to be very useful for debugging.
<<Cascades2: dag: TBP>>=
procedure :: construct => dag_construct
<<Cascades2: procedures>>=
subroutine dag_construct (dag, feyngraph_set)
class (dag_t), intent (inout) :: dag
type (feyngraph_set_t), intent (inout) :: feyngraph_set
integer :: n_nodes
integer :: n_options
integer :: n_combinations
logical :: continue_loop
integer :: subtree_size
integer :: i,j
subtree_size = 1
call dag%get_nodes_and_combinations (leaves = .true.)
do i=1, dag%n_nodes
call dag%node(i)%make_f_nodes (feyngraph_set, dag)
enddo
continue_loop = .true.
subtree_size = subtree_size + 2
do while (continue_loop)
n_nodes = dag%n_nodes
n_options = dag%n_options
n_combinations = dag%n_combinations
call dag%get_nodes_and_combinations (leaves = .false.)
if (n_nodes /= dag%n_nodes) then
dag%node(n_nodes+1:dag%n_nodes)%subtree_size = subtree_size
do i = n_nodes+1, dag%n_nodes
call dag%node(i)%make_f_nodes (feyngraph_set, dag)
enddo
subtree_size = subtree_size + 2
end if
if (n_combinations /= dag%n_combinations) then
!$OMP PARALLEL DO
do i = n_combinations+1, dag%n_combinations
call dag%combination(i)%make_f_nodes (feyngraph_set, dag)
enddo
!$OMP END PARALLEL DO
end if
call dag%get_options ()
if (n_options /= dag%n_options) then
!$OMP PARALLEL DO
do i = n_options+1, dag%n_options
call dag%options(i)%make_f_nodes (feyngraph_set, dag)
enddo
!$OMP END PARALLEL DO
end if
if (n_nodes == dag%n_nodes .and. n_options == dag%n_options &
.and. n_combinations == dag%n_combinations) then
continue_loop = .false.
end if
enddo
!!! add root node to dag
call dag%add_node (dag%string%t, leaf = .false.)
dag%node(dag%n_nodes)%subtree_size = subtree_size
call dag%node(dag%n_nodes)%make_f_nodes (feyngraph_set, dag)
if (debug2_active (D_PHASESPACE)) then
call dag%write (output_unit)
end if
!!! set indices for all f_nodes
do i=1, dag%n_nodes
if (allocated (dag%node(i)%f_node)) then
do j=1, size (dag%node(i)%f_node)
if (associated (dag%node(i)%f_node(j)%node)) &
call dag%node(i)%f_node(j)%node%set_index ()
enddo
end if
enddo
end subroutine dag_construct
@ %def dag_construct
@ Identify [[dag_nodes]] and [[dag_combinations]]. Leaves are simply
nodes (i.e. of type [[NODE_TK]]) where only one bit in the bincode is
set. The [[dag_nodes]] and [[dag_combinations]] have in common that they
are surrounded by parentheses. There is however a way to distinguish
between them because the corresponding substring contains a colon (or
[[dag_token]] with type [[COLON_TK]]) if it is a [[dag_node]]. Otherwise
it is a [[dag_combination]]. The string of the [[dag_node]] or
[[dag_combination]] should not contain curly braces, because these
correspond to [[dag_options]] and should be identified before.
<<Cascades2: dag: TBP>>=
procedure :: get_nodes_and_combinations => dag_get_nodes_and_combinations
<<Cascades2: procedures>>=
subroutine dag_get_nodes_and_combinations (dag, leaves)
class (dag_t), intent (inout) :: dag
logical, intent (in) :: leaves
type (dag_string_t) :: new_string
integer :: i, j, k
integer :: i_node
integer :: new_size
integer :: first_colon
logical :: combination
!!! Create nodes also for external particles, except for the incoming one which
!!! appears as the root of the tree. These can easily be identified by their
!!! bincodes, since they should contain only one bit which is set.
if (leaves) then
first_colon = minloc (dag%string%t%type, 1, dag%string%t%type == COLON_TK)
do i = first_colon + 1, size (dag%string%t)
if (dag%string%t(i)%type == NODE_TK) then
if (popcnt(dag%string%t(i)%bincode) == 1) then
call dag%add_node (dag%string%t(i:i), .true., i_node)
call dag%string%t(i)%init_dag_object_token (DAG_NODE_TK, i_node)
end if
end if
enddo
call dag%string%update_char_len ()
else
!!! Create a node or combination for every closed pair of parentheses
!!! which do not contain any other parentheses or curly braces.
!!! A node (not outgoing) contains a colon. This is not the case
!!! for combinations, which we use as the criteria to distinguish
!!! between both.
allocate (new_string%t (size (dag%string%t)))
i = 1
new_size = 0
do while (i <= size(dag%string%t))
if (dag%string%t(i)%type == OPEN_PAR_TK) then
combination = .true.
do j = i+1, size (dag%string%t)
select case (dag%string%t(j)%type)
case (CLOSED_PAR_TK)
new_size = new_size + 1
if (combination) then
call dag%add_combination (dag%string%t(i:j), i_node)
call new_string%t(new_size)%init_dag_object_token (DAG_COMBINATION_TK, i_node)
else
call dag%add_node (dag%string%t(i:j), leaves, i_node)
call new_string%t(new_size)%init_dag_object_token (DAG_NODE_TK, i_node)
end if
i = j + 1
exit
case (OPEN_PAR_TK, OPEN_CURLY_TK, CLOSED_CURLY_TK)
new_size = new_size + 1
new_string%t(new_size) = dag%string%t(i)
i = i + 1
exit
case (COLON_TK)
combination = .false.
end select
enddo
else
new_size = new_size + 1
new_string%t(new_size) = dag%string%t(i)
i = i + 1
end if
enddo
dag%string = new_string%t(:new_size)
call dag%string%update_char_len ()
end if
end subroutine dag_get_nodes_and_combinations
@ %def dag_get_nodes_and_combinations
@ Identify [[dag_options]], i.e. lists of rival nodes or combinations
of nodes. These are identified by the surrounding curly braces. They
should not contain any parentheses any more, because these correspond
either to nodes or to combinations and should be identified before.
<<Cascades2: dag: TBP>>=
procedure :: get_options => dag_get_options
<<Cascades2: procedures>>=
subroutine dag_get_options (dag)
class (dag_t), intent (inout) :: dag
type (dag_string_t) :: new_string
integer :: i, j, k
integer :: new_size
integer :: i_options
character (len=10) :: index_char
integer :: index_start, index_end
!!! Create a node or combination for every closed pair of parentheses
!!! which do not contain any other parentheses or curly braces.
!!! A node (not outgoing) contains a colon. This is not the case
!!! for combinations, which we use as the criteria to distinguish
!!! between both.
allocate (new_string%t (size (dag%string%t)))
i = 1
new_size = 0
do while (i <= size(dag%string%t))
if (dag%string%t(i)%type == OPEN_CURLY_TK) then
do j = i+1, size (dag%string%t)
select case (dag%string%t(j)%type)
case (CLOSED_CURLY_TK)
new_size = new_size + 1
call dag%add_options (dag%string%t(i:j), i_options)
call new_string%t(new_size)%init_dag_object_token (DAG_OPTIONS_TK, i_options)
i = j + 1
exit
case (OPEN_PAR_TK, CLOSED_PAR_TK, OPEN_CURLY_TK)
new_size = new_size + 1
new_string%t(new_size) = dag%string%t(i)
i = i + 1
exit
end select
enddo
else
new_size = new_size + 1
new_string%t(new_size) = dag%string%t(i)
i = i + 1
end if
enddo
dag%string = new_string%t(:new_size)
call dag%string%update_char_len ()
end subroutine dag_get_options
@ %def dag_get_options
@ Add a [[dag_node]] to the list. The optional argument returns the index
of the node. The node might already exist. In this case we only return
the index.
<<Cascades2: dag: TBP>>=
procedure :: add_node => dag_add_node
<<Cascades2: parameters>>=
integer, parameter :: DAG_STACK_SIZE = 1000
<<Cascades2: procedures>>=
subroutine dag_add_node (dag, string, leaf, i_node)
class (dag_t), intent (inout) :: dag
type (dag_token_t), dimension (:), intent (in) :: string
logical, intent (in) :: leaf
integer, intent (out), optional :: i_node
type (dag_node_t), dimension (:), allocatable :: tmp_node
integer :: string_len
integer :: i
string_len = sum (string%char_len)
if (.not. allocated (dag%node)) then
allocate (dag%node (DAG_STACK_SIZE))
else if (dag%n_nodes == size (dag%node)) then
allocate (tmp_node (dag%n_nodes))
tmp_node = dag%node
deallocate (dag%node)
allocate (dag%node (dag%n_nodes+DAG_STACK_SIZE))
dag%node(:dag%n_nodes) = tmp_node
deallocate (tmp_node)
end if
do i = 1, dag%n_nodes
if (dag%node(i)%string_len == string_len) then
if (size (dag%node(i)%string%t) == size (string)) then
if (all(dag%node(i)%string%t == string)) then
if (present (i_node)) i_node = i
return
end if
end if
end if
enddo
dag%n_nodes = dag%n_nodes + 1
dag%node(dag%n_nodes)%string = string
dag%node(dag%n_nodes)%string_len = string_len
if (present (i_node)) i_node = dag%n_nodes
dag%node(dag%n_nodes)%leaf = leaf
end subroutine dag_add_node
@ %def dag_add_node
@ A similar subroutine for options.
<<Cascades2: dag: TBP>>=
procedure :: add_options => dag_add_options
<<Cascades2: procedures>>=
subroutine dag_add_options (dag, string, i_options)
class (dag_t), intent (inout) :: dag
type (dag_token_t), dimension (:), intent (in) :: string
integer, intent (out), optional :: i_options
type (dag_options_t), dimension (:), allocatable :: tmp_options
integer :: string_len
integer :: i
string_len = sum (string%char_len)
if (.not. allocated (dag%options)) then
allocate (dag%options (DAG_STACK_SIZE))
else if (dag%n_options == size (dag%options)) then
allocate (tmp_options (dag%n_options))
tmp_options = dag%options
deallocate (dag%options)
allocate (dag%options (dag%n_options+DAG_STACK_SIZE))
dag%options(:dag%n_options) = tmp_options
deallocate (tmp_options)
end if
do i = 1, dag%n_options
if (dag%options(i)%string_len == string_len) then
if (size (dag%options(i)%string%t) == size (string)) then
if (all(dag%options(i)%string%t == string)) then
if (present (i_options)) i_options = i
return
end if
end if
end if
enddo
dag%n_options = dag%n_options + 1
dag%options(dag%n_options)%string = string
dag%options(dag%n_options)%string_len = string_len
if (present (i_options)) i_options = dag%n_options
end subroutine dag_add_options
@ %def dag_add_options
@ A similar subroutine for combinations.
<<Cascades2: dag: TBP>>=
procedure :: add_combination => dag_add_combination
<<Cascades2: procedures>>=
subroutine dag_add_combination (dag, string, i_combination)
class (dag_t), intent (inout) :: dag
type (dag_token_t), dimension (:), intent (in) :: string
integer, intent (out), optional :: i_combination
type (dag_combination_t), dimension (:), allocatable :: tmp_combination
integer :: string_len
integer :: i
string_len = sum (string%char_len)
if (.not. allocated (dag%combination)) then
allocate (dag%combination (DAG_STACK_SIZE))
else if (dag%n_combinations == size (dag%combination)) then
allocate (tmp_combination (dag%n_combinations))
tmp_combination = dag%combination
deallocate (dag%combination)
allocate (dag%combination (dag%n_combinations+DAG_STACK_SIZE))
dag%combination(:dag%n_combinations) = tmp_combination
deallocate (tmp_combination)
end if
do i = 1, dag%n_combinations
if (dag%combination(i)%string_len == string_len) then
if (size (dag%combination(i)%string%t) == size (string)) then
if (all(dag%combination(i)%string%t == string)) then
i_combination = i
return
end if
end if
end if
enddo
dag%n_combinations = dag%n_combinations + 1
dag%combination(dag%n_combinations)%string = string
dag%combination(dag%n_combinations)%string_len = string_len
if (present (i_combination)) i_combination = dag%n_combinations
end subroutine dag_add_combination
@ %def dag_add_combination
@ For a given [[dag_node]] we want to create all [[f_nodes]]. If the node
is not a leaf, it contains in its string placeholders for options or
combinations. For these objects there are similar subroutines which are
needed here to obtain the sets of daughter nodes. If the [[dag_node]] is
a leaf, it corresponds to an external particle and the token contains the
particle name.
<<Cascades2: dag node: TBP>>=
procedure :: make_f_nodes => dag_node_make_f_nodes
<<Cascades2: procedures>>=
subroutine dag_node_make_f_nodes (dag_node, feyngraph_set, dag)
class (dag_node_t), intent (inout) :: dag_node
type (feyngraph_set_t), intent (inout) :: feyngraph_set
type (dag_t), intent (inout) :: dag
character (len=LABEL_LEN) :: particle_label
integer :: i, j
integer, dimension (2) :: obj
integer, dimension (2) :: i_obj
integer :: n_obj
integer :: pos
integer :: new_size, size1, size2
integer, dimension(:), allocatable :: match
if (allocated (dag_node%f_node)) return
pos = minloc (dag_node%string%t%type, 1,dag_node%string%t%type == NODE_TK)
particle_label = char (dag_node%string%t(pos))
if (dag_node%leaf) then
!!! construct subtree with procedure similar to the one for the old output
allocate (dag_node%f_node(1))
allocate (dag_node%f_node(1)%node)
dag_node%f_node(1)%node%particle_label = particle_label
call dag_node%f_node(1)%node%assign_particle_properties (feyngraph_set)
if (.not. dag_node%f_node(1)%node%keep) then
deallocate (dag_node%f_node)
return
end if
else
n_obj = 0
do i = 1, size (dag_node%string%t)
select case (dag_node%string%t(i)%type)
case (DAG_NODE_TK, DAG_OPTIONS_TK, DAG_COMBINATION_TK)
n_obj = n_obj + 1
if (n_obj > 2) return
obj(n_obj) = dag_node%string%t(i)%type
i_obj(n_obj) = dag_node%string%t(i)%index
end select
enddo
if (n_obj == 1) then
if (obj(1) == DAG_OPTIONS_TK) then
if (allocated (dag%options(i_obj(1))%f_node_ptr1)) then
size1 = size(dag%options(i_obj(1))%f_node_ptr1)
allocate (dag_node%f_node(size1))
do i=1, size1
allocate (dag_node%f_node(i)%node)
dag_node%f_node(i)%node%particle_label = particle_label
call dag_node%f_node(i)%node%assign_particle_properties (feyngraph_set)
dag_node%f_node(i)%node%daughter1 => dag%options(i_obj(1))%f_node_ptr1(i)%node
dag_node%f_node(i)%node%daughter2 => dag%options(i_obj(1))%f_node_ptr2(i)%node
dag_node%f_node(i)%node%n_subtree_nodes = &
dag%options(i_obj(1))%f_node_ptr1(i)%node%n_subtree_nodes &
+ dag%options(i_obj(1))%f_node_ptr2(i)%node%n_subtree_nodes + 1
enddo
end if
else if (obj(1) == DAG_COMBINATION_TK) then
if (allocated (dag%combination(i_obj(1))%f_node_ptr1)) then
size1 = size(dag%combination(i_obj(1))%f_node_ptr1)
allocate (dag_node%f_node(size1))
do i=1, size1
allocate (dag_node%f_node(i)%node)
dag_node%f_node(i)%node%particle_label = particle_label
call dag_node%f_node(i)%node%assign_particle_properties (feyngraph_set)
dag_node%f_node(i)%node%daughter1 => dag%combination(i_obj(1))%f_node_ptr1(i)%node
dag_node%f_node(i)%node%daughter2 => dag%combination(i_obj(1))%f_node_ptr2(i)%node
dag_node%f_node(i)%node%n_subtree_nodes = &
dag%combination(i_obj(1))%f_node_ptr1(i)%node%n_subtree_nodes &
+ dag%combination(i_obj(1))%f_node_ptr2(i)%node%n_subtree_nodes + 1
enddo
end if
end if
!!! simply set daughter pointers, daughters are already combined correctly
else if (n_obj == 2) then
size1 = 0
size2 = 0
if (obj(1) == DAG_NODE_TK) then
if (allocated (dag%node(i_obj(1))%f_node)) then
do i=1, size (dag%node(i_obj(1))%f_node)
if (dag%node(i_obj(1))%f_node(i)%node%keep) size1 = size1 + 1
enddo
end if
else if (obj(1) == DAG_OPTIONS_TK) then
if (allocated (dag%options(i_obj(1))%f_node_ptr1)) then
do i=1, size (dag%options(i_obj(1))%f_node_ptr1)
if (dag%options(i_obj(1))%f_node_ptr1(i)%node%keep) size1 = size1 + 1
enddo
end if
end if
if (obj(2) == DAG_NODE_TK) then
if (allocated (dag%node(i_obj(2))%f_node)) then
do i=1, size (dag%node(i_obj(2))%f_node)
if (dag%node(i_obj(2))%f_node(i)%node%keep) size2 = size2 + 1
enddo
end if
else if (obj(2) == DAG_OPTIONS_TK) then
if (allocated (dag%options(i_obj(2))%f_node_ptr1)) then
do i=1, size (dag%options(i_obj(2))%f_node_ptr1)
if (dag%options(i_obj(2))%f_node_ptr1(i)%node%keep) size2 = size2 + 1
enddo
end if
end if
!!! make all combinations of daughters
select case (obj(1))
case (DAG_NODE_TK)
select case (obj(2))
case (DAG_NODE_TK)
call combine_all_daughters(dag%node(i_obj(1))%f_node, &
dag%node(i_obj(2))%f_node)
case (DAG_OPTIONS_TK)
call combine_all_daughters(dag%node(i_obj(1))%f_node, &
dag%options(i_obj(2))%f_node_ptr1)
end select
case (DAG_OPTIONS_TK)
select case (obj(2))
case (DAG_NODE_TK)
call combine_all_daughters(dag%options(i_obj(1))%f_node_ptr1, &
dag%node(i_obj(2))%f_node)
case (DAG_OPTIONS_TK)
call combine_all_daughters(dag%options(i_obj(1))%f_node_ptr1, &
dag%options(i_obj(2))%f_node_ptr1)
end select
end select
end if
end if
contains
subroutine combine_all_daughters (daughter1_ptr, daughter2_ptr)
type (f_node_ptr_t), dimension (:), intent (in) :: daughter1_ptr
type (f_node_ptr_t), dimension (:), intent (in) :: daughter2_ptr
integer :: i, j
integer :: pos
new_size = size1*size2
allocate (dag_node%f_node(new_size))
pos = 0
do i = 1, size (daughter1_ptr)
if (daughter1_ptr(i)%node%keep) then
do j = 1, size (daughter2_ptr)
if (daughter2_ptr(j)%node%keep) then
pos = pos + 1
allocate (dag_node%f_node(pos)%node)
dag_node%f_node(pos)%node%particle_label = particle_label
call dag_node%f_node(pos)%node%assign_particle_properties (feyngraph_set)
dag_node%f_node(pos)%node%daughter1 => daughter1_ptr(i)%node
dag_node%f_node(pos)%node%daughter2 => daughter2_ptr(j)%node
dag_node%f_node(pos)%node%n_subtree_nodes = daughter1_ptr(i)%node%n_subtree_nodes &
+ daughter2_ptr(j)%node%n_subtree_nodes + 1
call feyngraph_set%model%match_vertex (daughter1_ptr(i)%node%particle%pdg, &
daughter2_ptr(j)%node%particle%pdg, match)
if (allocated (match)) then
if (any (abs(match) == abs(dag_node%f_node(pos)%node%particle%pdg))) then
dag_node%f_node(pos)%node%keep = .true.
else
dag_node%f_node(pos)%node%keep = .false.
end if
deallocate (match)
else
dag_node%f_node(pos)%node%keep = .false.
end if
end if
enddo
end if
enddo
end subroutine combine_all_daughters
end subroutine dag_node_make_f_nodes
@ %def dag_node_make_f_nodes
@ In [[dag_options_make_f_nodes_single]]
we obtain all [[f_nodes]] for [[dag_nodes]] which correspond to a
set of rival subtrees or nodes, which is the first possibility for
which [[dag_options]] can appear.
In [[dag_options_make_f_nodes_pair]]
the options are rival pairs ([[daughter1]], [[daughter2]]).
Therefore we have to pass two allocatable arrays of type [[f_node_ptr_t]]
to the subroutine.
<<Cascades2: dag options: TBP>>=
procedure :: make_f_nodes => dag_options_make_f_nodes
<<Cascades2: procedures>>=
subroutine dag_options_make_f_nodes (dag_options, &
feyngraph_set, dag)
class (dag_options_t), intent (inout) :: dag_options
type (feyngraph_set_t), intent (inout) :: feyngraph_set
type (dag_t), intent (inout) :: dag
integer, dimension (:), allocatable :: obj, i_obj
integer :: n_obj
integer :: i
integer :: pos
!!! read options
if (allocated (dag_options%f_node_ptr1)) return
n_obj = count ((dag_options%string%t%type == DAG_NODE_TK) .or. &
(dag_options%string%t%type == DAG_OPTIONS_TK) .or. &
(dag_options%string%t%type == DAG_COMBINATION_TK), 1)
allocate (obj(n_obj)); allocate (i_obj(n_obj))
pos = 0
do i = 1, size (dag_options%string%t)
select case (dag_options%string%t(i)%type)
case (DAG_NODE_TK, DAG_OPTIONS_TK, DAG_COMBINATION_TK)
pos = pos + 1
obj(pos) = dag_options%string%t(i)%type
i_obj(pos) = dag_options%string%t(i)%index
end select
enddo
if (any (dag_options%string%t%type == DAG_NODE_TK)) then
call dag_options_make_f_nodes_single
else if (any (dag_options%string%t%type == DAG_COMBINATION_TK)) then
call dag_options_make_f_nodes_pair
end if
deallocate (obj, i_obj)
contains
subroutine dag_options_make_f_nodes_single
integer :: i_start, i_end
integer :: n_nodes
n_nodes = 0
do i=1, n_obj
if (allocated (dag%node(i_obj(i))%f_node)) then
n_nodes = n_nodes + size (dag%node(i_obj(i))%f_node)
end if
enddo
if (n_nodes /= 0) then
allocate (dag_options%f_node_ptr1 (n_nodes))
i_end = 0
do i = 1, n_obj
if (allocated (dag%node(i_obj(i))%f_node)) then
i_start = i_end + 1
i_end = i_end + size (dag%node(i_obj(i))%f_node)
dag_options%f_node_ptr1(i_start:i_end) = dag%node(i_obj(i))%f_node
end if
enddo
end if
end subroutine dag_options_make_f_nodes_single
subroutine dag_options_make_f_nodes_pair
integer :: i_start, i_end
integer :: n_nodes
!!! get f_nodes from each combination
n_nodes = 0
do i=1, n_obj
if (allocated (dag%combination(i_obj(i))%f_node_ptr1)) then
n_nodes = n_nodes + size (dag%combination(i_obj(i))%f_node_ptr1)
end if
enddo
if (n_nodes /= 0) then
allocate (dag_options%f_node_ptr1 (n_nodes))
allocate (dag_options%f_node_ptr2 (n_nodes))
i_end = 0
do i=1, n_obj
if (allocated (dag%combination(i_obj(i))%f_node_ptr1)) then
i_start = i_end + 1
i_end = i_end + size (dag%combination(i_obj(i))%f_node_ptr1)
dag_options%f_node_ptr1(i_start:i_end) = dag%combination(i_obj(i))%f_node_ptr1
dag_options%f_node_ptr2(i_start:i_end) = dag%combination(i_obj(i))%f_node_ptr2
end if
enddo
end if
end subroutine dag_options_make_f_nodes_pair
end subroutine dag_options_make_f_nodes
@ %def dag_options_make_f_nodes
@ We create all combinations of daughter [[f_nodes]] for a combination.
In the combination each daughter can be either a single [[dag_node]] or
[[dag_options]] which are a set of single [[dag_nodes]]. Therefore, we
first create all possible [[f_nodes]] for daughter1, then all possible
[[f_nodes]] for daughter2. In the end we combine all [[daughter1]] nodes
with all [[daughter2]] nodes.
<<Cascades2: dag combination: TBP>>=
procedure :: make_f_nodes => dag_combination_make_f_nodes
<<Cascades2: procedures>>=
subroutine dag_combination_make_f_nodes (dag_combination, &
feyngraph_set, dag)
class (dag_combination_t), intent (inout) :: dag_combination
type (feyngraph_set_t), intent (inout) :: feyngraph_set
type (dag_t), intent (inout) :: dag
integer, dimension (2) :: obj, i_obj
integer :: n_obj
integer :: new_size, size1, size2
integer :: i, j, pos
if (allocated (dag_combination%f_node_ptr1)) return
n_obj = 0
do i = 1, size (dag_combination%string%t)
select case (dag_combination%string%t(i)%type)
case (DAG_NODE_TK, DAG_OPTIONS_TK, DAG_COMBINATION_TK)
n_obj = n_obj + 1
if (n_obj > 2) return
obj(n_obj) = dag_combination%string%t(i)%type
i_obj(n_obj) = dag_combination%string%t(i)%index
end select
enddo
size1 = 0
size2 = 0
if (obj(1) == DAG_NODE_TK) then
if (allocated (dag%node(i_obj(1))%f_node)) &
size1 = size (dag%node(i_obj(1))%f_node)
else if (obj(1) == DAG_OPTIONS_TK) then
if (allocated (dag%options(i_obj(1))%f_node_ptr1)) &
size1 = size (dag%options(i_obj(1))%f_node_ptr1)
end if
if (obj(2) == DAG_NODE_TK) then
if (allocated (dag%node(i_obj(2))%f_node)) &
size2 = size (dag%node(i_obj(2))%f_node)
else if (obj(2) == DAG_OPTIONS_TK) then
if (allocated (dag%options(i_obj(2))%f_node_ptr1)) &
size2 = size (dag%options(i_obj(2))%f_node_ptr1)
end if
!!! combine the 2 arrays of f_nodes
new_size = size1*size2
if (new_size /= 0) then
allocate (dag_combination%f_node_ptr1 (new_size))
allocate (dag_combination%f_node_ptr2 (new_size))
pos = 0
select case (obj(1))
case (DAG_NODE_TK)
select case (obj(2))
case (DAG_NODE_TK)
do i = 1, size1
do j = 1, size2
pos = pos + 1
dag_combination%f_node_ptr1(pos) = dag%node(i_obj(1))%f_node(i)
dag_combination%f_node_ptr2(pos) = dag%node(i_obj(2))%f_node(j)
enddo
enddo
case (DAG_OPTIONS_TK)
do i = 1, size1
do j = 1, size2
pos = pos + 1
dag_combination%f_node_ptr1(pos) = dag%node(i_obj(1))%f_node(i)
dag_combination%f_node_ptr2(pos) = dag%options(i_obj(2))%f_node_ptr1(j)
enddo
enddo
end select
case (DAG_OPTIONS_TK)
select case (obj(2))
case (DAG_NODE_TK)
do i = 1, size1
do j = 1, size2
pos = pos + 1
dag_combination%f_node_ptr1(pos) = dag%options(i_obj(1))%f_node_ptr1(i)
dag_combination%f_node_ptr2(pos) = dag%node(i_obj(2))%f_node(j)
enddo
enddo
case (DAG_OPTIONS_TK)
do i = 1, size1
do j = 1, size2
pos = pos + 1
dag_combination%f_node_ptr1(pos) = dag%options(i_obj(1))%f_node_ptr1(i)
dag_combination%f_node_ptr2(pos) = dag%options(i_obj(2))%f_node_ptr1(j)
enddo
enddo
end select
end select
end if
end subroutine dag_combination_make_f_nodes
@ %def dag_combination_make_f_nodes
@ Here we create the [[feyngraphs]]. After the construction of the
[[dag]] the remaining [[dag_string]] should contain a token for a
single [[dag_node]] which corresponds to the roots of the
[[feyngraphs]]. Therefore we make all [[f_nodes]] for this [[dag_node]]
and create a [[feyngraph]] for each [[f_node]]. Note that only
3-vertices are accepted. All other vertices are rejected. The
starting point is the last dag node which has been added to the list,
since this corresponds to the root of the tree.
Is is important to understand that the structure of feyngraphs is not
the same as the structure of the dag which is read from file, because
for the calculations which are performed in this module we want to
reuse the nodes for the outgoing particles, which means that they
appear only once. In O'Mega's output, it is the first incoming particle
which appears only once and the outgoing particles appear many times. This
transition is incorporated in the subroutines which create [[f_nodes]]
from the different dag objects.
<<Cascades2: dag: TBP>>=
procedure :: make_feyngraphs => dag_make_feyngraphs
<<Cascades2: procedures>>=
subroutine dag_make_feyngraphs (dag, feyngraph_set)
class (dag_t), intent (inout) :: dag
type (feyngraph_set_t), intent (inout) :: feyngraph_set
integer :: i
integer :: max_subtree_size
max_subtree_size = dag%node(dag%n_nodes)%subtree_size
if (allocated (dag%node(dag%n_nodes)%f_node)) then
do i = 1, size (dag%node(dag%n_nodes)%f_node)
if (.not. associated (feyngraph_set%first)) then
allocate (feyngraph_set%last)
feyngraph_set%first => feyngraph_set%last
else
allocate (feyngraph_set%last%next)
feyngraph_set%last => feyngraph_set%last%next
end if
feyngraph_set%last%root => dag%node(dag%n_nodes)%f_node(i)%node
!!! The first particle was correct in the O'Mega parsable DAG output. It was however
!!! changed to its anti-particle in f_node_assign_particle_properties, which we revert here.
feyngraph_set%last%root%particle => feyngraph_set%last%root%particle%anti
feyngraph_set%last%n_nodes = feyngraph_set%last%root%n_subtree_nodes
feyngraph_set%n_graphs = feyngraph_set%n_graphs + 1
enddo
feyngraph_set%f_node_list%max_tree_size = feyngraph_set%first%n_nodes
end if
end subroutine dag_make_feyngraphs
@ %def dag_make_feyngraphs
@ A write procedure of the [[dag]] for debugging.
<<Cascades2: dag: TBP>>=
procedure :: write => dag_write
<<Cascades2: procedures>>=
subroutine dag_write (dag, u)
class (dag_t), intent (in) :: dag
integer, intent(in) :: u
integer :: i
write (u,fmt='(A)') 'nodes'
do i=1, dag%n_nodes
write (u,fmt='(I5,3X,A)') i, char (dag%node(i)%string)
enddo
write (u,fmt='(A)') 'options'
do i=1, dag%n_options
write (u,fmt='(I5,3X,A)') i, char (dag%options(i)%string)
enddo
write (u,fmt='(A)') 'combination'
do i=1, dag%n_combinations
write (u,fmt='(I5,3X,A)') i, char (dag%combination(i)%string)
enddo
end subroutine dag_write
@ %def dag_write
@ Make a copy of a resonant [[k_node]], where the copy is kept
nonresonant.
<<Cascades2: procedures>>=
subroutine k_node_make_nonresonant_copy (k_node)
type (k_node_t), intent (in) :: k_node
type (k_node_t), pointer :: copy
call k_node%f_node%k_node_list%add_entry (copy, recycle=.true.)
copy%daughter1 => k_node%daughter1
copy%daughter2 => k_node%daughter2
copy = k_node
copy%mapping = NONRESONANT
copy%resonant = .false.
copy%on_shell = .false.
copy%mapping_assigned = .true.
copy%is_nonresonant_copy = .true.
end subroutine k_node_make_nonresonant_copy
@ %def k_node_make_nonresonant_copy
@ For a given [[feyngraph]] we create all possible [[kingraphs]]. Here
we use existing [[k_nodes]] which have already been created when the
mapping calculations of the pure s-channel subgraphs are performed. The
nodes for the incoming particles or the nodes on the t-line will have
to be created in all cases because they are not used in several graphs.
To obtain the existing [[k_nodes]], we use the subroutine
[[k_node_init_from_f_node]] which itself uses [[f_node_list_get_nodes]]
to obtain all active [[k_nodes]] in the [[k_node_list]] of the [[f_node]].
The created [[kingraphs]] are attached to the linked list
of the [[feyngraph]]. For scattering processes we have to split up the
t-line, because since all graphs are represented as a decay, different
nodes can share daughter nodes. This happens also for the t-line or
the incoming particle which appears as an outgoing particle. For the
[[t_line]] or [[incoming]] nodes we do not want to recycle nodes but
rather create a copy of this line for each [[kingraph]].
<<Cascades2: feyngraph: TBP>>=
procedure :: make_kingraphs => feyngraph_make_kingraphs
<<Cascades2: procedures>>=
subroutine feyngraph_make_kingraphs (feyngraph, feyngraph_set)
class (feyngraph_t), intent (inout) :: feyngraph
type (feyngraph_set_t), intent (in) :: feyngraph_set
type (k_node_ptr_t), dimension (:), allocatable :: kingraph_root
integer :: i
if (.not. associated (feyngraph%kin_first)) then
call k_node_init_from_f_node (feyngraph%root, &
kingraph_root, feyngraph_set)
if (.not. feyngraph%root%keep) return
if (feyngraph_set%process_type == SCATTERING) then
call split_up_t_lines (kingraph_root)
end if
do i=1, size (kingraph_root)
if (associated (feyngraph%kin_last)) then
allocate (feyngraph%kin_last%next)
feyngraph%kin_last => feyngraph%kin_last%next
else
allocate (feyngraph%kin_last)
feyngraph%kin_first => feyngraph%kin_last
end if
feyngraph%kin_last%root => kingraph_root(i)%node
feyngraph%kin_last%n_nodes = feyngraph%n_nodes
feyngraph%kin_last%keep = feyngraph%keep
if (feyngraph_set%process_type == SCATTERING) then
feyngraph%kin_last%root%bincode = &
f_node_get_external_bincode (feyngraph_set, feyngraph%root)
end if
enddo
deallocate (kingraph_root)
end if
end subroutine feyngraph_make_kingraphs
@ %def feyngraph_make_kingraphs
@ Create all [[k_nodes]] for a given [[f_node]]. We return these nodes
using [[k_node_ptr]]. If the node is external, we assign also the bincode
to the [[k_nodes]] because this is determined from substrings of the
input file which belong to the [[feyngraphs]] and [[f_nodes]].
<<Cascades2: procedures>>=
recursive subroutine k_node_init_from_f_node (f_node, k_node_ptr, feyngraph_set)
type (f_node_t), target, intent (inout) :: f_node
type (k_node_ptr_t), allocatable, dimension (:), intent (out) :: k_node_ptr
type (feyngraph_set_t), intent (in) :: feyngraph_set
type (k_node_ptr_t), allocatable, dimension(:) :: daughter_ptr1, daughter_ptr2
integer :: n_nodes
integer :: i, j
integer :: pos
integer, save :: counter = 0
if (.not. (f_node%incoming .or. f_node%t_line)) then
call f_node%k_node_list%get_nodes (k_node_ptr)
if (.not. allocated (k_node_ptr) .and. f_node%k_node_list%n_entries > 0) then
f_node%keep = .false.
return
end if
end if
if (.not. allocated (k_node_ptr)) then
if (associated (f_node%daughter1) .and. associated (f_node%daughter2)) then
call k_node_init_from_f_node (f_node%daughter1, daughter_ptr1, &
feyngraph_set)
call k_node_init_from_f_node (f_node%daughter2, daughter_ptr2, &
feyngraph_set)
if (.not. (f_node%daughter1%keep .and. f_node%daughter2%keep)) then
f_node%keep = .false.
return
end if
n_nodes = size (daughter_ptr1) * size (daughter_ptr2)
allocate (k_node_ptr (n_nodes))
pos = 1
do i=1, size (daughter_ptr1)
do j=1, size (daughter_ptr2)
if (f_node%incoming .or. f_node%t_line) then
call f_node%k_node_list%add_entry (k_node_ptr(pos)%node, recycle = .false.)
else
call f_node%k_node_list%add_entry (k_node_ptr(pos)%node, recycle = .true.)
end if
k_node_ptr(pos)%node%f_node => f_node
k_node_ptr(pos)%node%daughter1 => daughter_ptr1(i)%node
k_node_ptr(pos)%node%daughter2 => daughter_ptr2(j)%node
k_node_ptr(pos)%node%f_node_index = f_node%index
k_node_ptr(pos)%node%incoming = f_node%incoming
k_node_ptr(pos)%node%t_line = f_node%t_line
k_node_ptr(pos)%node%particle => f_node%particle
pos = pos + 1
enddo
enddo
deallocate (daughter_ptr1, daughter_ptr2)
else
allocate (k_node_ptr(1))
if (f_node%incoming .or. f_node%t_line) then
call f_node%k_node_list%add_entry (k_node_ptr(1)%node, recycle=.false.)
else
call f_node%k_node_list%add_entry (k_node_ptr(1)%node, recycle=.true.)
end if
k_node_ptr(1)%node%f_node => f_node
k_node_ptr(1)%node%f_node_index = f_node%index
k_node_ptr(1)%node%incoming = f_node%incoming
k_node_ptr(1)%node%t_line = f_node%t_line
k_node_ptr(1)%node%particle => f_node%particle
k_node_ptr(1)%node%bincode = f_node_get_external_bincode (feyngraph_set, &
f_node)
end if
end if
end subroutine k_node_init_from_f_node
@ %def k_node_init_from_f_node
@ The graphs resulting from [[k_node_init_from_f_node]] are fine if they
are used only in one direction. This is however not the case when one
wants to invert the graphs, i.e. take the other incoming particle of a
scattering process as the decaying particle, because the outgoing
[[f_nodes]] (and hence also the [[k_nodes]]) exist only once. This
problem is solved here by creating a distinct t-line for each of the
graphs. The following subroutine disentangles the data structure by
creating new nodes such that the different t-lines are not connected
any more.
<<Cascades2: procedures>>=
recursive subroutine split_up_t_lines (t_node)
type (k_node_ptr_t), dimension(:), intent (inout) :: t_node
type (k_node_t), pointer :: ref_node => null ()
type (k_node_t), pointer :: ref_daughter => null ()
type (k_node_t), pointer :: new_daughter => null ()
type (k_node_ptr_t), dimension(:), allocatable :: t_daughter
integer :: ref_daughter_index
integer :: i, j
allocate (t_daughter (size (t_node)))
do i=1, size (t_node)
ref_node => t_node(i)%node
if (associated (ref_node%daughter1) .and. associated (ref_node%daughter2)) then
ref_daughter => null ()
if (ref_node%daughter1%incoming .or. ref_node%daughter1%t_line) then
ref_daughter => ref_node%daughter1
ref_daughter_index = 1
else if (ref_node%daughter2%incoming .or. ref_node%daughter2%t_line) then
ref_daughter => ref_node%daughter2
ref_daughter_index = 2
end if
do j=1, size (t_daughter)
if (.not. associated (t_daughter(j)%node)) then
t_daughter(j)%node => ref_daughter
exit
else if (t_daughter(j)%node%index == ref_daughter%index) then
new_daughter => null ()
call ref_daughter%f_node%k_node_list%add_entry (new_daughter, recycle=.false.)
new_daughter = ref_daughter
new_daughter%daughter1 => ref_daughter%daughter1
new_daughter%daughter2 => ref_daughter%daughter2
if (ref_daughter_index == 1) then
ref_node%daughter1 => new_daughter
else if (ref_daughter_index == 2) then
ref_node%daughter2 => new_daughter
end if
ref_daughter => new_daughter
end if
enddo
else
return
end if
enddo
call split_up_t_lines (t_daughter)
deallocate (t_daughter)
end subroutine split_up_t_lines
@ %def split_up_t_lines
@ This subroutine sets the [[inverse_daughters]] of a [[k_node]]. If we
invert a [[kingraph]] such that not the first but the second incoming
particle appears as the root of the tree, the [[incoming]] and [[t_line]]
particles obtain other daughters. These are the former mother node and
the sister node [[s_daughter]]. Here we set only the pointers for
the [[inverse_daughters]]. The inversion happens in [[kingraph_make_inverse_copy]]
and [[node_inverse_deep_copy]].
<<Cascades2: procedures>>=
subroutine kingraph_set_inverse_daughters (kingraph)
type (kingraph_t), intent (inout) :: kingraph
type (k_node_t), pointer :: mother
type (k_node_t), pointer :: t_daughter
type (k_node_t), pointer :: s_daughter
mother => kingraph%root
do while (associated (mother))
if (associated (mother%daughter1) .and. &
associated (mother%daughter2)) then
if (mother%daughter1%t_line .or. mother%daughter1%incoming) then
t_daughter => mother%daughter1; s_daughter => mother%daughter2
else if (mother%daughter2%t_line .or. mother%daughter2%incoming) then
t_daughter => mother%daughter2; s_daughter => mother%daughter1
else
exit
end if
t_daughter%inverse_daughter1 => mother
t_daughter%inverse_daughter2 => s_daughter
mother => t_daughter
else
exit
end if
enddo
end subroutine kingraph_set_inverse_daughters
@ %def kingraph_set_inverse_daughters
@ Set the bincode of an [[f_node]] which corresponds to an external
particle. This is done on the basis of the [[particle_label]] which is a
substring of the input file. Here it is not the particle name which is
important, but the number(s) in brackets which in general indicate the
external particles which are connected to the current node. This function
is however only used for external particles, so there can either be
one or [[n_out + 1]] particles in the brackets (in the DAG input file
always one, because also for the root there is only a single number).
In all cases we check the number of particles (in the DAG input the
numbers are separated by a slash).
<<Cascades2: procedures>>=
function f_node_get_external_bincode (feyngraph_set, f_node) result (bincode)
type (feyngraph_set_t), intent (in) :: feyngraph_set
type (f_node_t), intent (in) :: f_node
integer (TC) :: bincode
character (len=LABEL_LEN) :: particle_label
integer :: start_pos, end_pos, n_out_decay
integer :: n_prt ! for DAG
integer :: i
bincode = 0
if (feyngraph_set%process_type == DECAY) then
n_out_decay = feyngraph_set%n_out
else
n_out_decay = feyngraph_set%n_out + 1
end if
particle_label = f_node%particle_label
start_pos = index (particle_label, '[') + 1
end_pos = index (particle_label, ']') - 1
particle_label = particle_label(start_pos:end_pos)
!!! n_out_decay is the number of outgoing particles in the
!!! O'Mega output, which is always represented as a decay
if (feyngraph_set%use_dag) then
n_prt = 1
do i=1, len(particle_label)
if (particle_label(i:i) == '/') n_prt = n_prt + 1
enddo
else
n_prt = end_pos - start_pos + 1
end if
if (n_prt == 1) then
bincode = calculate_external_bincode (particle_label, &
feyngraph_set%process_type, n_out_decay)
else if (n_prt == n_out_decay) then
bincode = ibset (0, n_out_decay)
end if
end function f_node_get_external_bincode
@ %def f_node_get_external_bincode
@ Assign a bincode to an internal node, which is calculated from
the bincodes of [[daughter1]] and [[daughter2]].
<<Cascades2: procedures>>=
subroutine node_assign_bincode (node)
type (k_node_t), intent (inout) :: node
if (associated (node%daughter1) .and. associated (node%daughter2) &
.and. .not. node%incoming) then
node%bincode = ior(node%daughter1%bincode, node%daughter2%bincode)
end if
end subroutine node_assign_bincode
@ %def node_assign_bincode
@ Calculate the [[bincode]] from the number in the brackets of the
[[particle_label]], if the node is external. For the root in the
non-factorized output, this is calculated directly in
[[f_node_get_external_bincode]] because in this case all the other
external particle numbers appear between the brackets.
<<Cascades2: procedures>>=
function calculate_external_bincode (label_number_string, process_type, n_out_decay) result (bincode)
character (len=*), intent (in) :: label_number_string
integer, intent (in) :: process_type
integer, intent (in) :: n_out_decay
character :: number_char
integer :: number_int
integer (kind=TC) :: bincode
bincode = 0
read (label_number_string, fmt='(A)') number_char
!!! check if the character is a letter (A,B,C,...) or a number (1...9)
!!! numbers 1 and 2 are special cases
select case (number_char)
case ('1')
if (process_type == SCATTERING) then
number_int = n_out_decay + 3
else
number_int = n_out_decay + 2
end if
case ('2')
if (process_type == SCATTERING) then
number_int = n_out_decay + 2
else
number_int = 2
end if
case ('A')
number_int = 10
case ('B')
number_int = 11
case ('C')
number_int = 12
case ('D')
number_int = 13
case default
read (number_char, fmt='(I1)') number_int
end select
bincode = ibset (bincode, number_int - process_type - 1)
end function calculate_external_bincode
@ %def calculate_external_bincode
@
\subsection{Mapping calculations}
Once a [[k_node]] and its subtree nodes have been created, we can
perform the kinematical calculations and assign mappings, depending on
the particle properties and the results for the subtree nodes. This
could in principle be done recursively, calling the procedure first
for the daughter nodes and then perform the calculations for the actual
node. But for parallization and comparing the nodes, this will be done
simultaneously for all nodes with the same number of subtree nodes, and the number of
subtree nodes increases, starting from one, in steps of two. The
actual mapping calculations are done in complete analogy to cascades.
<<Cascades2: procedures>>=
subroutine node_assign_mapping_s (feyngraph, node, feyngraph_set)
type (feyngraph_t), intent (inout) :: feyngraph
type (k_node_t), intent (inout) :: node
type (feyngraph_set_t), intent (inout) :: feyngraph_set
real(default) :: eff_mass_sum
logical :: keep
if (.not. node%mapping_assigned) then
if (node%particle%mass > feyngraph_set%phs_par%m_threshold_s) then
node%effective_mass = node%particle%mass
end if
if (associated (node%daughter1) .and. associated (node%daughter2)) then
if (.not. (node%daughter1%keep .and. node%daughter2%keep)) then
node%keep = .false.; return
end if
node%ext_mass_sum = node%daughter1%ext_mass_sum &
+ node%daughter2%ext_mass_sum
keep = .false.
!!! Potentially resonant cases [sqrts = m_rea for on-shell decay]
if (node%particle%mass > node%ext_mass_sum &
.and. node%particle%mass <= feyngraph_set%phs_par%sqrts) then
if (node%particle%width /= 0) then
if (node%daughter1%on_shell .or. node%daughter2%on_shell) then
keep = .true.
node%mapping = S_CHANNEL
node%resonant = .true.
end if
else
call warn_decay (node%particle)
end if
!!! Collinear and IR singular cases
else if (node%particle%mass < feyngraph_set%phs_par%sqrts) then
!!! Massless splitting
if (node%daughter1%effective_mass == 0 &
.and. node%daughter2%effective_mass == 0 &
.and. .not. associated (node%daughter1%daughter1) &
.and. .not. associated (node%daughter1%daughter2) &
.and. .not. associated (node%daughter2%daughter1) &
.and. .not. associated (node%daughter2%daughter2)) then
keep = .true.
node%log_enhanced = .true.
if (node%particle%is_vector) then
if (node%daughter1%particle%is_vector &
.and. node%daughter2%particle%is_vector) then
node%mapping = COLLINEAR !!! three-vector-splitting
else
node%mapping = INFRARED !!! vector spliiting into matter
end if
else
if (node%daughter1%particle%is_vector &
.or. node%daughter2%particle%is_vector) then
node%mapping = COLLINEAR !!! vector radiation off matter
else
node%mapping = INFRARED !!! scalar radiation/splitting
end if
end if
!!! IR radiation off massive particle [cascades]
else if (node%effective_mass > 0 .and. &
node%daughter1%effective_mass > 0 .and. &
node%daughter2%effective_mass == 0 .and. &
(node%daughter1%on_shell .or. &
node%daughter1%mapping == RADIATION) .and. &
abs (node%effective_mass - &
node%daughter1%effective_mass) < feyngraph_set%phs_par%m_threshold_s) &
then
keep = .true.
node%log_enhanced = .true.
node%mapping = RADIATION
else if (node%effective_mass > 0 .and. &
node%daughter2%effective_mass > 0 .and. &
node%daughter1%effective_mass == 0 .and. &
(node%daughter2%on_shell .or. &
node%daughter2%mapping == RADIATION) .and. &
abs (node%effective_mass - &
node%daughter2%effective_mass) < feyngraph_set%phs_par%m_threshold_s) &
then
keep = .true.
node%log_enhanced = .true.
node%mapping = RADIATION
end if
end if
!!! Non-singular cases, including failed resonances [from cascades]
if (.not. keep) then
!!! Two on-shell particles from a virtual mother [from cascades, here eventually more than 2]
if (node%daughter1%on_shell .or. node%daughter2%on_shell) then
keep = .true.
eff_mass_sum = node%daughter1%effective_mass &
+ node%daughter2%effective_mass
node%effective_mass = max (node%ext_mass_sum, eff_mass_sum)
if (node%effective_mass < feyngraph_set%phs_par%m_threshold_s) then
node%effective_mass = 0
end if
end if
end if
!!! Complete and register feyngraph (make copy in case of resonance)
if (keep) then
node%on_shell = node%resonant .or. node%log_enhanced
if (node%resonant) then
if (feyngraph_set%phs_par%keep_nonresonant) then
call k_node_make_nonresonant_copy (node)
end if
node%ext_mass_sum = node%particle%mass
end if
end if
node%mapping_assigned = .true.
call node_assign_bincode (node)
call node%subtree%add_entry (node)
else !!! external (outgoing) particle
node%ext_mass_sum = node%particle%mass
node%mapping = EXTERNAL_PRT
node%multiplicity = 1
node%mapping_assigned = .true.
call node%subtree%add_entry (node)
node%on_shell = .true.
if (node%particle%mass >= feyngraph_set%phs_par%m_threshold_s) then
node%effective_mass = node%particle%mass
end if
end if
else if (node%is_nonresonant_copy) then
call node_assign_bincode (node)
call node%subtree%add_entry (node)
node%is_nonresonant_copy = .false.
end if
call node_count_specific_properties (node)
if (node%n_off_shell > feyngraph_set%phs_par%off_shell) then
node%keep = .false.
end if
contains
subroutine warn_decay (particle)
type(part_prop_t), intent(in) :: particle
integer :: i
integer, dimension(MAX_WARN_RESONANCE), save :: warned_code = 0
LOOP_WARNED: do i = 1, MAX_WARN_RESONANCE
if (warned_code(i) == 0) then
warned_code(i) = particle%pdg
write (msg_buffer, "(A)") &
& " Intermediate decay of zero-width particle " &
& // trim(particle%particle_label) &
& // " may be possible."
call msg_warning
exit LOOP_WARNED
else if (warned_code(i) == particle%pdg) then
exit LOOP_WARNED
end if
end do LOOP_WARNED
end subroutine warn_decay
end subroutine node_assign_mapping_s
@ %def node_assign_mapping_s
@ We determine the numbers [[n_resonances]], [[multiplicity]],
[[n_off_shell]] and [[n_log_enhanced]] for a given node.
<<Cascades2: procedures>>=
subroutine node_count_specific_properties (node)
type (k_node_t), intent (inout) :: node
if (associated (node%daughter1) .and. associated(node%daughter2)) then
if (node%resonant) then
node%multiplicity = 1
node%n_resonances &
= node%daughter1%n_resonances &
+ node%daughter2%n_resonances + 1
else
node%multiplicity &
= node%daughter1%multiplicity &
+ node%daughter2%multiplicity
node%n_resonances &
= node%daughter1%n_resonances &
+ node%daughter2%n_resonances
end if
if (node%log_enhanced) then
node%n_log_enhanced &
= node%daughter1%n_log_enhanced &
+ node%daughter2%n_log_enhanced + 1
else
node%n_log_enhanced &
= node%daughter1%n_log_enhanced &
+ node%daughter2%n_log_enhanced
end if
if (node%resonant) then
node%n_off_shell = 0
else if (node%log_enhanced) then
node%n_off_shell &
= node%daughter1%n_off_shell &
+ node%daughter2%n_off_shell
else
node%n_off_shell &
= node%daughter1%n_off_shell &
+ node%daughter2%n_off_shell + 1
end if
if (node%t_line) then
if (node%daughter1%t_line .or. node%daughter1%incoming) then
node%n_t_channel = node%daughter1%n_t_channel + 1
else if (node%daughter2%t_line .or. node%daughter2%incoming) then
node%n_t_channel = node%daughter2%n_t_channel + 1
end if
end if
end if
end subroutine node_count_specific_properties
@ %def node_count_specific_properties
@ The subroutine [[kingraph_assign_mappings_s]] completes kinematical
calculations for a decay process, considering the [[root]] node.
<<Cascades2: procedures>>=
subroutine kingraph_assign_mappings_s (feyngraph, kingraph, feyngraph_set)
type (feyngraph_t), intent (inout) :: feyngraph
type (kingraph_t), pointer, intent (inout) :: kingraph
type (feyngraph_set_t), intent (inout) :: feyngraph_set
if (.not. (kingraph%root%daughter1%keep .and. kingraph%root%daughter2%keep)) then
kingraph%keep = .false.
call kingraph%tree%final ()
end if
if (kingraph%keep) then
kingraph%root%on_shell = .true.
kingraph%root%mapping = EXTERNAL_PRT
kingraph%root%mapping_assigned = .true.
call node_assign_bincode (kingraph%root)
kingraph%root%ext_mass_sum = &
kingraph%root%daughter1%ext_mass_sum + &
kingraph%root%daughter2%ext_mass_sum
if (kingraph%root%ext_mass_sum >= feyngraph_set%phs_par%sqrts) then
kingraph%root%keep = .false.
kingraph%keep = .false.; call kingraph%tree%final (); return
end if
call kingraph%root%subtree%add_entry (kingraph%root)
kingraph%root%multiplicity &
= kingraph%root%daughter1%multiplicity &
+ kingraph%root%daughter2%multiplicity
kingraph%root%n_resonances &
= kingraph%root%daughter1%n_resonances &
+ kingraph%root%daughter2%n_resonances
kingraph%root%n_off_shell &
= kingraph%root%daughter1%n_off_shell &
+ kingraph%root%daughter2%n_off_shell
kingraph%root%n_log_enhanced &
= kingraph%root%daughter1%n_log_enhanced &
+ kingraph%root%daughter2%n_log_enhanced
if (kingraph%root%n_off_shell > feyngraph_set%phs_par%off_shell) then
kingraph%root%keep = .false.
kingraph%keep = .false.; call kingraph%tree%final (); return
else
kingraph%grove_prop%multiplicity = &
kingraph%root%multiplicity
kingraph%grove_prop%n_resonances = &
kingraph%root%n_resonances
kingraph%grove_prop%n_off_shell = &
kingraph%root%n_off_shell
kingraph%grove_prop%n_log_enhanced = &
kingraph%root%n_log_enhanced
end if
kingraph%tree = kingraph%root%subtree
end if
end subroutine kingraph_assign_mappings_s
@ %def kingraph_assign_mappings_s
@ Compute mappings for the [[t_line]] and [[incoming]] nodes. This is
done recursively using [[node_compute_t_line]].
<<Cascades2: procedures>>=
subroutine kingraph_compute_mappings_t_line (feyngraph, kingraph, feyngraph_set)
type (feyngraph_t), intent (inout) :: feyngraph
type (kingraph_t), pointer, intent (inout) :: kingraph
type (feyngraph_set_t), intent (inout) :: feyngraph_set
call node_compute_t_line (feyngraph, kingraph, kingraph%root, feyngraph_set)
if (.not. kingraph%root%keep) then
kingraph%keep = .false.
call kingraph%tree%final ()
end if
if (kingraph%keep) kingraph%tree = kingraph%root%subtree
end subroutine kingraph_compute_mappings_t_line
@ %def kingraph_compute_mappings_t_line
@ Perform the kinematical calculations and mapping assignment for a node
which is either [[incoming]] or [[t_line]]. This is done recursively,
going first to the daughter node which has this property. Therefore we
first set the pointer [[t_node]] to this daughter node and [[s_node]] to
the other one. The mapping determination happens again in the same way as
in [[cascades]].
<<Cascades2: procedures>>=
recursive subroutine node_compute_t_line (feyngraph, kingraph, node, feyngraph_set)
type (feyngraph_t), intent (inout) :: feyngraph
type (kingraph_t), intent (inout) :: kingraph
type (k_node_t), intent (inout) :: node
type (feyngraph_set_t), intent (inout) :: feyngraph_set
type (k_node_t), pointer :: s_node
type (k_node_t), pointer :: t_node
type (k_node_t), pointer :: new_s_node
if (.not. (node%daughter1%keep .and. node%daughter2%keep)) then
node%keep = .false.
return
end if
s_node => null ()
t_node => null ()
new_s_node => null ()
if (associated (node%daughter1) .and. associated (node%daughter2)) then
if (node%daughter1%t_line .or. node%daughter1%incoming) then
t_node => node%daughter1; s_node => node%daughter2
else if (node%daughter2%t_line .or. node%daughter2%incoming) then
t_node => node%daughter2; s_node => node%daughter1
end if
if (t_node%t_line) then
call node_compute_t_line (feyngraph, kingraph, t_node, feyngraph_set)
if (.not. t_node%keep) then
node%keep = .false.
return
end if
else if (t_node%incoming) then
t_node%mapping = EXTERNAL_PRT
t_node%on_shell = .true.
t_node%ext_mass_sum = t_node%particle%mass
if (t_node%particle%mass >= feyngraph_set%phs_par%m_threshold_t) then
t_node%effective_mass = t_node%particle%mass
end if
call t_node%subtree%add_entry (t_node)
end if
!!! root:
if (.not. node%incoming) then
if (t_node%incoming) then
node%ext_mass_sum = s_node%ext_mass_sum
else
node%ext_mass_sum &
= node%daughter1%ext_mass_sum &
+ node%daughter2%ext_mass_sum
end if
if (node%particle%mass > feyngraph_set%phs_par%m_threshold_t) then
node%effective_mass = max (node%particle%mass, &
s_node%effective_mass)
else if (s_node%effective_mass > feyngraph_set%phs_par%m_threshold_t) then
node%effective_mass = s_node%effective_mass
else
node%effective_mass = 0
end if
!!! Allowed decay of beam particle
if (t_node%incoming &
.and. t_node%particle%mass > s_node%particle%mass &
+ node%particle%mass) then
call beam_decay (feyngraph_set%fatal_beam_decay)
!!! Massless splitting
else if (t_node%effective_mass == 0 &
.and. s_node%effective_mass < feyngraph_set%phs_par%m_threshold_t &
.and. node%effective_mass == 0) then
node%mapping = U_CHANNEL
node%log_enhanced = .true.
!!! IR radiation off massive particle
else if (t_node%effective_mass /= 0 &
.and. s_node%effective_mass == 0 &
.and. node%effective_mass /= 0 &
.and. (t_node%on_shell &
.or. t_node%mapping == RADIATION) &
.and. abs (t_node%effective_mass - node%effective_mass) &
< feyngraph_set%phs_par%m_threshold_t) then
node%log_enhanced = .true.
node%mapping = RADIATION
end if
node%mapping_assigned = .true.
call node_assign_bincode (node)
call node%subtree%add_entry (node)
call node_count_specific_properties (node)
if (node%n_off_shell > feyngraph_set%phs_par%off_shell) then
node%keep = .false.
kingraph%keep = .false.; call kingraph%tree%final (); return
else if (node%n_t_channel > feyngraph_set%phs_par%t_channel) then
node%keep = .false.;
kingraph%keep = .false.; call kingraph%tree%final (); return
end if
else
node%mapping = EXTERNAL_PRT
node%on_shell = .true.
node%ext_mass_sum &
= t_node%ext_mass_sum &
+ s_node%ext_mass_sum
node%effective_mass = node%particle%mass
if (.not. (node%ext_mass_sum < feyngraph_set%phs_par%sqrts)) then
node%keep = .false.
kingraph%keep = .false.; call kingraph%tree%final (); return
end if
if (kingraph%keep) then
if (t_node%incoming .and. s_node%log_enhanced) then
call s_node%f_node%k_node_list%add_entry (new_s_node, recycle=.false.)
new_s_node = s_node
new_s_node%daughter1 => s_node%daughter1
new_s_node%daughter2 => s_node%daughter2
if (s_node%index == node%daughter1%index) then
node%daughter1 => new_s_node
else if (s_node%index == node%daughter2%index) then
node%daughter2 => new_s_node
end if
new_s_node%subtree = s_node%subtree
new_s_node%mapping = NO_MAPPING
new_s_node%log_enhanced = .false.
new_s_node%n_log_enhanced &
= new_s_node%n_log_enhanced - 1
new_s_node%log_enhanced = .false.
where (new_s_node%subtree%bc == new_s_node%bincode)
new_s_node%subtree%mapping = NO_MAPPING
endwhere
else if ((t_node%t_line .or. t_node%incoming) .and. &
t_node%mapping == U_CHANNEL) then
t_node%mapping = T_CHANNEL
where (t_node%subtree%bc == t_node%bincode)
t_node%subtree%mapping = T_CHANNEL
endwhere
else if (t_node%incoming .and. &
.not. associated (s_node%daughter1) .and. &
.not. associated (s_node%daughter2)) then
call s_node%f_node%k_node_list%add_entry (new_s_node, recycle=.false.)
new_s_node = s_node
new_s_node%mapping = ON_SHELL
new_s_node%daughter1 => s_node%daughter1
new_s_node%daughter2 => s_node%daughter2
new_s_node%subtree = s_node%subtree
if (s_node%index == node%daughter1%index) then
node%daughter1 => new_s_node
else if (s_node%index == node%daughter2%index) then
node%daughter2 => new_s_node
end if
where (new_s_node%subtree%bc == new_s_node%bincode)
new_s_node%subtree%mapping = ON_SHELL
endwhere
end if
end if
call node%subtree%add_entry (node)
node%multiplicity &
= node%daughter1%multiplicity &
+ node%daughter2%multiplicity
node%n_resonances &
= node%daughter1%n_resonances &
+ node%daughter2%n_resonances
node%n_off_shell &
= node%daughter1%n_off_shell &
+ node%daughter2%n_off_shell
node%n_log_enhanced &
= node%daughter1%n_log_enhanced &
+ node%daughter2%n_log_enhanced
node%n_t_channel &
= node%daughter1%n_t_channel &
+ node%daughter2%n_t_channel
if (node%n_off_shell > feyngraph_set%phs_par%off_shell) then
node%keep = .false.
kingraph%keep = .false.; call kingraph%tree%final (); return
else if (node%n_t_channel > feyngraph_set%phs_par%t_channel) then
node%keep = .false.
kingraph%keep = .false.; call kingraph%tree%final (); return
else
kingraph%grove_prop%multiplicity = node%multiplicity
kingraph%grove_prop%n_resonances = node%n_resonances
kingraph%grove_prop%n_off_shell = node%n_off_shell
kingraph%grove_prop%n_log_enhanced = node%n_log_enhanced
kingraph%grove_prop%n_t_channel = node%n_t_channel
end if
end if
end if
contains
subroutine beam_decay (fatal_beam_decay)
logical, intent(in) :: fatal_beam_decay
write (msg_buffer, "(1x,A,1x,'->',1x,A,1x,A)") &
t_node%particle%particle_label, &
node%particle%particle_label, &
s_node%particle%particle_label
call msg_message
write (msg_buffer, "(1x,'mass(',A,') =',1x,E17.10)") &
t_node%particle%particle_label, t_node%particle%mass
call msg_message
write (msg_buffer, "(1x,'mass(',A,') =',1x,E17.10)") &
node%particle%particle_label, node%particle%mass
call msg_message
write (msg_buffer, "(1x,'mass(',A,') =',1x,E17.10)") &
s_node%particle%particle_label, s_node%particle%mass
call msg_message
if (fatal_beam_decay) then
call msg_fatal (" Phase space: Initial beam particle can decay")
else
call msg_warning (" Phase space: Initial beam particle can decay")
end if
end subroutine beam_decay
end subroutine node_compute_t_line
@ %def node_compute_t_line
@ After all pure s-channel subdiagrams have already been created from the
corresponding [[f_nodes]] and mappings have been determined for their
nodes, we complete the calculations here. In a first step, the
[[kingraphs]] have to be created on the basis of the existing
[[k_nodes]], which means in particular that a [[feyngraph]] can give
rise to several [[kingraphs]] which will all be attached to the linked
list of the [[feyngraph]]. The calculations which remain are of different
kinds for decay and scattering processes. In a decay process the
kinematical calculations have to be done for the [[root]] node. In a
scattering process, after the creation of [[kingraphs]] in the first
step, there will be only [[kingraphs]] with the first incoming particle
as the [[root]] of the tree. For these graphs the [[inverse]] variable
has the value [[.false.]]. Before performing any calculations on these
graphs we make a so-called inverse copy of the graph (see below), which
will also be attached to the linked list. Since the s-channel subgraph
calculations have already been completed, only the t-line computations
remain.
<<Cascades2: feyngraph: TBP>>=
procedure :: make_inverse_kingraphs => feyngraph_make_inverse_kingraphs
<<Cascades2: procedures>>=
subroutine feyngraph_make_inverse_kingraphs (feyngraph)
class (feyngraph_t), intent (inout) :: feyngraph
type (kingraph_t), pointer :: current
current => feyngraph%kin_first
do while (associated (current))
if (current%inverse) exit
call current%make_inverse_copy (feyngraph)
current => current%next
enddo
end subroutine feyngraph_make_inverse_kingraphs
@ %def feyngraph_make_inverse_kingraphs
<<Cascades2: feyngraph: TBP>>=
procedure :: compute_mappings => feyngraph_compute_mappings
<<Cascades2: procedures>>=
subroutine feyngraph_compute_mappings (feyngraph, feyngraph_set)
class (feyngraph_t), intent (inout) :: feyngraph
type (feyngraph_set_t), intent (inout) :: feyngraph_set
type (kingraph_t), pointer :: current
current => feyngraph%kin_first
do while (associated (current))
if (feyngraph_set%process_type == DECAY) then
call kingraph_assign_mappings_s (feyngraph, current, feyngraph_set)
else if (feyngraph_set%process_type == SCATTERING) then
call kingraph_compute_mappings_t_line (feyngraph, current, feyngraph_set)
end if
current => current%next
enddo
end subroutine feyngraph_compute_mappings
@ %def feyngraph_compute_mappings
@ Here we control the mapping calculations for the nodes of s-channel
subgraphs. We start with the nodes with the smallest number of subtree
nodes and always increase this number by two because nodes have exactly
zero or two daughter nodes. We create the [[k_nodes]] using the
[[k_node_list]] of each [[f_node]]. The number of nodes which have to
be created depends of the number of existing daughter nodes, which means
that we have to create a node for each combination of existing and
valid (the ones which we [[keep]]) daughter nodes. If the node
corresponds to an external particle, we create only one node, since
there are no daughter nodes. If the particle is not external and
the daughter [[f_nodes]] do not contain any valid [[k_nodes]], we do
not create a new [[k_nodes]] either. When the calculations for all nodes
with the same number of subtree nodes have been completed, we compare
the valid nodes to eliminate equivalences (see below).
<<Cascades2: procedures>>=
subroutine f_node_list_compute_mappings_s (feyngraph_set)
type (feyngraph_set_t), intent (inout) :: feyngraph_set
type (f_node_ptr_t), dimension(:), allocatable :: set
type (k_node_ptr_t), dimension(:), allocatable :: k_set
type (k_node_entry_t), pointer :: k_entry
type (f_node_entry_t), pointer :: current
type (k_node_list_t), allocatable :: compare_list
integer :: n_entries
integer :: pos
integer :: i, j, k
do i = 1, feyngraph_set%f_node_list%max_tree_size - 2, 2
!!! Counter number of f_nodes with subtree size i for s channel calculations
n_entries = 0
if (feyngraph_set%use_dag) then
do j=1, feyngraph_set%dag%n_nodes
if (allocated (feyngraph_set%dag%node(j)%f_node)) then
do k=1, size(feyngraph_set%dag%node(j)%f_node)
if (associated (feyngraph_set%dag%node(j)%f_node(k)%node)) then
if (.not. (feyngraph_set%dag%node(j)%f_node(k)%node%incoming &
.or. feyngraph_set%dag%node(j)%f_node(k)%node%t_line) &
.and. feyngraph_set%dag%node(j)%f_node(k)%node%n_subtree_nodes == i) then
n_entries = n_entries + 1
end if
end if
enddo
end if
enddo
else
current => feyngraph_set%f_node_list%first
do while (associated (current))
if (.not. (current%node%incoming .or. current%node%t_line) &
.and. current%node%n_subtree_nodes == i) then
n_entries = n_entries + 1
end if
current => current%next
enddo
end if
if (n_entries == 0) exit
!!! Create a temporary k node list for comparison
allocate (set(n_entries))
pos = 0
if (feyngraph_set%use_dag) then
do j=1, feyngraph_set%dag%n_nodes
if (allocated (feyngraph_set%dag%node(j)%f_node)) then
do k=1, size(feyngraph_set%dag%node(j)%f_node)
if (associated (feyngraph_set%dag%node(j)%f_node(k)%node)) then
if (.not. (feyngraph_set%dag%node(j)%f_node(k)%node%incoming &
.or. feyngraph_set%dag%node(j)%f_node(k)%node%t_line) &
.and. feyngraph_set%dag%node(j)%f_node(k)%node%n_subtree_nodes == i) then
pos = pos + 1
set(pos)%node => feyngraph_set%dag%node(j)%f_node(k)%node
end if
end if
enddo
end if
enddo
else
current => feyngraph_set%f_node_list%first
do while (associated (current))
if (.not. (current%node%incoming .or. current%node%t_line) &
.and. current%node%n_subtree_nodes == i) then
pos = pos + 1
set(pos)%node => current%node
end if
current => current%next
enddo
end if
allocate (compare_list)
compare_list%observer = .true.
do j = 1, n_entries
call k_node_init_from_f_node (set(j)%node, k_set, &
feyngraph_set)
if (allocated (k_set)) deallocate (k_set)
enddo
!$OMP PARALLEL DO PRIVATE (k_entry)
do j = 1, n_entries
k_entry => set(j)%node%k_node_list%first
do while (associated (k_entry))
call node_assign_mapping_s(feyngraph_set%first, k_entry%node, feyngraph_set)
k_entry => k_entry%next
enddo
enddo
!$OMP END PARALLEL DO
do j = 1, size (set)
k_entry => set(j)%node%k_node_list%first
do while (associated (k_entry))
if (k_entry%node%keep) then
if (k_entry%node%mapping == NO_MAPPING .or. k_entry%node%mapping == NONRESONANT) then
call compare_list%add_pointer (k_entry%node)
end if
end if
k_entry => k_entry%next
enddo
enddo
deallocate (set)
call compare_list%check_subtree_equivalences(feyngraph_set%model)
call compare_list%final
deallocate (compare_list)
enddo
end subroutine f_node_list_compute_mappings_s
@ %def f_node_list_compute_mappings_s
@
\subsection{Fill the grove list}
Find the [[grove]] within the [[grove_list]] for a [[kingraph]] for
which the kinematical calculations and mapping assignments have been completed. The [[groves]]
are defined by the [[grove_prop]] entries and the value of the resonance
hash ([[res_hash]]). Whenever a matching grove does not exist, we
create one. In a first step we consider only part of the grove properties
(see [[grove_prop_match]]) and the resonance hash is ignored, which leads
to a preliminary grove list. In the end all numbers in [[grove_prop]] as
well as the resonance hash are compared, i.e. we create a new
[[grove_list]].
<<Cascades2: grove list: TBP>>=
procedure :: get_grove => grove_list_get_grove
<<Cascades2: procedures>>=
subroutine grove_list_get_grove (grove_list, kingraph, return_grove, preliminary)
class (grove_list_t), intent (inout) :: grove_list
type (kingraph_t), intent (in), pointer :: kingraph
type (grove_t), intent (inout), pointer :: return_grove
logical, intent (in) :: preliminary
type (grove_t), pointer :: current_grove
return_grove => null ()
if (.not. associated(grove_list%first)) then
allocate (grove_list%first)
grove_list%first%grove_prop = kingraph%grove_prop
return_grove => grove_list%first
return
end if
current_grove => grove_list%first
do while (associated (current_grove))
if ((preliminary .and. (current_grove%grove_prop .match. kingraph%grove_prop)) .or. &
(.not. preliminary .and. current_grove%grove_prop == kingraph%grove_prop)) then
return_grove => current_grove
exit
else if (.not. associated (current_grove%next)) then
allocate (current_grove%next)
current_grove%next%grove_prop = kingraph%grove_prop
if (size (kingraph%tree%bc) < 9) &
current_grove%compare_tree%depth = 1
return_grove => current_grove%next
exit
end if
if (associated (current_grove%next)) then
current_grove => current_grove%next
end if
enddo
end subroutine grove_list_get_grove
@ %def grove_list_get_grove
@ Add a valid [[kingraph]] to a [[grove_list]]. We first look for the
[[grove]] which has the grove properties of the [[kingraph]]. If no such
[[grove]] exists so far, it is created.
<<Cascades2: grove list: TBP>>=
procedure :: add_kingraph => grove_list_add_kingraph
<<Cascades2: procedures>>=
subroutine grove_list_add_kingraph (grove_list, kingraph, preliminary, check, model)
class (grove_list_t), intent (inout) :: grove_list
type (kingraph_t), pointer, intent (inout) :: kingraph
logical, intent (in) :: preliminary
logical, intent (in) :: check
type (model_data_t), optional, intent (in) :: model
type (grove_t), pointer :: grove
type (kingraph_t), pointer :: current
integer, save :: index = 0
grove => null ()
current => null ()
if (preliminary) then
if (kingraph%index == 0) then
index = index + 1
kingraph%index = index
end if
end if
call grove_list%get_grove (kingraph, grove, preliminary)
if (check) then
call grove%compare_tree%check_kingraph (kingraph, model, preliminary)
end if
if (kingraph%keep) then
if (associated (grove%first)) then
grove%last%grove_next => kingraph
grove%last => kingraph
else
grove%first => kingraph
grove%last => kingraph
end if
end if
end subroutine grove_list_add_kingraph
@ %ref grove_list_add_kingraph
@ For a given [[feyngraph]] we store all valid [[kingraphs]] in the
[[grove_list]].
<<Cascades2: grove list: TBP>>=
procedure :: add_feyngraph => grove_list_add_feyngraph
<<Cascades2: procedures>>=
subroutine grove_list_add_feyngraph (grove_list, feyngraph, model)
class (grove_list_t), intent (inout) :: grove_list
type (feyngraph_t), intent (inout) :: feyngraph
type (model_data_t), intent (in) :: model
type (kingraph_t), pointer :: current_kingraph, add_kingraph
do while (associated (feyngraph%kin_first))
if (feyngraph%kin_first%keep) then
add_kingraph => feyngraph%kin_first
feyngraph%kin_first => feyngraph%kin_first%next
add_kingraph%next => null ()
call grove_list%add_kingraph (kingraph=add_kingraph, &
preliminary=.true., check=.true., model=model)
else
exit
end if
enddo
if (associated (feyngraph%kin_first)) then
current_kingraph => feyngraph%kin_first
do while (associated (current_kingraph%next))
if (current_kingraph%next%keep) then
add_kingraph => current_kingraph%next
current_kingraph%next => current_kingraph%next%next
add_kingraph%next => null ()
call grove_list%add_kingraph (kingraph=add_kingraph, &
preliminary=.true., check=.true., model=model)
else
current_kingraph => current_kingraph%next
end if
enddo
end if
end subroutine grove_list_add_feyngraph
@ %def grove_list_add_feyngraph
@ Compare two [[grove_prop]] objects. The [[.match.]] operator is used
for preliminary groves in which the [[kingraphs]] share only the 3
numbers [[n_resonances]], [[n_log_enhanced]] and [[n_t_channel]]. These
groves are only used for comparing the kingraphs, because only graphs
within these preliminary groves can be equivalent (the numbers which are
compared here are unambigously fixed by the combination of mappings in
these channels).
<<Cascades2: interfaces>>=
interface operator (.match.)
module procedure grove_prop_match
end interface operator (.match.)
<<Cascades2: procedures>>=
function grove_prop_match (grove_prop1, grove_prop2) result (gp_match)
type (grove_prop_t), intent (in) :: grove_prop1
type (grove_prop_t), intent (in) :: grove_prop2
logical :: gp_match
gp_match = (grove_prop1%n_resonances == grove_prop2%n_resonances) &
.and. (grove_prop1%n_log_enhanced == grove_prop2%n_log_enhanced) &
.and. (grove_prop1%n_t_channel == grove_prop2%n_t_channel)
end function grove_prop_match
@ %def grove_prop_match
@ The equal operator on the other hand will be used when all valid
[[kingraphs]] have been created and mappings have been determined, to
split up the existing (preliminary) grove list, i.e. to create new
groves which are determined by all entries in [[grove_prop_t]].
<<Cascades2: interfaces>>=
interface operator (==)
module procedure grove_prop_equal
end interface operator (==)
<<Cascades2: procedures>>=
function grove_prop_equal (grove_prop1, grove_prop2) result (gp_equal)
type (grove_prop_t), intent (in) :: grove_prop1
type (grove_prop_t), intent (in) :: grove_prop2
logical :: gp_equal
gp_equal = (grove_prop1%res_hash == grove_prop2%res_hash) &
.and. (grove_prop1%n_resonances == grove_prop2%n_resonances) &
.and. (grove_prop1%n_log_enhanced == grove_prop2%n_log_enhanced) &
.and. (grove_prop1%n_off_shell == grove_prop2%n_off_shell) &
.and. (grove_prop1%multiplicity == grove_prop2%multiplicity) &
.and. (grove_prop1%n_t_channel == grove_prop2%n_t_channel)
end function grove_prop_equal
@ %def grove_prop_equal
@
\subsection{Remove equivalent channels}
Here we define the equivalence condition for completed [[kingraphs]].
The aim is to keep those [[kingraphs]] which describe the strongest
peaks of the amplitude. The [[bincodes]] and [[mappings]] have to be
the same for an equivalence, but the [[pdgs]] can be different. At
the same time we check if the trees are exacly the same (up to the
sign of pdg codes) in which case we do not keep both of them. This
can be the case when the incoming particles are the same or their
mutual anti-particles and there are no t-channel lines in the
Feynman diagram to which the kingraph belongs.
<<Cascades2: parameters>>=
integer, parameter :: EMPTY = -999
<<Cascades2: procedures>>=
function kingraph_eqv (kingraph1, kingraph2) result (eqv)
type (kingraph_t), intent (in) :: kingraph1
type (kingraph_t), intent (inout) :: kingraph2
logical :: eqv
integer :: i
logical :: equal
eqv = .false.
do i = kingraph1%tree%n_entries, 1, -1
if (kingraph1%tree%bc(i) /= kingraph2%tree%bc(i)) return
enddo
do i = kingraph1%tree%n_entries, 1, -1
if ( .not. (kingraph1%tree%mapping(i) == kingraph2%tree%mapping(i) &
.or. ((kingraph1%tree%mapping(i) == NO_MAPPING .or. &
kingraph1%tree%mapping(i) == NONRESONANT) .and. &
(kingraph2%tree%mapping(i) == NO_MAPPING .or. &
kingraph2%tree%mapping(i) == NONRESONANT)))) return
enddo
equal = .true.
do i = kingraph1%tree%n_entries, 1, -1
if (abs(kingraph1%tree%pdg(i)) /= abs(kingraph2%tree%pdg(i))) then
equal = .false.;
select case (kingraph1%tree%mapping(i))
case (S_CHANNEL, RADIATION)
select case (kingraph2%tree%mapping(i))
case (S_CHANNEL, RADIATION)
return
end select
end select
end if
enddo
if (equal) then
kingraph2%keep = .false.
call kingraph2%tree%final ()
else
eqv = .true.
end if
end function kingraph_eqv
@ %def kingraph_eqv
@ Select between two [[kingraphs]] which fulfill the equivalence
condition above. This is done by comparing the [[pdg]] values of the
[[tree]] for increasing bincode. If the particles are different at
some place, we usually choose the one which would be returned first by the
subroutine [[match_vertex]] of the model for the daughter [[pdg]] codes.
Since we work here only on the basis of the the [[trees]] of the
completed [[kingraphs]], we have to use the [[bc]] array to determine
the positions of the daughter nodes' entries in the array. The graph
which has to be kept should correspond to the stronger peak at the place
which is compared.
<<Cascades2: procedures>>=
subroutine kingraph_select (kingraph1, kingraph2, model, preliminary)
type (kingraph_t), intent (inout) :: kingraph1
type (kingraph_t), intent (inout) :: kingraph2
type (model_data_t), intent (in) :: model
logical, intent (in) :: preliminary
integer(TC), dimension(:), allocatable :: tmp_bc, daughter_bc
integer, dimension(:), allocatable :: tmp_pdg, daughter_pdg
integer, dimension (:), allocatable :: pdg_match
integer :: i, j
integer :: n_ext1, n_ext2
if (kingraph_eqv (kingraph1, kingraph2)) then
if (.not. preliminary) then
kingraph2%keep = .false.; call kingraph2%tree%final ()
return
end if
do i=1, size (kingraph1%tree%bc)
if (abs(kingraph1%tree%pdg(i)) /= abs(kingraph2%tree%pdg(i))) then
if (kingraph1%tree%mapping(i) /= EXTERNAL_PRT) then
n_ext1 = popcnt (kingraph1%tree%bc(i))
n_ext2 = n_ext1
do j=i+1, size (kingraph1%tree%bc)
if (abs(kingraph1%tree%pdg(j)) /= abs(kingraph2%tree%pdg(j))) then
n_ext2 = popcnt (kingraph1%tree%bc(j))
if (n_ext2 < n_ext1) exit
end if
enddo
if (n_ext2 < n_ext1) cycle
allocate (tmp_bc(i-1))
tmp_bc = kingraph1%tree%bc(:i-1)
allocate (tmp_pdg(i-1))
tmp_pdg = kingraph1%tree%pdg(:i-1)
do j=i-1, 1, - 1
where (iand (tmp_bc(:j-1),tmp_bc(j)) /= 0 &
.or. iand(tmp_bc(:j-1),kingraph1%tree%bc(i)) == 0)
tmp_bc(:j-1) = 0
tmp_pdg(:j-1) = 0
endwhere
enddo
allocate (daughter_bc(size(pack(tmp_bc, tmp_bc /= 0))))
daughter_bc = pack (tmp_bc, tmp_bc /= 0)
allocate (daughter_pdg(size(pack(tmp_pdg, tmp_pdg /= 0))))
daughter_pdg = pack (tmp_pdg, tmp_pdg /= 0)
if (size (daughter_pdg) == 2) then
call model%match_vertex(daughter_pdg(1), daughter_pdg(2), pdg_match)
end if
do j=1, size (pdg_match)
if (abs(pdg_match(j)) == abs(kingraph1%tree%pdg(i))) then
kingraph2%keep = .false.; call kingraph2%tree%final ()
exit
else if (abs(pdg_match(j)) == abs(kingraph2%tree%pdg(i))) then
kingraph1%keep = .false.; call kingraph1%tree%final ()
exit
end if
enddo
deallocate (tmp_bc, tmp_pdg, daughter_bc, daughter_pdg, pdg_match)
if (.not. (kingraph1%keep .and. kingraph2%keep)) exit
end if
end if
enddo
end if
end subroutine kingraph_select
@ %def kingraph_select
@ At the beginning we do not care about the resonance hash, but only
about part of the grove properties, which is defined in
[[grove_prop_match]]. In these resulting preliminary groves the kingraphs
can be equivalent, i.e. we do not have to compare all graphs with each
other but only all graphs within each of these preliminary groves. In the
end we create a new grove list where the grove properties of the
[[kingraphs]] within a [[grove]] have to be exactly the same and in
addition the groves are distinguished by the resonance hash values. Here
the kingraphs are not compared any more, which means that the number of
channels is not reduced any more.
<<Cascades2: grove list: TBP>>=
procedure :: merge => grove_list_merge
<<Cascades2: procedures>>=
subroutine grove_list_merge (target_list, grove_list, model, prc_component)
class (grove_list_t), intent (inout) :: target_list
type (grove_list_t), intent (inout) :: grove_list
type (model_data_t), intent (in) :: model
integer, intent (in) :: prc_component
type (grove_t), pointer :: current_grove
type (kingraph_t), pointer :: current_graph
current_grove => grove_list%first
do while (associated (current_grove))
do while (associated (current_grove%first))
current_graph => current_grove%first
current_grove%first => current_grove%first%grove_next
current_graph%grove_next => null ()
if (current_graph%keep) then
current_graph%prc_component = prc_component
call target_list%add_kingraph(kingraph=current_graph, &
preliminary=.false., check=.true., model=model)
else
call current_graph%final ()
deallocate (current_graph)
end if
enddo
current_grove => current_grove%next
enddo
end subroutine grove_list_merge
@ %def grove_list_merge
@ Recreate a grove list where we have different groves for different
resonance hashes.
<<Cascades2: grove list: TBP>>=
procedure :: rebuild => grove_list_rebuild
<<Cascades2: procedures>>=
subroutine grove_list_rebuild (grove_list)
class (grove_list_t), intent (inout) :: grove_list
type (grove_list_t) :: tmp_list
type (grove_t), pointer :: current_grove
type (grove_t), pointer :: remove_grove
type (kingraph_t), pointer :: current_graph
type (kingraph_t), pointer :: next_graph
tmp_list%first => grove_list%first
grove_list%first => null ()
current_grove => tmp_list%first
do while (associated (current_grove))
current_graph => current_grove%first
do while (associated (current_graph))
call current_graph%assign_resonance_hash ()
next_graph => current_graph%grove_next
current_graph%grove_next => null ()
if (current_graph%keep) then
call grove_list%add_kingraph (kingraph=current_graph, &
preliminary=.false., check=.false.)
end if
current_graph => next_graph
enddo
current_grove => current_grove%next
enddo
call tmp_list%final
end subroutine grove_list_rebuild
@ %def grove_list_rebuild
@
\subsection{Write the phase-space file}
The phase-space file is written from the graphs which survive the
calculations and equivalence checks and are in the grove list. It is
written grove by grove. The output should be the same as in the
corresponding procedure [[cascade_set_write_file_format]] of
[[cascades]], up to the order of groves and channels.
<<Cascades2: public>>=
public :: feyngraph_set_write_file_format
<<Cascades2: procedures>>=
subroutine feyngraph_set_write_file_format (feyngraph_set, u)
type (feyngraph_set_t), intent (in) :: feyngraph_set
integer, intent (in) :: u
type (grove_t), pointer :: grove
integer :: channel_number
integer :: grove_number
channel_number = 0
grove_number = 0
grove => feyngraph_set%grove_list%first
do while (associated (grove))
grove_number = grove_number + 1
call grove%write_file_format (feyngraph_set, grove_number, channel_number, u)
grove => grove%next
enddo
end subroutine feyngraph_set_write_file_format
@ %def feyngraph_set_write_file_format
@ Write the relevant information of the [[kingraphs]] of a [[grove]] and
the grove properties in the file format.
<<Cascades2: grove: TBP>>=
procedure :: write_file_format => grove_write_file_format
<<Cascades2: procedures>>=
recursive subroutine grove_write_file_format (grove, feyngraph_set, gr_number, ch_number, u)
class (grove_t), intent (in) :: grove
type (feyngraph_set_t), intent (in) :: feyngraph_set
integer, intent (in) :: u
integer, intent (inout) :: gr_number
integer, intent (inout) :: ch_number
type (kingraph_t), pointer :: current
1 format(3x,A,1x,40(1x,I4))
write (u, "(A)")
write (u, "(1x,'!',1x,A,1x,I0,A)", advance='no') &
'Multiplicity =', grove%grove_prop%multiplicity, ","
select case (grove%grove_prop%n_resonances)
case (0)
write (u, '(1x,A)', advance='no') 'no resonances, '
case (1)
write (u, '(1x,A)', advance='no') '1 resonance, '
case default
write (u, '(1x,I0,1x,A)', advance='no') &
grove%grove_prop%n_resonances, 'resonances, '
end select
write (u, '(1x,I0,1x,A)', advance='no') &
grove%grove_prop%n_log_enhanced, 'logs, '
write (u, '(1x,I0,1x,A)', advance='no') &
grove%grove_prop%n_off_shell, 'off-shell, '
select case (grove%grove_prop%n_t_channel)
case (0); write (u, '(1x,A)') 's-channel graph'
case (1); write (u, '(1x,A)') '1 t-channel line'
case default
write(u,'(1x,I0,1x,A)') &
grove%grove_prop%n_t_channel, 't-channel lines'
end select
write (u, '(1x,A,I0)') 'grove #', gr_number
current => grove%first
do while (associated (current))
if (current%keep) then
ch_number = ch_number + 1
call current%write_file_format (feyngraph_set, ch_number, u)
end if
current => current%grove_next
enddo
end subroutine grove_write_file_format
@ %def grove_write_file_format
@ Write the relevant information of a valid [[kingraph]] in the file
format. The information is extracted from the [[tree]].
<<Cascades2: kingraph: TBP>>=
procedure :: write_file_format => kingraph_write_file_format
<<Cascades2: procedures>>=
subroutine kingraph_write_file_format (kingraph, feyngraph_set, ch_number, u)
class (kingraph_t), intent (in) :: kingraph
type (feyngraph_set_t), intent (in) :: feyngraph_set
integer, intent (in) :: ch_number
integer, intent (in) :: u
integer :: i
integer(TC) :: bincode_incoming
2 format(3X,'map',1X,I3,1X,A,1X,I9,1X,'!',1X,A)
!!! determine bincode of incoming particle from tree
bincode_incoming = maxval (kingraph%tree%bc)
write (unit=u, fmt='(1X,A,I0)') '! Channel #', ch_number
write (unit=u, fmt='(3X,A,1X)', advance='no') 'tree'
do i=1, size (kingraph%tree%bc)
if (kingraph%tree%mapping(i) >=0 .or. kingraph%tree%mapping(i) == NONRESONANT &
.or. (kingraph%tree%bc(i) == bincode_incoming &
.and. feyngraph_set%process_type == DECAY)) then
write (unit=u, fmt='(1X,I0)', advance='no') kingraph%tree%bc(i)
end if
enddo
write (unit=u, fmt='(A)', advance='yes')
do i=1, size(kingraph%tree%bc)
select case (kingraph%tree%mapping(i))
case (NO_MAPPING, NONRESONANT, EXTERNAL_PRT)
case (S_CHANNEL)
write (unit=u, fmt=2) kingraph%tree%bc(i), 's_channel', &
kingraph%tree%pdg(i), &
trim(get_particle_name (feyngraph_set, kingraph%tree%pdg(i)))
case (T_CHANNEL)
write (unit=u, fmt=2) kingraph%tree%bc(i), 't_channel', &
abs (kingraph%tree%pdg(i)), &
trim(get_particle_name (feyngraph_set, abs(kingraph%tree%pdg(i))))
case (U_CHANNEL)
write (unit=u, fmt=2) kingraph%tree%bc(i), 'u_channel', &
abs (kingraph%tree%pdg(i)), &
trim(get_particle_name (feyngraph_set, abs(kingraph%tree%pdg(i))))
case (RADIATION)
write (unit=u, fmt=2) kingraph%tree%bc(i), 'radiation', &
kingraph%tree%pdg(i), &
trim(get_particle_name (feyngraph_set, kingraph%tree%pdg(i)))
case (COLLINEAR)
write (unit=u, fmt=2) kingraph%tree%bc(i), 'collinear', &
kingraph%tree%pdg(i), &
trim(get_particle_name (feyngraph_set, kingraph%tree%pdg(i)))
case (INFRARED)
write (unit=u, fmt=2) kingraph%tree%bc(i), 'infrared ', &
kingraph%tree%pdg(i), &
trim(get_particle_name (feyngraph_set, kingraph%tree%pdg(i)))
case (ON_SHELL)
write (unit=u, fmt=2) kingraph%tree%bc(i), 'on_shell ', &
kingraph%tree%pdg(i), &
trim(get_particle_name (feyngraph_set, kingraph%tree%pdg(i)))
case default
call msg_bug (" Impossible mapping mode encountered")
end select
enddo
end subroutine kingraph_write_file_format
@ %def kingraph_write_file_format
@ Get the particle name from the [[particle]] array of the
[[feyngraph_set]]. This is needed for the phs file creation.
<<Cascades2: procedures>>=
function get_particle_name (feyngraph_set, pdg) result (particle_name)
type (feyngraph_set_t), intent (in) :: feyngraph_set
integer, intent (in) :: pdg
character (len=LABEL_LEN) :: particle_name
integer :: i
do i=1, size (feyngraph_set%particle)
if (feyngraph_set%particle(i)%pdg == pdg) then
particle_name = feyngraph_set%particle(i)%particle_label
exit
end if
enddo
end function get_particle_name
@ %def get_particle_name
@
\subsection{Invert a graph}
All Feynman diagrams given by O'Mega look like a decay. The [[feyngraph]]
which is constructed from this output also looks like a decay, where one
of the incoming particles is the decaying particle (or the root of the
tree). The calculations can in principle be done on this data structure.
However, it is also performed with the other incoming particle as
the root. The first part of the calculation is the same for both cases.
For the second part we need to transform/turn the graphs such that the
other incoming particle becomes the root. This is done by identifying
the incoming particles from the O'Mega output (the first one is simply
the root of the existing tree, the second contains [2] in the
[[particle_label]]) and the nodes/particles which connect both incoming
particles (here we set [[t_line = .true.]]). At the same time we set the
pointers [[inverse_daughter1]] and [[inverse_daughter2]] for the
corresponding node, which point to the mother node and the other daughter
of the mother node; these will be the daughters of the node in the
inverted [[feyngraph]].
<<Cascades2: feyngraph: TBP>>=
procedure :: make_invertible => feyngraph_make_invertible
<<Cascades2: procedures>>=
subroutine feyngraph_make_invertible (feyngraph)
class (feyngraph_t), intent (inout) :: feyngraph
logical :: t_line_found
feyngraph%root%incoming = .true.
t_line_found = .false.
if (associated (feyngraph%root%daughter1)) then
call f_node_t_line_check (feyngraph%root%daughter1, t_line_found)
if (.not. t_line_found) then
if (associated (feyngraph%root%daughter2)) then
call f_node_t_line_check (feyngraph%root%daughter2, t_line_found)
end if
end if
end if
contains
<<k node t line check>>
end subroutine feyngraph_make_invertible
@ %def feyngraph_make_invertible
@ Check if a node has to be [[t_line]] or [[incoming]] and assign
inverse daughter pointers.
<<k node t line check>>=
recursive subroutine f_node_t_line_check (node, t_line_found)
type (f_node_t), target, intent (inout) :: node
integer :: pos
logical, intent (inout) :: t_line_found
if (associated (node%daughter1)) then
call f_node_t_line_check (node%daughter1, t_line_found)
if (node%daughter1%incoming .or. node%daughter1%t_line) then
node%t_line = .true.
else if (associated (node%daughter2)) then
call f_node_t_line_check (node%daughter2, t_line_found)
if (node%daughter2%incoming .or. node%daughter2%t_line) then
node%t_line = .true.
end if
end if
else
pos = index (node%particle_label, '[') + 1
if (node%particle_label(pos:pos) == '2') then
node%incoming = .true.
t_line_found = .true.
end if
end if
end subroutine f_node_t_line_check
@ %def k_node_t_line_check
@ Make an inverted copy of a [[kingraph]] using the inverse daughter
pointers.
<<Cascades2: kingraph: TBP>>=
procedure :: make_inverse_copy => kingraph_make_inverse_copy
<<Cascades2: procedures>>=
subroutine kingraph_make_inverse_copy (original_kingraph, feyngraph)
class (kingraph_t), intent (inout) :: original_kingraph
type (feyngraph_t), intent (inout) :: feyngraph
type (kingraph_t), pointer :: kingraph_copy
type (k_node_t), pointer :: potential_root
allocate (kingraph_copy)
if (associated (feyngraph%kin_last)) then
allocate (feyngraph%kin_last%next)
feyngraph%kin_last => feyngraph%kin_last%next
else
allocate(feyngraph%kin_first)
feyngraph%kin_last => feyngraph%kin_first
end if
kingraph_copy => feyngraph%kin_last
call kingraph_set_inverse_daughters (original_kingraph)
kingraph_copy%inverse = .true.
kingraph_copy%n_nodes = original_kingraph%n_nodes
kingraph_copy%keep = original_kingraph%keep
potential_root => original_kingraph%root
do while (.not. potential_root%incoming .or. &
(associated (potential_root%daughter1) .and. associated (potential_root%daughter2)))
if (potential_root%daughter1%incoming .or. potential_root%daughter1%t_line) then
potential_root => potential_root%daughter1
else if (potential_root%daughter2%incoming .or. potential_root%daughter2%t_line) then
potential_root => potential_root%daughter2
end if
enddo
call node_inverse_deep_copy (potential_root, kingraph_copy%root)
end subroutine kingraph_make_inverse_copy
@ %def kingraph_make_inverse_copy
@ Recursively deep-copy nodes, but along the t-line the inverse daughters
become the new daughters. We need a deep copy only for the [[incoming]]
or [[t_line]] nodes. For the other nodes (of s-channel subgraphs) we set
only pointers to the existing nodes of the non-inverted graph.
<<Cascades2: procedures>>=
recursive subroutine node_inverse_deep_copy (original_node, node_copy)
type (k_node_t), intent (in) :: original_node
type (k_node_t), pointer, intent (out) :: node_copy
call original_node%f_node%k_node_list%add_entry(node_copy, recycle=.false.)
node_copy = original_node
if (node_copy%t_line .or. node_copy%incoming) then
node_copy%particle => original_node%particle%anti
else
node_copy%particle => original_node%particle
end if
if (associated (original_node%inverse_daughter1) .and. associated (original_node%inverse_daughter2)) then
if (original_node%inverse_daughter1%incoming .or. original_node%inverse_daughter1%t_line) then
node_copy%daughter2 => original_node%inverse_daughter2
call node_inverse_deep_copy (original_node%inverse_daughter1, &
node_copy%daughter1)
else if (original_node%inverse_daughter2%incoming .or. original_node%inverse_daughter2%t_line) then
node_copy%daughter1 => original_node%inverse_daughter1
call node_inverse_deep_copy (original_node%inverse_daughter2, &
node_copy%daughter2)
end if
end if
end subroutine node_inverse_deep_copy
@ %def node_inverse_deep_copy
@
\subsection{Find phase-space parametrizations}
Perform all mapping calculations for a single process and store valid
[[kingraphs]] (channels) into the grove list, without caring for instance
about the resonance hash values.
<<Cascades2: public>>=
public :: feyngraph_set_generate_single
<<Cascades2: procedures>>=
subroutine feyngraph_set_generate_single (feyngraph_set, model, n_in, n_out, &
phs_par, fatal_beam_decay, u_in)
type(feyngraph_set_t), intent(inout) :: feyngraph_set
type(model_data_t), target, intent(in) :: model
integer, intent(in) :: n_in, n_out
type(phs_parameters_t), intent(in) :: phs_par
logical, intent(in) :: fatal_beam_decay
integer, intent(in) :: u_in
feyngraph_set%n_in = n_in
feyngraph_set%n_out = n_out
feyngraph_set%process_type = n_in
feyngraph_set%phs_par = phs_par
feyngraph_set%model => model
if (debug_on) call msg_debug (D_PHASESPACE, "Construct relevant Feynman diagrams from Omega output")
call feyngraph_set%build (u_in)
if (debug_on) call msg_debug (D_PHASESPACE, "Find phase-space parametrizations")
call feyngraph_set_find_phs_parametrizations(feyngraph_set)
end subroutine feyngraph_set_generate_single
@ %def feyngraph_set_generate_single
@ Find the phase space parametrizations. We start with the computation
of pure s-channel subtrees, i.e. we determine mappings and compare
subtrees in order to reduce the number of channels. This can be
parallelized easily. When all s-channel [[k_nodes]] exist, the possible
[[kingraphs]] are created using these nodes and we determine mappings for
t-channel nodes.
<<Cascades2: procedures>>=
subroutine feyngraph_set_find_phs_parametrizations (feyngraph_set)
class (feyngraph_set_t), intent (inout) :: feyngraph_set
type (feyngraph_t), pointer :: current => null ()
type (feyngraph_ptr_t), dimension (:), allocatable :: set
integer :: pos
integer :: i
allocate (set (feyngraph_set%n_graphs))
pos = 0
current => feyngraph_set%first
do while (associated (current))
pos = pos + 1
set(pos)%graph => current
current => current%next
enddo
if (feyngraph_set%process_type == SCATTERING) then
!$OMP PARALLEL DO
do i=1, feyngraph_set%n_graphs
if (set(i)%graph%keep) then
call set(i)%graph%make_invertible ()
end if
enddo
!$OMP END PARALLEL DO
end if
call f_node_list_compute_mappings_s (feyngraph_set)
do i=1, feyngraph_set%n_graphs
if (set(i)%graph%keep) then
call set(i)%graph%make_kingraphs (feyngraph_set)
end if
enddo
if (feyngraph_set%process_type == SCATTERING) then
do i=1, feyngraph_set%n_graphs
if (set(i)%graph%keep) then
call set(i)%graph%make_inverse_kingraphs ()
end if
enddo
end if
do i=1, feyngraph_set%n_graphs
if (set(i)%graph%keep) then
call set(i)%graph%compute_mappings (feyngraph_set)
end if
enddo
do i=1, feyngraph_set%n_graphs
if (set(i)%graph%keep) then
call feyngraph_set%grove_list%add_feyngraph (set(i)%graph, &
feyngraph_set%model)
end if
enddo
end subroutine feyngraph_set_find_phs_parametrizations
@ %def feyngraph_set_find_phs_parametrizations
@ Compare objects of type [[tree_t]].
<<Cascades2: interfaces>>=
interface operator (==)
module procedure tree_equal
end interface operator (==)
<<Cascades2: procedures>>=
elemental function tree_equal (tree1, tree2) result (flag)
type (tree_t), intent (in) :: tree1, tree2
logical :: flag
if (tree1%n_entries == tree2%n_entries) then
if (tree1%bc(size(tree1%bc)) == tree2%bc(size(tree2%bc))) then
flag = all (tree1%mapping == tree2%mapping) .and. &
all (tree1%bc == tree2%bc) .and. &
all (abs(tree1%pdg) == abs(tree2%pdg))
else
flag = .false.
end if
else
flag = .false.
end if
end function tree_equal
@ %def tree_equal
@ Select between equivalent subtrees (type [[tree_t]]). This is similar
to [[kingraph_select]], but we compare only positions with mappings
[[NONRESONANT]] and [[NO_MAPPING]].
<<Cascades2: interfaces>>=
interface operator (.eqv.)
module procedure subtree_eqv
end interface operator (.eqv.)
<<Cascades2: procedures>>=
pure function subtree_eqv (subtree1, subtree2) result (eqv)
type (tree_t), intent (in) :: subtree1, subtree2
logical :: eqv
integer :: root_pos
integer :: i
logical :: equal
eqv = .false.
if (subtree1%n_entries /= subtree2%n_entries) return
root_pos = subtree1%n_entries
if (subtree1%mapping(root_pos) == NONRESONANT .or. &
subtree2%mapping(root_pos) == NONRESONANT .or. &
(subtree1%mapping(root_pos) == NO_MAPPING .and. &
subtree2%mapping(root_pos) == NO_MAPPING .and. &
abs(subtree1%pdg(root_pos)) == abs(subtree2%pdg(root_pos)))) then
do i = subtree1%n_entries, 1, -1
if (subtree1%bc(i) /= subtree2%bc(i)) return
enddo
equal = .true.
do i = subtree1%n_entries, 1, -1
if (abs(subtree1%pdg(i)) /= abs (subtree2%pdg(i))) then
select case (subtree1%mapping(i))
case (NO_MAPPING, NONRESONANT)
select case (subtree2%mapping(i))
case (NO_MAPPING, NONRESONANT)
equal = .false.
case default
return
end select
case default
return
end select
end if
enddo
do i = subtree1%n_entries, 1, -1
if (subtree1%mapping(i) /= subtree2%mapping(i)) then
select case (subtree1%mapping(i))
case (NO_MAPPING, NONRESONANT)
select case (subtree2%mapping(i))
case (NO_MAPPING, NONRESONANT)
case default
return
end select
case default
return
end select
end if
enddo
if (.not. equal) eqv = .true.
end if
end function subtree_eqv
@ %def subtree_eqv
<<Cascades2: procedures>>=
subroutine subtree_select (subtree1, subtree2, model)
type (tree_t), intent (inout) :: subtree1, subtree2
type (model_data_t), intent (in) :: model
integer :: j, k
integer(TC), dimension(:), allocatable :: tmp_bc, daughter_bc
integer, dimension(:), allocatable :: tmp_pdg, daughter_pdg
integer, dimension (:), allocatable :: pdg_match
if (subtree1 .eqv. subtree2) then
do j=1, subtree1%n_entries
if (abs(subtree1%pdg(j)) /= abs(subtree2%pdg(j))) then
tmp_bc = subtree1%bc(:j-1); tmp_pdg = subtree1%pdg(:j-1)
do k=j-1, 1, - 1
where (iand (tmp_bc(:k-1),tmp_bc(k)) /= 0 &
.or. iand(tmp_bc(:k-1),subtree1%bc(j)) == 0)
tmp_bc(:k-1) = 0
tmp_pdg(:k-1) = 0
endwhere
enddo
daughter_bc = pack (tmp_bc, tmp_bc /= 0)
daughter_pdg = pack (tmp_pdg, tmp_pdg /= 0)
if (size (daughter_pdg) == 2) then
call model%match_vertex(daughter_pdg(1), daughter_pdg(2), pdg_match)
if (.not. allocated (pdg_match)) then
!!! Relevant if tree contains only abs (pdg). In this case, changing the
!!! sign of one of the pdg codes should give a result.
call model%match_vertex(-daughter_pdg(1), daughter_pdg(2), pdg_match)
end if
end if
do k=1, size (pdg_match)
if (abs(pdg_match(k)) == abs(subtree1%pdg(j))) then
if (subtree1%keep) subtree2%keep = .false.
exit
else if (abs(pdg_match(k)) == abs(subtree2%pdg(j))) then
if (subtree2%keep) subtree1%keep = .false.
exit
end if
enddo
deallocate (tmp_bc, tmp_pdg, daughter_bc, daughter_pdg, pdg_match)
if (.not. (subtree1%keep .and. subtree2%keep)) exit
end if
enddo
end if
end subroutine subtree_select
@ %def subtree_select
@ Assign a resonance hash value to a [[kingraph]], like in [[cascades]],
but here without the array [[tree_resonant]].
<<Cascades2: kingraph: TBP>>=
procedure :: assign_resonance_hash => kingraph_assign_resonance_hash
<<Cascades2: procedures>>=
subroutine kingraph_assign_resonance_hash (kingraph)
class (kingraph_t), intent (inout) :: kingraph
logical, dimension (:), allocatable :: tree_resonant
integer(i8), dimension(1) :: mold
allocate (tree_resonant (kingraph%tree%n_entries))
tree_resonant = (kingraph%tree%mapping == S_CHANNEL)
kingraph%grove_prop%res_hash = hash (transfer &
([sort (pack (kingraph%tree%pdg, tree_resonant)), &
sort (pack (abs (kingraph%tree%pdg), &
kingraph%tree%mapping == T_CHANNEL .or. &
kingraph%tree%mapping == U_CHANNEL))], mold))
deallocate (tree_resonant)
end subroutine kingraph_assign_resonance_hash
@ %def kingraph_assign_resonance_hash
@ Write the process in the bincode format. This is again a copy of the
corresponding procedure in [[cascades]], using [[feyngraph_set]] instead
of [[cascade_set]] as an argument.
<<Cascades2: public>>=
public :: feyngraph_set_write_process_bincode_format
<<Cascades2: procedures>>=
subroutine feyngraph_set_write_process_bincode_format (feyngraph_set, unit)
type(feyngraph_set_t), intent(in), target :: feyngraph_set
integer, intent(in), optional :: unit
integer, dimension(:), allocatable :: bincode, field_width
integer :: n_in, n_out, n_tot, n_flv
integer :: u, f, i, bc
character(20) :: str
type(string_t) :: fmt_head
type(string_t), dimension(:), allocatable :: fmt_proc
u = given_output_unit (unit); if (u < 0) return
if (.not. allocated (feyngraph_set%flv)) return
write (u, "('!',1x,A)") "List of subprocesses with particle bincodes:"
n_in = feyngraph_set%n_in
n_out = feyngraph_set%n_out
n_tot = n_in + n_out
n_flv = size (feyngraph_set%flv, 2)
allocate (bincode (n_tot), field_width (n_tot), fmt_proc (n_tot))
bc = 1
do i = 1, n_out
bincode(n_in + i) = bc
bc = 2 * bc
end do
do i = n_in, 1, -1
bincode(i) = bc
bc = 2 * bc
end do
do i = 1, n_tot
write (str, "(I0)") bincode(i)
field_width(i) = len_trim (str)
do f = 1, n_flv
field_width(i) = max (field_width(i), &
len (feyngraph_set%flv(i,f)%get_name ()))
end do
end do
fmt_head = "('!'"
do i = 1, n_tot
fmt_head = fmt_head // ",1x,"
fmt_proc(i) = "(1x,"
write (str, "(I0)") field_width(i)
fmt_head = fmt_head // "I" // trim(str)
fmt_proc(i) = fmt_proc(i) // "A" // trim(str)
if (i == n_in) then
fmt_head = fmt_head // ",1x,' '"
end if
end do
do i = 1, n_tot
fmt_proc(i) = fmt_proc(i) // ")"
end do
fmt_head = fmt_head // ")"
write (u, char (fmt_head)) bincode
do f = 1, n_flv
write (u, "('!')", advance="no")
do i = 1, n_tot
write (u, char (fmt_proc(i)), advance="no") &
char (feyngraph_set%flv(i,f)%get_name ())
if (i == n_in) write (u, "(1x,'=>')", advance="no")
end do
write (u, *)
end do
write (u, char (fmt_head)) bincode
end subroutine feyngraph_set_write_process_bincode_format
@ %def feyngraph_set_write_process_bincode_format
@ Write tex file for graphical display of channels.
<<Cascades2: public>>=
public :: feyngraph_set_write_graph_format
<<Cascades2: procedures>>=
subroutine feyngraph_set_write_graph_format (feyngraph_set, filename, process_id, unit)
type(feyngraph_set_t), intent(in), target :: feyngraph_set
type(string_t), intent(in) :: filename, process_id
integer, intent(in), optional :: unit
type(kingraph_t), pointer :: kingraph
type(grove_t), pointer :: grove
integer :: u, n_grove, count, pgcount
logical :: first_in_grove
u = given_output_unit (unit); if (u < 0) return
write (u, '(A)') "\documentclass[10pt]{article}"
write (u, '(A)') "\usepackage{amsmath}"
write (u, '(A)') "\usepackage{feynmp}"
write (u, '(A)') "\usepackage{url}"
write (u, '(A)') "\usepackage{color}"
write (u, *)
write (u, '(A)') "\textwidth 18.5cm"
write (u, '(A)') "\evensidemargin -1.5cm"
write (u, '(A)') "\oddsidemargin -1.5cm"
write (u, *)
write (u, '(A)') "\newcommand{\blue}{\color{blue}}"
write (u, '(A)') "\newcommand{\green}{\color{green}}"
write (u, '(A)') "\newcommand{\red}{\color{red}}"
write (u, '(A)') "\newcommand{\magenta}{\color{magenta}}"
write (u, '(A)') "\newcommand{\cyan}{\color{cyan}}"
write (u, '(A)') "\newcommand{\sm}{\footnotesize}"
write (u, '(A)') "\setlength{\parindent}{0pt}"
write (u, '(A)') "\setlength{\parsep}{20pt}"
write (u, *)
write (u, '(A)') "\begin{document}"
write (u, '(A)') "\begin{fmffile}{" // char (filename) // "}"
write (u, '(A)') "\fmfcmd{color magenta; magenta = red + blue;}"
write (u, '(A)') "\fmfcmd{color cyan; cyan = green + blue;}"
write (u, '(A)') "\begin{fmfshrink}{0.5}"
write (u, '(A)') "\begin{flushleft}"
write (u, *)
write (u, '(A)') "\noindent" // &
& "\textbf{\large\texttt{WHIZARD} phase space channels}" // &
& "\hfill\today"
write (u, *)
write (u, '(A)') "\vspace{10pt}"
write (u, '(A)') "\noindent" // &
& "\textbf{Process:} \url{" // char (process_id) // "}"
call feyngraph_set_write_process_tex_format (feyngraph_set, u)
write (u, *)
write (u, '(A)') "\noindent" // &
& "\textbf{Note:} These are pseudo Feynman graphs that "
write (u, '(A)') "visualize phase-space parameterizations " // &
& "(``integration channels''). "
write (u, '(A)') "They do \emph{not} indicate Feynman graphs used for the " // &
& "matrix element."
write (u, *)
write (u, '(A)') "\textbf{Color code:} " // &
& "{\blue resonance,} " // &
& "{\cyan t-channel,} " // &
& "{\green radiation,} "
write (u, '(A)') "{\red infrared,} " // &
& "{\magenta collinear,} " // &
& "external/off-shell"
write (u, *)
write (u, '(A)') "\noindent" // &
& "\textbf{Black square:} Keystone, indicates ordering of " // &
& "phase space parameters."
write (u, *)
write (u, '(A)') "\vspace{-20pt}"
count = 0
pgcount = 0
n_grove = 0
grove => feyngraph_set%grove_list%first
do while (associated (grove))
n_grove = n_grove + 1
write (u, *)
write (u, '(A)') "\vspace{20pt}"
write (u, '(A)') "\begin{tabular}{l}"
write (u, '(A,I5,A)') &
& "\fbox{\bf Grove \boldmath$", n_grove, "$} \\[10pt]"
write (u, '(A,I1,A)') "Multiplicity: ", &
grove%grove_prop%multiplicity, "\\"
write (u, '(A,I1,A)') "Resonances: ", &
grove%grove_prop%n_resonances, "\\"
write (u, '(A,I1,A)') "Log-enhanced: ", &
grove%grove_prop%n_log_enhanced, "\\"
write (u, '(A,I1,A)') "Off-shell: ", &
grove%grove_prop%n_off_shell, "\\"
write (u, '(A,I1,A)') "t-channel: ", &
grove%grove_prop%n_t_channel, ""
write (u, '(A)') "\end{tabular}"
kingraph => grove%first
do while (associated (kingraph))
count = count + 1
call kingraph_write_graph_format (kingraph, count, unit)
kingraph => kingraph%grove_next
enddo
grove => grove%next
enddo
write (u, '(A)') "\end{flushleft}"
write (u, '(A)') "\end{fmfshrink}"
write (u, '(A)') "\end{fmffile}"
write (u, '(A)') "\end{document}"
end subroutine feyngraph_set_write_graph_format
@ %def feyngraph_set_write_graph_format
@ Write the process as a \LaTeX\ expression. This is a slightly modified
copy of [[cascade_set_write_process_tex_format]] which has only been
adapted to the types which are used here.
<<Cascades2: procedures>>=
subroutine feyngraph_set_write_process_tex_format (feyngraph_set, unit)
type(feyngraph_set_t), intent(in), target :: feyngraph_set
integer, intent(in), optional :: unit
integer :: n_tot
integer :: u, f, i
n_tot = feyngraph_set%n_in + feyngraph_set%n_out
u = given_output_unit (unit); if (u < 0) return
if (.not. allocated (feyngraph_set%flv)) return
write (u, "(A)") "\begin{align*}"
do f = 1, size (feyngraph_set%flv, 2)
do i = 1, feyngraph_set%n_in
if (i > 1) write (u, "(A)", advance="no") "\quad "
write (u, "(A)", advance="no") &
char (feyngraph_set%flv(i,f)%get_tex_name ())
end do
write (u, "(A)", advance="no") "\quad &\to\quad "
do i = feyngraph_set%n_in + 1, n_tot
if (i > feyngraph_set%n_in + 1) write (u, "(A)", advance="no") "\quad "
write (u, "(A)", advance="no") &
char (feyngraph_set%flv(i,f)%get_tex_name ())
end do
if (f < size (feyngraph_set%flv, 2)) then
write (u, "(A)") "\\"
else
write (u, "(A)") ""
end if
end do
write (u, "(A)") "\end{align*}"
end subroutine feyngraph_set_write_process_tex_format
@ %def feyngraph_set_write_process_tex_format
@ This creates metapost source for graphical display for a given [[kingraph]].
It is the analogon to [[cascade_write_graph_format]] (a modified copy).
<<Cascades2: procedures>>=
subroutine kingraph_write_graph_format (kingraph, count, unit)
type(kingraph_t), intent(in) :: kingraph
integer, intent(in) :: count
integer, intent(in), optional :: unit
integer :: u
type(string_t) :: left_str, right_str
u = given_output_unit (unit); if (u < 0) return
left_str = ""
right_str = ""
write (u, '(A)') "\begin{minipage}{105pt}"
write (u, '(A)') "\vspace{30pt}"
write (u, '(A)') "\begin{center}"
write (u, '(A)') "\begin{fmfgraph*}(55,55)"
call graph_write_node (kingraph%root)
write (u, '(A)') "\fmfleft{" // char (extract (left_str, 2)) // "}"
write (u, '(A)') "\fmfright{" // char (extract (right_str, 2)) // "}"
write (u, '(A)') "\end{fmfgraph*}\\"
write (u, '(A,I5,A)') "\fbox{$", count, "$}"
write (u, '(A)') "\end{center}"
write (u, '(A)') "\end{minipage}"
write (u, '(A)') "%"
contains
recursive subroutine graph_write_node (node)
type(k_node_t), intent(in) :: node
if (associated (node%daughter1) .or. associated (node%daughter2)) then
if (node%daughter2%t_line .or. node%daughter2%incoming) then
call vertex_write (node, node%daughter2)
call vertex_write (node, node%daughter1)
else
call vertex_write (node, node%daughter1)
call vertex_write (node, node%daughter2)
end if
if (node%mapping == EXTERNAL_PRT) then
call line_write (node%bincode, 0, node%particle)
call external_write (node%bincode, node%particle%tex_name, &
left_str)
write (u, '(A,I0,A)') "\fmfv{d.shape=square}{v0}"
end if
else
if (node%incoming) then
call external_write (node%bincode, node%particle%anti%tex_name, &
left_str)
else
call external_write (node%bincode, node%particle%tex_name, &
right_str)
end if
end if
end subroutine graph_write_node
recursive subroutine vertex_write (node, daughter)
type(k_node_t), intent(in) :: node, daughter
integer :: bincode
if (associated (node%daughter1) .and. associated (node%daughter2) &
.and. node%mapping == EXTERNAL_PRT) then
bincode = 0
else
bincode = node%bincode
end if
call graph_write_node (daughter)
if (associated (node%daughter1) .or. associated (node%daughter2)) then
call line_write (bincode, daughter%bincode, daughter%particle, &
mapping=daughter%mapping)
else
call line_write (bincode, daughter%bincode, daughter%particle)
end if
end subroutine vertex_write
subroutine line_write (i1, i2, particle, mapping)
integer(TC), intent(in) :: i1, i2
type(part_prop_t), intent(in) :: particle
integer, intent(in), optional :: mapping
integer :: k1, k2
type(string_t) :: prt_type
select case (particle%spin_type)
case (SCALAR); prt_type = "plain"
case (SPINOR); prt_type = "fermion"
case (VECTOR); prt_type = "boson"
case (VECTORSPINOR); prt_type = "fermion"
case (TENSOR); prt_type = "dbl_wiggly"
case default; prt_type = "dashes"
end select
if (particle%pdg < 0) then
!!! anti-particle
k1 = i2; k2 = i1
else
k1 = i1; k2 = i2
end if
if (present (mapping)) then
select case (mapping)
case (S_CHANNEL)
write (u, '(A,I0,A,I0,A)') "\fmf{" // char (prt_type) // &
& ",f=blue,lab=\sm\blue$" // &
& char (particle%tex_name) // "$}" // &
& "{v", k1, ",v", k2, "}"
case (T_CHANNEL, U_CHANNEL)
write (u, '(A,I0,A,I0,A)') "\fmf{" // char (prt_type) // &
& ",f=cyan,lab=\sm\cyan$" // &
& char (particle%tex_name) // "$}" // &
& "{v", k1, ",v", k2, "}"
case (RADIATION)
write (u, '(A,I0,A,I0,A)') "\fmf{" // char (prt_type) // &
& ",f=green,lab=\sm\green$" // &
& char (particle%tex_name) // "$}" // &
& "{v", k1, ",v", k2, "}"
case (COLLINEAR)
write (u, '(A,I0,A,I0,A)') "\fmf{" // char (prt_type) // &
& ",f=magenta,lab=\sm\magenta$" // &
& char (particle%tex_name) // "$}" // &
& "{v", k1, ",v", k2, "}"
case (INFRARED)
write (u, '(A,I0,A,I0,A)') "\fmf{" // char (prt_type) // &
& ",f=red,lab=\sm\red$" // &
& char (particle%tex_name) // "$}" // &
& "{v", k1, ",v", k2, "}"
case default
write (u, '(A,I0,A,I0,A)') "\fmf{" // char (prt_type) // &
& ",f=black}" // &
& "{v", k1, ",v", k2, "}"
end select
else
write (u, '(A,I0,A,I0,A)') "\fmf{" // char (prt_type) // &
& "}" // &
& "{v", k1, ",v", k2, "}"
end if
end subroutine line_write
subroutine external_write (bincode, name, ext_str)
integer(TC), intent(in) :: bincode
type(string_t), intent(in) :: name
type(string_t), intent(inout) :: ext_str
character(len=20) :: str
write (str, '(A2,I0)') ",v", bincode
ext_str = ext_str // trim (str)
write (u, '(A,I0,A,I0,A)') "\fmflabel{\sm$" &
// char (name) &
// "\,(", bincode, ")" &
// "$}{v", bincode, "}"
end subroutine external_write
end subroutine kingraph_write_graph_format
@ %def kingraph_write_graph_format
@ Generate a [[feyngraph_set]] for several subprocesses. Mapping
calculations are performed separately, but the final grove list is shared
between the subsets [[fset]] of the [[feyngraph_set]].
<<Cascades2: public>>=
public :: feyngraph_set_generate
<<Cascades2: procedures>>=
subroutine feyngraph_set_generate &
(feyngraph_set, model, n_in, n_out, flv, phs_par, fatal_beam_decay, &
u_in, vis_channels, use_dag)
type(feyngraph_set_t), intent(out) :: feyngraph_set
class(model_data_t), intent(in), target :: model
integer, intent(in) :: n_in, n_out
type(flavor_t), dimension(:,:), intent(in) :: flv
type(phs_parameters_t), intent(in) :: phs_par
logical, intent(in) :: fatal_beam_decay
integer, intent(in) :: u_in
logical, intent(in) :: vis_channels
logical, optional, intent(in) :: use_dag
type(grove_t), pointer :: grove
integer :: i, j
type(kingraph_t), pointer :: kingraph
if (phase_space_vanishes (phs_par%sqrts, n_in, flv)) return
if (present (use_dag)) feyngraph_set%use_dag = use_dag
feyngraph_set%process_type = n_in
feyngraph_set%n_in = n_in
feyngraph_set%n_out = n_out
allocate (feyngraph_set%flv (size (flv, 1), size (flv, 2)))
do i = 1, size (flv, 2)
do j = 1, size (flv, 1)
call feyngraph_set%flv(j,i)%init (flv(j,i)%get_pdg (), model)
end do
end do
allocate (feyngraph_set%particle (PRT_ARRAY_SIZE))
allocate (feyngraph_set%grove_list)
allocate (feyngraph_set%fset (size (flv, 2)))
do i = 1, size (feyngraph_set%fset)
feyngraph_set%fset(i)%use_dag = feyngraph_set%use_dag
allocate (feyngraph_set%fset(i)%flv(size (flv,1),1))
feyngraph_set%fset(i)%flv(:,1) = flv(:,i)
feyngraph_set%fset(i)%particle => feyngraph_set%particle
allocate (feyngraph_set%fset(i)%grove_list)
call feyngraph_set_generate_single (feyngraph_set%fset(i), &
model, n_in, n_out, phs_par, fatal_beam_decay, u_in)
call feyngraph_set%grove_list%merge (feyngraph_set%fset(i)%grove_list, model, i)
if (.not. vis_channels) call feyngraph_set%fset(i)%final()
enddo
call feyngraph_set%grove_list%rebuild ()
end subroutine feyngraph_set_generate
@ %def feyngraph_set_generate
@ Check whether the [[grove_list]] of the [[feyngraph_set]] contains any
[[kingraphs]] which are valid, i.e. where the [[keep]] variable has the
value [[.true.]]. This is necessary to write a non-empty phase-space
file. The function is the pendant to [[cascade_set_is_valid]].
<<Cascades2: public>>=
public :: feyngraph_set_is_valid
<<Cascades2: procedures>>=
function feyngraph_set_is_valid (feyngraph_set) result (flag)
class (feyngraph_set_t), intent(in) :: feyngraph_set
type (kingraph_t), pointer :: kingraph
type (grove_t), pointer :: grove
logical :: flag
flag = .false.
if (associated (feyngraph_set%grove_list)) then
grove => feyngraph_set%grove_list%first
do while (associated (grove))
kingraph => grove%first
do while (associated (kingraph))
if (kingraph%keep) then
flag = .true.
return
end if
kingraph => kingraph%next
enddo
grove => grove%next
enddo
end if
end function feyngraph_set_is_valid
@ %def feyngraph_set_is_valid
@
\subsection{Return the resonance histories for subtraction}
The following procedures are copies of corresponding procedures in
[[cascades]], which only have been adapted to the new types used in
this module.\\
Extract the resonance set from a valid [[kingraph]] which is kept in the
final grove list.
<<Cascades2: kingraph: TBP>>=
procedure :: extract_resonance_history => kingraph_extract_resonance_history
<<Cascades2: procedures>>=
subroutine kingraph_extract_resonance_history &
(kingraph, res_hist, model, n_out)
class(kingraph_t), intent(in), target :: kingraph
type(resonance_history_t), intent(out) :: res_hist
class(model_data_t), intent(in), target :: model
integer, intent(in) :: n_out
type(resonance_info_t) :: resonance
integer :: i, mom_id, pdg
if (debug_on) call msg_debug2 (D_PHASESPACE, "kingraph_extract_resonance_history")
if (kingraph%grove_prop%n_resonances > 0) then
if (associated (kingraph%root%daughter1) .or. &
associated (kingraph%root%daughter2)) then
if (debug_on) call msg_debug2 (D_PHASESPACE, "kingraph has resonances, root has children")
do i = 1, kingraph%tree%n_entries
if (kingraph%tree%mapping(i) == S_CHANNEL) then
mom_id = kingraph%tree%bc (i)
pdg = kingraph%tree%pdg (i)
call resonance%init (mom_id, pdg, model, n_out)
if (debug2_active (D_PHASESPACE)) then
print *, 'D: Adding resonance'
call resonance%write ()
end if
call res_hist%add_resonance (resonance)
end if
end do
end if
end if
end subroutine kingraph_extract_resonance_history
@ %def kingraph_extract_resonance_history
@ Determine the number of valid [[kingraphs]] in [[grove_list]].
<<Cascades2: public>>=
public :: grove_list_get_n_trees
<<Cascades2: procedures>>=
function grove_list_get_n_trees (grove_list) result (n)
class (grove_list_t), intent (in) :: grove_list
integer :: n
type(kingraph_t), pointer :: kingraph
type(grove_t), pointer :: grove
if (debug_on) call msg_debug (D_PHASESPACE, "grove_list_get_n_trees")
n = 0
grove => grove_list%first
do while (associated (grove))
kingraph => grove%first
do while (associated (kingraph))
if (kingraph%keep) n = n + 1
kingraph => kingraph%grove_next
enddo
grove => grove%next
enddo
if (debug_on) call msg_debug (D_PHASESPACE, "n", n)
end function grove_list_get_n_trees
@ %def grove_list_get_n_trees
@ Extract the resonance histories from the [[feyngraph_set]], in complete
analogy to [[cascade_set_get_resonance_histories]]
<<Cascades2: public>>=
public :: feyngraph_set_get_resonance_histories
<<Cascades2: procedures>>=
subroutine feyngraph_set_get_resonance_histories (feyngraph_set, n_filter, res_hists)
type(feyngraph_set_t), intent(in), target :: feyngraph_set
integer, intent(in), optional :: n_filter
type(resonance_history_t), dimension(:), allocatable, intent(out) :: res_hists
type(kingraph_t), pointer :: kingraph
type(grove_t), pointer :: grove
type(resonance_history_t) :: res_hist
type(resonance_history_set_t) :: res_hist_set
integer :: i_grove
if (debug_on) call msg_debug (D_PHASESPACE, "grove_list_get_resonance_histories")
call res_hist_set%init (n_filter = n_filter)
grove => feyngraph_set%grove_list%first
i_grove = 0
do while (associated (grove))
i_grove = i_grove + 1
kingraph => grove%first
do while (associated (kingraph))
if (kingraph%keep) then
if (debug_on) call msg_debug2 (D_PHASESPACE, "grove", i_grove)
call kingraph%extract_resonance_history &
(res_hist, feyngraph_set%model, feyngraph_set%n_out)
call res_hist_set%enter (res_hist)
end if
kingraph => kingraph%grove_next
end do
end do
call res_hist_set%freeze ()
call res_hist_set%to_array (res_hists)
end subroutine feyngraph_set_get_resonance_histories
@ %def feyngraph_set_get_resonance_histories
<<[[cascades2_ut.f90]]>>=
<<File header>>
module cascades2_ut
use unit_tests
use cascades2_uti
<<Standard module head>>
<<Cascades2: public test>>
contains
<<Cascades2: test driver>>
end module cascades2_ut
@ %def cascades2_ut
@
<<[[cascades2_uti.f90]]>>=
<<File header>>
module cascades2_uti
<<Use kinds>>
<<Use strings>>
use numeric_utils
use cascades2
use flavors
use phs_forests, only: phs_parameters_t
use model_data
<<Standard module head>>
<<Cascades2: test declarations>>
contains
<<Cascades2: tests>>
end module cascades2_uti
@ %def cascades2_uti
@ API: driver for the unit tests below.
<<Cascades2: public test>>=
public :: cascades2_test
<<Cascades2: test driver>>=
subroutine cascades2_test (u, results)
integer, intent(in) :: u
type(test_results_t), intent(inout) :: results
<<Cascades2: execute tests>>
end subroutine cascades2_test
@ %def cascades2_test
@
<<Cascades2: execute tests>>=
call test (cascades2_1, "cascades2_1", &
"make phase-space", u, results)
call test (cascades2_2, "cascades2_2", &
"make phase-space (scattering)", u, results)
<<Cascades2: test declarations>>=
public :: cascades2_1
<<Cascades2: tests>>=
subroutine cascades2_1 (u)
integer, intent(in) :: u
type (feyngraph_set_t) :: feyngraph_set
type (model_data_t) :: model
integer :: n_in = 1
integer :: n_out = 6
type(flavor_t), dimension(7,1) :: flv
type (phs_parameters_t) :: phs_par
logical :: fatal_beam_decay = .true.
integer :: u_in = 8
write (u, "(A)") "* Test output: cascades2_1"
write (u, "(A)") "* Purpose: create a test phs file (decay) with the forest"
write (u, "(A)") "* output of O'Mega"
write (u, "(A)")
write (u, "(A)") "* Initializing"
write (u, "(A)")
call init_sm_full_test (model)
call flv(1,1)%init (6, model)
call flv(2,1)%init (5, model)
call flv(3,1)%init (-11, model)
call flv(4,1)%init (12, model)
call flv(5,1)%init (21, model)
call flv(6,1)%init (22, model)
call flv(7,1)%init (21, model)
phs_par%sqrts = 173.1_default
phs_par%m_threshold_s = 50._default
phs_par%m_threshold_t = 100._default
phs_par%keep_nonresonant = .true.
phs_par%off_shell = 2
open (unit=u_in, file="cascades2_1.fds", status='old', action='read')
write (u, "(A)")
write (u, "(A)") "* Generating phase-space parametrizations"
write (u, "(A)")
call feyngraph_set_generate (feyngraph_set, model, n_in, n_out, &
flv, phs_par, fatal_beam_decay, u_in, use_dag = .false., &
vis_channels = .false.)
call feyngraph_set_write_process_bincode_format (feyngraph_set, u)
call feyngraph_set_write_file_format (feyngraph_set, u)
write (u, "(A)") "* Cleanup"
write (u, "(A)")
close (u_in)
call feyngraph_set%final ()
call model%final ()
write (u, *)
write (u, "(A)") "* Test output end: cascades2_1"
end subroutine cascades2_1
@ %def cascades2_1
@
<<Cascades2: test declarations>>=
public :: cascades2_2
<<Cascades2: tests>>=
subroutine cascades2_2 (u)
integer, intent(in) :: u
type (feyngraph_set_t) :: feyngraph_set
type (model_data_t) :: model
integer :: n_in = 2
integer :: n_out = 5
type(flavor_t), dimension(7,1) :: flv
type (phs_parameters_t) :: phs_par
logical :: fatal_beam_decay = .true.
integer :: u_in = 8
write (u, "(A)") "* Test output: cascades2_2"
write (u, "(A)") "* Purpose: create a test phs file (scattering) with the"
write (u, "(A)") "* parsable DAG output of O'Mega"
write (u, "(A)")
write (u, "(A)") "* Initializing"
write (u, "(A)")
call init_sm_full_test (model)
call flv(1,1)%init (-11, model)
call flv(2,1)%init (11, model)
call flv(3,1)%init (-11, model)
call flv(4,1)%init (12, model)
call flv(5,1)%init (1, model)
call flv(6,1)%init (-2, model)
call flv(7,1)%init (22, model)
phs_par%sqrts = 500._default
phs_par%m_threshold_s = 50._default
phs_par%m_threshold_t = 100._default
phs_par%keep_nonresonant = .true.
phs_par%off_shell = 2
phs_par%t_channel = 6
open (unit=u_in, file="cascades2_2.fds", &
status='old', action='read')
write (u, "(A)")
write (u, "(A)") "* Generating phase-space parametrizations"
write (u, "(A)")
call feyngraph_set_generate (feyngraph_set, model, n_in, n_out, &
flv, phs_par, fatal_beam_decay, u_in, use_dag = .true., &
vis_channels = .false.)
call feyngraph_set_write_process_bincode_format (feyngraph_set, u)
call feyngraph_set_write_file_format (feyngraph_set, u)
write (u, "(A)") "* Cleanup"
write (u, "(A)")
close (u_in)
call feyngraph_set%final ()
call model%final ()
write (u, *)
write (u, "(A)") "* Test output end: cascades2_2"
end subroutine cascades2_2
@ %def cascades2_2
Index: trunk/omega/src/omegalib.nw
===================================================================
--- trunk/omega/src/omegalib.nw (revision 8482)
+++ trunk/omega/src/omegalib.nw (revision 8483)
@@ -1,14215 +1,14261 @@
% -*- ess-noweb-default-code-mode: f90-mode; noweb-default-code-mode: f90-mode; -*-
% omegalib.nw --
%
% Copyright (C) 1999-2020 by
% Wolfgang Kilian <kilian@physik.uni-siegen.de>
% Thorsten Ohl <ohl@physik.uni-wuerzburg.de>
% Juergen Reuter <juergen.reuter@desy.de>
% with contributions from
% Fabian Bach <fabian.bach@t-online.de>
% Bijan Chokoufe Nejad <bijan.chokoufe@desy.de>
% Marco Sekulla <marco.sekulla@kit.edu>
% Christian Speckner <cnspeckn@googlemail.com>
%
% WHIZARD is free software; you can redistribute it and/or modify it
% under the terms of the GNU General Public License as published by
% the Free Software Foundation; either version 2, or (at your option)
% any later version.
%
% WHIZARD is distributed in the hope that it will be useful, but
% WITHOUT ANY WARRANTY; without even the implied warranty of
% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
% GNU General Public License for more details.
%
% You should have received a copy of the GNU General Public License
% along with this program; if not, write to the Free Software
% Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
@
\section{Trivia}
<<[[omega_spinors.f90]]>>=
<<Copyleft>>
module omega_spinors
use kinds
use constants
implicit none
private
public :: operator (*), operator (+), operator (-)
public :: abs, set_zero
<<[[intrinsic :: abs]]>>
type, public :: conjspinor
! private (omegalib needs access, but DON'T TOUCH IT!)
complex(kind=default), dimension(4) :: a
end type conjspinor
type, public :: spinor
! private (omegalib needs access, but DON'T TOUCH IT!)
complex(kind=default), dimension(4) :: a
end type spinor
<<Declaration of operations for spinors>>
integer, parameter, public :: omega_spinors_2010_01_A = 0
contains
<<Implementation of operations for spinors>>
end module omega_spinors
@
<<[[intrinsic :: abs]] (if working)>>=
intrinsic :: abs
@
<<[[intrinsic :: conjg]] (if working)>>=
intrinsic :: conjg
@ well, the Intel Fortran Compiler chokes on these with an internal error:
<<[[intrinsic :: abs]]>>=
@
<<[[intrinsic :: conjg]]>>=
@
To reenable the pure functions that have been removed for OpenMP, one
should set this chunk to [[pure &]]
<<[[pure]] unless OpenMP>>=
@
\subsection{Inner Product}
<<Declaration of operations for spinors>>=
interface operator (*)
module procedure conjspinor_spinor
end interface
private :: conjspinor_spinor
@
\begin{equation}
\bar\psi\psi'
\end{equation}
NB: [[dot_product]] conjugates its first argument, we can either
cancel this or inline [[dot_product]]:
<<Implementation of operations for spinors>>=
pure function conjspinor_spinor (psibar, psi) result (psibarpsi)
complex(kind=default) :: psibarpsi
type(conjspinor), intent(in) :: psibar
type(spinor), intent(in) :: psi
psibarpsi = psibar%a(1)*psi%a(1) + psibar%a(2)*psi%a(2) &
+ psibar%a(3)*psi%a(3) + psibar%a(4)*psi%a(4)
end function conjspinor_spinor
@
\subsection{Spinor Vector Space}
<<Declaration of operations for spinors>>=
interface set_zero
module procedure set_zero_spinor, set_zero_conjspinor
end interface
private :: set_zero_spinor, set_zero_conjspinor
@
<<Implementation of operations for spinors>>=
elemental subroutine set_zero_spinor (x)
type(spinor), intent(out) :: x
x%a = 0
end subroutine set_zero_spinor
@
<<Implementation of operations for spinors>>=
elemental subroutine set_zero_conjspinor (x)
type(conjspinor), intent(out) :: x
x%a = 0
end subroutine set_zero_conjspinor
@
\subsubsection{Scalar Multiplication}
<<Declaration of operations for spinors>>=
interface operator (*)
module procedure integer_spinor, spinor_integer, &
real_spinor, double_spinor, &
complex_spinor, dcomplex_spinor, &
spinor_real, spinor_double, &
spinor_complex, spinor_dcomplex
end interface
private :: integer_spinor, spinor_integer, real_spinor, &
double_spinor, complex_spinor, dcomplex_spinor, &
spinor_real, spinor_double, spinor_complex, spinor_dcomplex
@
<<Implementation of operations for spinors>>=
pure function integer_spinor (x, y) result (xy)
integer, intent(in) :: x
type(spinor), intent(in) :: y
type(spinor) :: xy
xy%a = x * y%a
end function integer_spinor
@
<<Implementation of operations for spinors>>=
pure function real_spinor (x, y) result (xy)
real(kind=single), intent(in) :: x
type(spinor), intent(in) :: y
type(spinor) :: xy
xy%a = x * y%a
end function real_spinor
pure function double_spinor (x, y) result (xy)
real(kind=default), intent(in) :: x
type(spinor), intent(in) :: y
type(spinor) :: xy
xy%a = x * y%a
end function double_spinor
pure function complex_spinor (x, y) result (xy)
complex(kind=single), intent(in) :: x
type(spinor), intent(in) :: y
type(spinor) :: xy
xy%a = x * y%a
end function complex_spinor
pure function dcomplex_spinor (x, y) result (xy)
complex(kind=default), intent(in) :: x
type(spinor), intent(in) :: y
type(spinor) :: xy
xy%a = x * y%a
end function dcomplex_spinor
pure function spinor_integer (y, x) result (xy)
integer, intent(in) :: x
type(spinor), intent(in) :: y
type(spinor) :: xy
xy%a = x * y%a
end function spinor_integer
pure function spinor_real (y, x) result (xy)
real(kind=single), intent(in) :: x
type(spinor), intent(in) :: y
type(spinor) :: xy
xy%a = x * y%a
end function spinor_real
pure function spinor_double (y, x) result (xy)
real(kind=default), intent(in) :: x
type(spinor), intent(in) :: y
type(spinor) :: xy
xy%a = x * y%a
end function spinor_double
pure function spinor_complex (y, x) result (xy)
complex(kind=single), intent(in) :: x
type(spinor), intent(in) :: y
type(spinor) :: xy
xy%a = x * y%a
end function spinor_complex
pure function spinor_dcomplex (y, x) result (xy)
complex(kind=default), intent(in) :: x
type(spinor), intent(in) :: y
type(spinor) :: xy
xy%a = x * y%a
end function spinor_dcomplex
@
<<Declaration of operations for spinors>>=
interface operator (*)
module procedure integer_conjspinor, conjspinor_integer, &
real_conjspinor, double_conjspinor, &
complex_conjspinor, dcomplex_conjspinor, &
conjspinor_real, conjspinor_double, &
conjspinor_complex, conjspinor_dcomplex
end interface
private :: integer_conjspinor, conjspinor_integer, real_conjspinor, &
double_conjspinor, complex_conjspinor, dcomplex_conjspinor, &
conjspinor_real, conjspinor_double, conjspinor_complex, &
conjspinor_dcomplex
@
<<Implementation of operations for spinors>>=
pure function integer_conjspinor (x, y) result (xy)
integer, intent(in) :: x
type(conjspinor), intent(in) :: y
type(conjspinor) :: xy
xy%a = x * y%a
end function integer_conjspinor
pure function real_conjspinor (x, y) result (xy)
real(kind=single), intent(in) :: x
type(conjspinor), intent(in) :: y
type(conjspinor) :: xy
xy%a = x * y%a
end function real_conjspinor
pure function double_conjspinor (x, y) result (xy)
real(kind=default), intent(in) :: x
type(conjspinor), intent(in) :: y
type(conjspinor) :: xy
xy%a = x * y%a
end function double_conjspinor
pure function complex_conjspinor (x, y) result (xy)
complex(kind=single), intent(in) :: x
type(conjspinor), intent(in) :: y
type(conjspinor) :: xy
xy%a = x * y%a
end function complex_conjspinor
pure function dcomplex_conjspinor (x, y) result (xy)
complex(kind=default), intent(in) :: x
type(conjspinor), intent(in) :: y
type(conjspinor) :: xy
xy%a = x * y%a
end function dcomplex_conjspinor
pure function conjspinor_integer (y, x) result (xy)
integer, intent(in) :: x
type(conjspinor), intent(in) :: y
type(conjspinor) :: xy
xy%a = x * y%a
end function conjspinor_integer
pure function conjspinor_real (y, x) result (xy)
real(kind=single), intent(in) :: x
type(conjspinor), intent(in) :: y
type(conjspinor) :: xy
xy%a = x * y%a
end function conjspinor_real
pure function conjspinor_double (y, x) result (xy)
real(kind=default), intent(in) :: x
type(conjspinor), intent(in) :: y
type(conjspinor) :: xy
xy%a = x * y%a
end function conjspinor_double
pure function conjspinor_complex (y, x) result (xy)
complex(kind=single), intent(in) :: x
type(conjspinor), intent(in) :: y
type(conjspinor) :: xy
xy%a = x * y%a
end function conjspinor_complex
pure function conjspinor_dcomplex (y, x) result (xy)
complex(kind=default), intent(in) :: x
type(conjspinor), intent(in) :: y
type(conjspinor) :: xy
xy%a = x * y%a
end function conjspinor_dcomplex
@
\subsubsection{Unary Plus and Minus}
<<Declaration of operations for spinors>>=
interface operator (+)
module procedure plus_spinor, plus_conjspinor
end interface
private :: plus_spinor, plus_conjspinor
interface operator (-)
module procedure neg_spinor, neg_conjspinor
end interface
private :: neg_spinor, neg_conjspinor
@
<<Implementation of operations for spinors>>=
pure function plus_spinor (x) result (plus_x)
type(spinor), intent(in) :: x
type(spinor) :: plus_x
plus_x%a = x%a
end function plus_spinor
pure function neg_spinor (x) result (neg_x)
type(spinor), intent(in) :: x
type(spinor) :: neg_x
neg_x%a = - x%a
end function neg_spinor
@
<<Implementation of operations for spinors>>=
pure function plus_conjspinor (x) result (plus_x)
type(conjspinor), intent(in) :: x
type(conjspinor) :: plus_x
plus_x%a = x%a
end function plus_conjspinor
pure function neg_conjspinor (x) result (neg_x)
type(conjspinor), intent(in) :: x
type(conjspinor) :: neg_x
neg_x%a = - x%a
end function neg_conjspinor
@
\subsubsection{Addition and Subtraction}
<<Declaration of operations for spinors>>=
interface operator (+)
module procedure add_spinor, add_conjspinor
end interface
private :: add_spinor, add_conjspinor
interface operator (-)
module procedure sub_spinor, sub_conjspinor
end interface
private :: sub_spinor, sub_conjspinor
@
<<Implementation of operations for spinors>>=
pure function add_spinor (x, y) result (xy)
type(spinor), intent(in) :: x, y
type(spinor) :: xy
xy%a = x%a + y%a
end function add_spinor
pure function sub_spinor (x, y) result (xy)
type(spinor), intent(in) :: x, y
type(spinor) :: xy
xy%a = x%a - y%a
end function sub_spinor
@
<<Implementation of operations for spinors>>=
pure function add_conjspinor (x, y) result (xy)
type(conjspinor), intent(in) :: x, y
type(conjspinor) :: xy
xy%a = x%a + y%a
end function add_conjspinor
pure function sub_conjspinor (x, y) result (xy)
type(conjspinor), intent(in) :: x, y
type(conjspinor) :: xy
xy%a = x%a - y%a
end function sub_conjspinor
@
\subsection{Norm}
<<Declaration of operations for spinors>>=
interface abs
module procedure abs_spinor, abs_conjspinor
end interface
private :: abs_spinor, abs_conjspinor
@
<<Implementation of operations for spinors>>=
pure function abs_spinor (psi) result (x)
type(spinor), intent(in) :: psi
real(kind=default) :: x
x = sqrt (real (dot_product (psi%a, psi%a)))
end function abs_spinor
@
<<Implementation of operations for spinors>>=
pure function abs_conjspinor (psibar) result (x)
real(kind=default) :: x
type(conjspinor), intent(in) :: psibar
x = sqrt (real (dot_product (psibar%a, psibar%a)))
end function abs_conjspinor
@
\section{Spinors Revisited}
<<[[omega_bispinors.f90]]>>=
<<Copyleft>>
module omega_bispinors
use kinds
use constants
implicit none
private
public :: operator (*), operator (+), operator (-)
public :: abs, set_zero
type, public :: bispinor
! private (omegalib needs access, but DON'T TOUCH IT!)
complex(kind=default), dimension(4) :: a
end type bispinor
<<Declaration of operations for bispinors>>
integer, parameter, public :: omega_bispinors_2010_01_A = 0
contains
<<Implementation of operations for bispinors>>
end module omega_bispinors
@
<<Declaration of operations for bispinors>>=
interface operator (*)
module procedure spinor_product
end interface
private :: spinor_product
@
\begin{equation}
\bar\psi\psi'
\end{equation}
NB: [[dot_product]] conjugates its first argument, we have to cancel this.
<<Implementation of operations for bispinors>>=
pure function spinor_product (psil, psir) result (psilpsir)
complex(kind=default) :: psilpsir
type(bispinor), intent(in) :: psil, psir
type(bispinor) :: psidum
psidum%a(1) = psir%a(2)
psidum%a(2) = - psir%a(1)
psidum%a(3) = - psir%a(4)
psidum%a(4) = psir%a(3)
psilpsir = dot_product (conjg (psil%a), psidum%a)
end function spinor_product
@
\subsection{Spinor Vector Space}
<<Declaration of operations for bispinors>>=
interface set_zero
module procedure set_zero_bispinor
end interface
private :: set_zero_bispinor
@
<<Implementation of operations for bispinors>>=
elemental subroutine set_zero_bispinor (x)
type(bispinor), intent(out) :: x
x%a = 0
end subroutine set_zero_bispinor
@
\subsubsection{Scalar Multiplication}
<<Declaration of operations for bispinors>>=
interface operator (*)
module procedure integer_bispinor, bispinor_integer, &
real_bispinor, double_bispinor, &
complex_bispinor, dcomplex_bispinor, &
bispinor_real, bispinor_double, &
bispinor_complex, bispinor_dcomplex
end interface
private :: integer_bispinor, bispinor_integer, real_bispinor, &
double_bispinor, complex_bispinor, dcomplex_bispinor, &
bispinor_real, bispinor_double, bispinor_complex, bispinor_dcomplex
@
<<Implementation of operations for bispinors>>=
pure function integer_bispinor (x, y) result (xy)
type(bispinor) :: xy
integer, intent(in) :: x
type(bispinor), intent(in) :: y
xy%a = x * y%a
end function integer_bispinor
@
<<Implementation of operations for bispinors>>=
pure function real_bispinor (x, y) result (xy)
type(bispinor) :: xy
real(kind=single), intent(in) :: x
type(bispinor), intent(in) :: y
xy%a = x * y%a
end function real_bispinor
@
<<Implementation of operations for bispinors>>=
pure function double_bispinor (x, y) result (xy)
type(bispinor) :: xy
real(kind=default), intent(in) :: x
type(bispinor), intent(in) :: y
xy%a = x * y%a
end function double_bispinor
@
<<Implementation of operations for bispinors>>=
pure function complex_bispinor (x, y) result (xy)
type(bispinor) :: xy
complex(kind=single), intent(in) :: x
type(bispinor), intent(in) :: y
xy%a = x * y%a
end function complex_bispinor
@
<<Implementation of operations for bispinors>>=
pure function dcomplex_bispinor (x, y) result (xy)
type(bispinor) :: xy
complex(kind=default), intent(in) :: x
type(bispinor), intent(in) :: y
xy%a = x * y%a
end function dcomplex_bispinor
@
<<Implementation of operations for bispinors>>=
pure function bispinor_integer (y, x) result (xy)
type(bispinor) :: xy
integer, intent(in) :: x
type(bispinor), intent(in) :: y
xy%a = x * y%a
end function bispinor_integer
@
<<Implementation of operations for bispinors>>=
pure function bispinor_real (y, x) result (xy)
type(bispinor) :: xy
real(kind=single), intent(in) :: x
type(bispinor), intent(in) :: y
xy%a = x * y%a
end function bispinor_real
@
<<Implementation of operations for bispinors>>=
pure function bispinor_double (y, x) result (xy)
type(bispinor) :: xy
real(kind=default), intent(in) :: x
type(bispinor), intent(in) :: y
xy%a = x * y%a
end function bispinor_double
@
<<Implementation of operations for bispinors>>=
pure function bispinor_complex (y, x) result (xy)
type(bispinor) :: xy
complex(kind=single), intent(in) :: x
type(bispinor), intent(in) :: y
xy%a = x * y%a
end function bispinor_complex
@
<<Implementation of operations for bispinors>>=
pure function bispinor_dcomplex (y, x) result (xy)
type(bispinor) :: xy
complex(kind=default), intent(in) :: x
type(bispinor), intent(in) :: y
xy%a = x * y%a
end function bispinor_dcomplex
@
\subsubsection{Unary Plus and Minus}
<<Declaration of operations for bispinors>>=
interface operator (+)
module procedure plus_bispinor
end interface
private :: plus_bispinor
interface operator (-)
module procedure neg_bispinor
end interface
private :: neg_bispinor
@
<<Implementation of operations for bispinors>>=
pure function plus_bispinor (x) result (plus_x)
type(bispinor) :: plus_x
type(bispinor), intent(in) :: x
plus_x%a = x%a
end function plus_bispinor
@
<<Implementation of operations for bispinors>>=
pure function neg_bispinor (x) result (neg_x)
type(bispinor) :: neg_x
type(bispinor), intent(in) :: x
neg_x%a = - x%a
end function neg_bispinor
@
\subsubsection{Addition and Subtraction}
<<Declaration of operations for bispinors>>=
interface operator (+)
module procedure add_bispinor
end interface
private :: add_bispinor
interface operator (-)
module procedure sub_bispinor
end interface
private :: sub_bispinor
@
<<Implementation of operations for bispinors>>=
pure function add_bispinor (x, y) result (xy)
type(bispinor) :: xy
type(bispinor), intent(in) :: x, y
xy%a = x%a + y%a
end function add_bispinor
@
<<Implementation of operations for bispinors>>=
pure function sub_bispinor (x, y) result (xy)
type(bispinor) :: xy
type(bispinor), intent(in) :: x, y
xy%a = x%a - y%a
end function sub_bispinor
@
\subsection{Norm}
<<Declaration of operations for bispinors>>=
interface abs
module procedure abs_bispinor
end interface
private :: abs_bispinor
@
<<Implementation of operations for bispinors>>=
pure function abs_bispinor (psi) result (x)
real(kind=default) :: x
type(bispinor), intent(in) :: psi
x = sqrt (real (dot_product (psi%a, psi%a)))
end function abs_bispinor
@
\section{Vectorspinors}
<<[[omega_vectorspinors.f90]]>>=
<<Copyleft>>
module omega_vectorspinors
use kinds
use constants
use omega_bispinors
use omega_vectors
implicit none
private
public :: operator (*), operator (+), operator (-)
public :: abs, set_zero
type, public :: vectorspinor
! private (omegalib needs access, but DON'T TOUCH IT!)
type(bispinor), dimension(4) :: psi
end type vectorspinor
<<Declaration of operations for vectorspinors>>
integer, parameter, public :: omega_vectorspinors_2010_01_A = 0
contains
<<Implementation of operations for vectorspinors>>
end module omega_vectorspinors
@
<<Declaration of operations for vectorspinors>>=
interface operator (*)
module procedure vspinor_product
end interface
private :: vspinor_product
@
\begin{equation}
\bar\psi^\mu\psi'_\mu
\end{equation}
<<Implementation of operations for vectorspinors>>=
pure function vspinor_product (psil, psir) result (psilpsir)
complex(kind=default) :: psilpsir
type(vectorspinor), intent(in) :: psil, psir
psilpsir = psil%psi(1) * psir%psi(1) &
- psil%psi(2) * psir%psi(2) &
- psil%psi(3) * psir%psi(3) &
- psil%psi(4) * psir%psi(4)
end function vspinor_product
@
\subsection{Vectorspinor Vector Space}
<<Declaration of operations for vectorspinors>>=
interface set_zero
module procedure set_zero_vectorspinor
end interface
private :: set_zero_vectorspinor
@
<<Implementation of operations for vectorspinors>>=
elemental subroutine set_zero_vectorspinor (x)
type(vectorspinor), intent(out) :: x
call set_zero (x%psi)
end subroutine set_zero_vectorspinor
@
\subsubsection{Scalar Multiplication}
<<Declaration of operations for vectorspinors>>=
interface operator (*)
module procedure integer_vectorspinor, vectorspinor_integer, &
real_vectorspinor, double_vectorspinor, &
complex_vectorspinor, dcomplex_vectorspinor, &
vectorspinor_real, vectorspinor_double, &
vectorspinor_complex, vectorspinor_dcomplex, &
momentum_vectorspinor, vectorspinor_momentum
end interface
private :: integer_vectorspinor, vectorspinor_integer, real_vectorspinor, &
double_vectorspinor, complex_vectorspinor, dcomplex_vectorspinor, &
vectorspinor_real, vectorspinor_double, vectorspinor_complex, &
vectorspinor_dcomplex
@
<<Implementation of operations for vectorspinors>>=
pure function integer_vectorspinor (x, y) result (xy)
type(vectorspinor) :: xy
integer, intent(in) :: x
type(vectorspinor), intent(in) :: y
integer :: k
do k = 1,4
xy%psi(k) = x * y%psi(k)
end do
end function integer_vectorspinor
@
<<Implementation of operations for vectorspinors>>=
pure function real_vectorspinor (x, y) result (xy)
type(vectorspinor) :: xy
real(kind=single), intent(in) :: x
type(vectorspinor), intent(in) :: y
integer :: k
do k = 1,4
xy%psi(k) = x * y%psi(k)
end do
end function real_vectorspinor
@
<<Implementation of operations for vectorspinors>>=
pure function double_vectorspinor (x, y) result (xy)
type(vectorspinor) :: xy
real(kind=default), intent(in) :: x
type(vectorspinor), intent(in) :: y
integer :: k
do k = 1,4
xy%psi(k) = x * y%psi(k)
end do
end function double_vectorspinor
@
<<Implementation of operations for vectorspinors>>=
pure function complex_vectorspinor (x, y) result (xy)
type(vectorspinor) :: xy
complex(kind=single), intent(in) :: x
type(vectorspinor), intent(in) :: y
integer :: k
do k = 1,4
xy%psi(k) = x * y%psi(k)
end do
end function complex_vectorspinor
@
<<Implementation of operations for vectorspinors>>=
pure function dcomplex_vectorspinor (x, y) result (xy)
type(vectorspinor) :: xy
complex(kind=default), intent(in) :: x
type(vectorspinor), intent(in) :: y
integer :: k
do k = 1,4
xy%psi(k) = x * y%psi(k)
end do
end function dcomplex_vectorspinor
@
<<Implementation of operations for vectorspinors>>=
pure function vectorspinor_integer (y, x) result (xy)
type(vectorspinor) :: xy
integer, intent(in) :: x
type(vectorspinor), intent(in) :: y
integer :: k
do k = 1,4
xy%psi(k) = y%psi(k) * x
end do
end function vectorspinor_integer
@
<<Implementation of operations for vectorspinors>>=
pure function vectorspinor_real (y, x) result (xy)
type(vectorspinor) :: xy
real(kind=single), intent(in) :: x
type(vectorspinor), intent(in) :: y
integer :: k
do k = 1,4
xy%psi(k) = y%psi(k) * x
end do
end function vectorspinor_real
@
<<Implementation of operations for vectorspinors>>=
pure function vectorspinor_double (y, x) result (xy)
type(vectorspinor) :: xy
real(kind=default), intent(in) :: x
type(vectorspinor), intent(in) :: y
integer :: k
do k = 1,4
xy%psi(k) = y%psi(k) * x
end do
end function vectorspinor_double
@
<<Implementation of operations for vectorspinors>>=
pure function vectorspinor_complex (y, x) result (xy)
type(vectorspinor) :: xy
complex(kind=single), intent(in) :: x
type(vectorspinor), intent(in) :: y
integer :: k
do k = 1,4
xy%psi(k) = y%psi(k) * x
end do
end function vectorspinor_complex
@
<<Implementation of operations for vectorspinors>>=
pure function vectorspinor_dcomplex (y, x) result (xy)
type(vectorspinor) :: xy
complex(kind=default), intent(in) :: x
type(vectorspinor), intent(in) :: y
integer :: k
do k = 1,4
xy%psi(k) = y%psi(k) * x
end do
end function vectorspinor_dcomplex
@
<<Implementation of operations for vectorspinors>>=
pure function momentum_vectorspinor (y, x) result (xy)
type(bispinor) :: xy
type(momentum), intent(in) :: y
type(vectorspinor), intent(in) :: x
integer :: k
do k = 1,4
xy%a(k) = y%t * x%psi(1)%a(k) - y%x(1) * x%psi(2)%a(k) - &
y%x(2) * x%psi(3)%a(k) - y%x(3) * x%psi(4)%a(k)
end do
end function momentum_vectorspinor
@
<<Implementation of operations for vectorspinors>>=
pure function vectorspinor_momentum (y, x) result (xy)
type(bispinor) :: xy
type(momentum), intent(in) :: x
type(vectorspinor), intent(in) :: y
integer :: k
do k = 1,4
xy%a(k) = x%t * y%psi(1)%a(k) - x%x(1) * y%psi(2)%a(k) - &
x%x(2) * y%psi(3)%a(k) - x%x(3) * y%psi(4)%a(k)
end do
end function vectorspinor_momentum
@
\subsubsection{Unary Plus and Minus}
<<Declaration of operations for vectorspinors>>=
interface operator (+)
module procedure plus_vectorspinor
end interface
private :: plus_vectorspinor
interface operator (-)
module procedure neg_vectorspinor
end interface
private :: neg_vectorspinor
@
<<Implementation of operations for vectorspinors>>=
pure function plus_vectorspinor (x) result (plus_x)
type(vectorspinor) :: plus_x
type(vectorspinor), intent(in) :: x
integer :: k
do k = 1,4
plus_x%psi(k) = + x%psi(k)
end do
end function plus_vectorspinor
@
<<Implementation of operations for vectorspinors>>=
pure function neg_vectorspinor (x) result (neg_x)
type(vectorspinor) :: neg_x
type(vectorspinor), intent(in) :: x
integer :: k
do k = 1,4
neg_x%psi(k) = - x%psi(k)
end do
end function neg_vectorspinor
@
\subsubsection{Addition and Subtraction}
<<Declaration of operations for vectorspinors>>=
interface operator (+)
module procedure add_vectorspinor
end interface
private :: add_vectorspinor
interface operator (-)
module procedure sub_vectorspinor
end interface
private :: sub_vectorspinor
@
<<Implementation of operations for vectorspinors>>=
pure function add_vectorspinor (x, y) result (xy)
type(vectorspinor) :: xy
type(vectorspinor), intent(in) :: x, y
integer :: k
do k = 1,4
xy%psi(k) = x%psi(k) + y%psi(k)
end do
end function add_vectorspinor
@
<<Implementation of operations for vectorspinors>>=
pure function sub_vectorspinor (x, y) result (xy)
type(vectorspinor) :: xy
type(vectorspinor), intent(in) :: x, y
integer :: k
do k = 1,4
xy%psi(k) = x%psi(k) - y%psi(k)
end do
end function sub_vectorspinor
@
\subsection{Norm}
<<Declaration of operations for vectorspinors>>=
interface abs
module procedure abs_vectorspinor
end interface
private :: abs_vectorspinor
@
<<Implementation of operations for vectorspinors>>=
pure function abs_vectorspinor (psi) result (x)
real(kind=default) :: x
type(vectorspinor), intent(in) :: psi
x = sqrt (real (dot_product (psi%psi(1)%a, psi%psi(1)%a) &
- dot_product (psi%psi(2)%a, psi%psi(2)%a) &
- dot_product (psi%psi(3)%a, psi%psi(3)%a) &
- dot_product (psi%psi(4)%a, psi%psi(4)%a)))
end function abs_vectorspinor
@
\section{Vectors and Tensors}
Condensed representation of antisymmetric rank-2 tensors:
\begin{equation}
\begin{pmatrix}
T^{00} & T^{01} & T^{02} & T^{03} \\
T^{10} & T^{11} & T^{12} & T^{13} \\
T^{20} & T^{21} & T^{22} & T^{23} \\
T^{30} & T^{31} & T^{32} & T^{33}
\end{pmatrix}
=
\begin{pmatrix}
0 & T_e^1 & T_e^2 & T_e^3 \\
-T_e^1 & 0 & T_b^3 & -T_b^2 \\
-T_e^2 & -T_b^3 & 0 & T_b^1 \\
-T_e^3 & T_b^2 & -T_b^1 & 0
\end{pmatrix}
\end{equation}
<<[[omega_vectors.f90]]>>=
<<Copyleft>>
module omega_vectors
use kinds
use constants
implicit none
private
public :: assignment (=), operator(==)
public :: operator (*), operator (+), operator (-), operator (.wedge.)
public :: abs, conjg, set_zero
public :: random_momentum
<<[[intrinsic :: abs]]>>
<<[[intrinsic :: conjg]]>>
type, public :: momentum
! private (omegalib needs access, but DON'T TOUCH IT!)
real(kind=default) :: t
real(kind=default), dimension(3) :: x
end type momentum
type, public :: vector
! private (omegalib needs access, but DON'T TOUCH IT!)
complex(kind=default) :: t
complex(kind=default), dimension(3) :: x
end type vector
type, public :: tensor2odd
! private (omegalib needs access, but DON'T TOUCH IT!)
complex(kind=default), dimension(3) :: e
complex(kind=default), dimension(3) :: b
end type tensor2odd
<<Declaration of operations for vectors>>
integer, parameter, public :: omega_vectors_2010_01_A = 0
contains
<<Implementation of operations for vectors>>
end module omega_vectors
@
\subsection{Constructors}
<<Declaration of operations for vectors>>=
interface assignment (=)
module procedure momentum_of_array, vector_of_momentum, &
vector_of_array, vector_of_double_array, &
array_of_momentum, array_of_vector
end interface
private :: momentum_of_array, vector_of_momentum, vector_of_array, &
vector_of_double_array, array_of_momentum, array_of_vector
@
<<Implementation of operations for vectors>>=
pure subroutine momentum_of_array (m, p)
type(momentum), intent(out) :: m
real(kind=default), dimension(0:), intent(in) :: p
m%t = p(0)
m%x = p(1:3)
end subroutine momentum_of_array
pure subroutine array_of_momentum (p, v)
real(kind=default), dimension(0:), intent(out) :: p
type(momentum), intent(in) :: v
p(0) = v%t
p(1:3) = v%x
end subroutine array_of_momentum
@
<<Implementation of operations for vectors>>=
pure subroutine vector_of_array (v, p)
type(vector), intent(out) :: v
complex(kind=default), dimension(0:), intent(in) :: p
v%t = p(0)
v%x = p(1:3)
end subroutine vector_of_array
pure subroutine vector_of_double_array (v, p)
type(vector), intent(out) :: v
real(kind=default), dimension(0:), intent(in) :: p
v%t = p(0)
v%x = p(1:3)
end subroutine vector_of_double_array
pure subroutine array_of_vector (p, v)
complex(kind=default), dimension(0:), intent(out) :: p
type(vector), intent(in) :: v
p(0) = v%t
p(1:3) = v%x
end subroutine array_of_vector
@
<<Implementation of operations for vectors>>=
pure subroutine vector_of_momentum (v, p)
type(vector), intent(out) :: v
type(momentum), intent(in) :: p
v%t = p%t
v%x = p%x
end subroutine vector_of_momentum
@
<<Declaration of operations for vectors>>=
interface operator(==)
module procedure momentum_eq
end interface
@
<<Implementation of operations for vectors>>=
elemental function momentum_eq (lhs, rhs) result (yorn)
logical :: yorn
type(momentum), intent(in) :: lhs
type(momentum), intent(in) :: rhs
yorn = all (abs(lhs%x - rhs%x) < eps0) .and. abs(lhs%t - rhs%t) < eps0
end function momentum_eq
@
\subsection{Inner Products}
<<Declaration of operations for vectors>>=
interface operator (*)
module procedure momentum_momentum, vector_vector, &
vector_momentum, momentum_vector, tensor2odd_tensor2odd
end interface
private :: momentum_momentum, vector_vector, vector_momentum, &
momentum_vector, tensor2odd_tensor2odd
@
<<Implementation of operations for vectors>>=
pure function momentum_momentum (x, y) result (xy)
type(momentum), intent(in) :: x
type(momentum), intent(in) :: y
real(kind=default) :: xy
xy = x%t*y%t - x%x(1)*y%x(1) - x%x(2)*y%x(2) - x%x(3)*y%x(3)
end function momentum_momentum
pure function momentum_vector (x, y) result (xy)
type(momentum), intent(in) :: x
type(vector), intent(in) :: y
complex(kind=default) :: xy
xy = x%t*y%t - x%x(1)*y%x(1) - x%x(2)*y%x(2) - x%x(3)*y%x(3)
end function momentum_vector
pure function vector_momentum (x, y) result (xy)
type(vector), intent(in) :: x
type(momentum), intent(in) :: y
complex(kind=default) :: xy
xy = x%t*y%t - x%x(1)*y%x(1) - x%x(2)*y%x(2) - x%x(3)*y%x(3)
end function vector_momentum
pure function vector_vector (x, y) result (xy)
type(vector), intent(in) :: x
type(vector), intent(in) :: y
complex(kind=default) :: xy
xy = x%t*y%t - x%x(1)*y%x(1) - x%x(2)*y%x(2) - x%x(3)*y%x(3)
end function vector_vector
@
Just like classical electrodynamics:
\begin{equation}
\frac{1}{2} T_{\mu\nu} U^{\mu\nu}
= \frac{1}{2} \left( - T^{0i} U^{0i} - T^{i0} U^{i0} + T^{ij} U^{ij} \right)
= T_b^k U_b^k - T_e^k U_e^k
\end{equation}
<<Implementation of operations for vectors>>=
pure function tensor2odd_tensor2odd (x, y) result (xy)
type(tensor2odd), intent(in) :: x
type(tensor2odd), intent(in) :: y
complex(kind=default) :: xy
xy = x%b(1)*y%b(1) + x%b(2)*y%b(2) + x%b(3)*y%b(3) &
- x%e(1)*y%e(1) - x%e(2)*y%e(2) - x%e(3)*y%e(3)
end function tensor2odd_tensor2odd
@
\subsection{Not Entirely Inner Products}
<<Declaration of operations for vectors>>=
interface operator (*)
module procedure momentum_tensor2odd, tensor2odd_momentum, &
vector_tensor2odd, tensor2odd_vector
end interface
private :: momentum_tensor2odd, tensor2odd_momentum, vector_tensor2odd, &
tensor2odd_vector
@
\begin{subequations}
\begin{align}
y^\nu = x_\mu T^{\mu\nu}:
& y^0 = - x^i T^{i0} = x^i T^{0i} \\
& y^1 = x^0 T^{01} - x^2 T^{21} - x^3 T^{31} \\
& y^2 = x^0 T^{02} - x^1 T^{12} - x^3 T^{32} \\
& y^3 = x^0 T^{03} - x^1 T^{13} - x^2 T^{23}
\end{align}
\end{subequations}
<<Implementation of operations for vectors>>=
pure function vector_tensor2odd (x, t2) result (xt2)
type(vector), intent(in) :: x
type(tensor2odd), intent(in) :: t2
type(vector) :: xt2
xt2%t = x%x(1)*t2%e(1) + x%x(2)*t2%e(2) + x%x(3)*t2%e(3)
xt2%x(1) = x%t*t2%e(1) + x%x(2)*t2%b(3) - x%x(3)*t2%b(2)
xt2%x(2) = x%t*t2%e(2) + x%x(3)*t2%b(1) - x%x(1)*t2%b(3)
xt2%x(3) = x%t*t2%e(3) + x%x(1)*t2%b(2) - x%x(2)*t2%b(1)
end function vector_tensor2odd
pure function momentum_tensor2odd (x, t2) result (xt2)
type(momentum), intent(in) :: x
type(tensor2odd), intent(in) :: t2
type(vector) :: xt2
xt2%t = x%x(1)*t2%e(1) + x%x(2)*t2%e(2) + x%x(3)*t2%e(3)
xt2%x(1) = x%t*t2%e(1) + x%x(2)*t2%b(3) - x%x(3)*t2%b(2)
xt2%x(2) = x%t*t2%e(2) + x%x(3)*t2%b(1) - x%x(1)*t2%b(3)
xt2%x(3) = x%t*t2%e(3) + x%x(1)*t2%b(2) - x%x(2)*t2%b(1)
end function momentum_tensor2odd
@
\begin{subequations}
\begin{align}
y^\mu = T^{\mu\nu} x_\nu :
& y^0 = - T^{0i} x^i \\
& y^1 = T^{10} x^0 - T^{12} x^2 - T^{13} x^3 \\
& y^2 = T^{20} x^0 - T^{21} x^1 - T^{23} x^3 \\
& y^3 = T^{30} x^0 - T^{31} x^1 - T^{32} x^2
\end{align}
\end{subequations}
<<Implementation of operations for vectors>>=
pure function tensor2odd_vector (t2, x) result (t2x)
type(tensor2odd), intent(in) :: t2
type(vector), intent(in) :: x
type(vector) :: t2x
t2x%t = - t2%e(1)*x%x(1) - t2%e(2)*x%x(2) - t2%e(3)*x%x(3)
t2x%x(1) = - t2%e(1)*x%t + t2%b(2)*x%x(3) - t2%b(3)*x%x(2)
t2x%x(2) = - t2%e(2)*x%t + t2%b(3)*x%x(1) - t2%b(1)*x%x(3)
t2x%x(3) = - t2%e(3)*x%t + t2%b(1)*x%x(2) - t2%b(2)*x%x(1)
end function tensor2odd_vector
pure function tensor2odd_momentum (t2, x) result (t2x)
type(tensor2odd), intent(in) :: t2
type(momentum), intent(in) :: x
type(vector) :: t2x
t2x%t = - t2%e(1)*x%x(1) - t2%e(2)*x%x(2) - t2%e(3)*x%x(3)
t2x%x(1) = - t2%e(1)*x%t + t2%b(2)*x%x(3) - t2%b(3)*x%x(2)
t2x%x(2) = - t2%e(2)*x%t + t2%b(3)*x%x(1) - t2%b(1)*x%x(3)
t2x%x(3) = - t2%e(3)*x%t + t2%b(1)*x%x(2) - t2%b(2)*x%x(1)
end function tensor2odd_momentum
@
\subsection{Outer Products}
<<Declaration of operations for vectors>>=
interface operator (.wedge.)
module procedure momentum_wedge_momentum, &
momentum_wedge_vector, vector_wedge_momentum, vector_wedge_vector
end interface
private :: momentum_wedge_momentum, momentum_wedge_vector, &
vector_wedge_momentum, vector_wedge_vector
@
<<Implementation of operations for vectors>>=
pure function momentum_wedge_momentum (x, y) result (t2)
type(momentum), intent(in) :: x
type(momentum), intent(in) :: y
type(tensor2odd) :: t2
t2%e = x%t * y%x - x%x * y%t
t2%b(1) = x%x(2) * y%x(3) - x%x(3) * y%x(2)
t2%b(2) = x%x(3) * y%x(1) - x%x(1) * y%x(3)
t2%b(3) = x%x(1) * y%x(2) - x%x(2) * y%x(1)
end function momentum_wedge_momentum
pure function momentum_wedge_vector (x, y) result (t2)
type(momentum), intent(in) :: x
type(vector), intent(in) :: y
type(tensor2odd) :: t2
t2%e = x%t * y%x - x%x * y%t
t2%b(1) = x%x(2) * y%x(3) - x%x(3) * y%x(2)
t2%b(2) = x%x(3) * y%x(1) - x%x(1) * y%x(3)
t2%b(3) = x%x(1) * y%x(2) - x%x(2) * y%x(1)
end function momentum_wedge_vector
pure function vector_wedge_momentum (x, y) result (t2)
type(vector), intent(in) :: x
type(momentum), intent(in) :: y
type(tensor2odd) :: t2
t2%e = x%t * y%x - x%x * y%t
t2%b(1) = x%x(2) * y%x(3) - x%x(3) * y%x(2)
t2%b(2) = x%x(3) * y%x(1) - x%x(1) * y%x(3)
t2%b(3) = x%x(1) * y%x(2) - x%x(2) * y%x(1)
end function vector_wedge_momentum
pure function vector_wedge_vector (x, y) result (t2)
type(vector), intent(in) :: x
type(vector), intent(in) :: y
type(tensor2odd) :: t2
t2%e = x%t * y%x - x%x * y%t
t2%b(1) = x%x(2) * y%x(3) - x%x(3) * y%x(2)
t2%b(2) = x%x(3) * y%x(1) - x%x(1) * y%x(3)
t2%b(3) = x%x(1) * y%x(2) - x%x(2) * y%x(1)
end function vector_wedge_vector
@
\subsection{Vector Space}
<<Declaration of operations for vectors>>=
interface set_zero
module procedure set_zero_vector, set_zero_momentum, &
set_zero_tensor2odd, set_zero_real, set_zero_complex
end interface
private :: set_zero_vector, set_zero_momentum, set_zero_tensor2odd
@
<<Implementation of operations for vectors>>=
elemental subroutine set_zero_vector (x)
type(vector), intent(out) :: x
x%t = 0
x%x = 0
end subroutine set_zero_vector
@
<<Implementation of operations for vectors>>=
elemental subroutine set_zero_momentum (x)
type(momentum), intent(out) :: x
x%t = 0
x%x = 0
end subroutine set_zero_momentum
@
<<Implementation of operations for vectors>>=
elemental subroutine set_zero_tensor2odd (x)
type(tensor2odd), intent(out) :: x
x%e = 0
x%b = 0
end subroutine set_zero_tensor2odd
@
Doesn't really belong here, but there is no better place \ldots
<<Implementation of operations for vectors>>=
elemental subroutine set_zero_real (x)
real(kind=default), intent(out) :: x
x = 0
end subroutine set_zero_real
@
<<Implementation of operations for vectors>>=
elemental subroutine set_zero_complex (x)
complex(kind=default), intent(out) :: x
x = 0
end subroutine set_zero_complex
@
\subsubsection{Scalar Multiplication}
<<Declaration of operations for vectors>>=
interface operator (*)
module procedure integer_momentum, real_momentum, double_momentum, &
complex_momentum, dcomplex_momentum, &
integer_vector, real_vector, double_vector, &
complex_vector, dcomplex_vector, &
integer_tensor2odd, real_tensor2odd, double_tensor2odd, &
complex_tensor2odd, dcomplex_tensor2odd, &
momentum_integer, momentum_real, momentum_double, &
momentum_complex, momentum_dcomplex, &
vector_integer, vector_real, vector_double, &
vector_complex, vector_dcomplex, &
tensor2odd_integer, tensor2odd_real, tensor2odd_double, &
tensor2odd_complex, tensor2odd_dcomplex
end interface
private :: integer_momentum, real_momentum, double_momentum, &
complex_momentum, dcomplex_momentum, integer_vector, real_vector, &
double_vector, complex_vector, dcomplex_vector, &
integer_tensor2odd, real_tensor2odd, double_tensor2odd, &
complex_tensor2odd, dcomplex_tensor2odd, momentum_integer, &
momentum_real, momentum_double, momentum_complex, &
momentum_dcomplex, vector_integer, vector_real, vector_double, &
vector_complex, vector_dcomplex, tensor2odd_integer, &
tensor2odd_real, tensor2odd_double, tensor2odd_complex, &
tensor2odd_dcomplex
@
<<Implementation of operations for vectors>>=
pure function integer_momentum (x, y) result (xy)
integer, intent(in) :: x
type(momentum), intent(in) :: y
type(momentum) :: xy
xy%t = x * y%t
xy%x = x * y%x
end function integer_momentum
pure function real_momentum (x, y) result (xy)
real(kind=single), intent(in) :: x
type(momentum), intent(in) :: y
type(momentum) :: xy
xy%t = x * y%t
xy%x = x * y%x
end function real_momentum
pure function double_momentum (x, y) result (xy)
real(kind=default), intent(in) :: x
type(momentum), intent(in) :: y
type(momentum) :: xy
xy%t = x * y%t
xy%x = x * y%x
end function double_momentum
pure function complex_momentum (x, y) result (xy)
complex(kind=single), intent(in) :: x
type(momentum), intent(in) :: y
type(vector) :: xy
xy%t = x * y%t
xy%x = x * y%x
end function complex_momentum
pure function dcomplex_momentum (x, y) result (xy)
complex(kind=default), intent(in) :: x
type(momentum), intent(in) :: y
type(vector) :: xy
xy%t = x * y%t
xy%x = x * y%x
end function dcomplex_momentum
@
<<Implementation of operations for vectors>>=
pure function integer_vector (x, y) result (xy)
integer, intent(in) :: x
type(vector), intent(in) :: y
type(vector) :: xy
xy%t = x * y%t
xy%x = x * y%x
end function integer_vector
pure function real_vector (x, y) result (xy)
real(kind=single), intent(in) :: x
type(vector), intent(in) :: y
type(vector) :: xy
xy%t = x * y%t
xy%x = x * y%x
end function real_vector
pure function double_vector (x, y) result (xy)
real(kind=default), intent(in) :: x
type(vector), intent(in) :: y
type(vector) :: xy
xy%t = x * y%t
xy%x = x * y%x
end function double_vector
pure function complex_vector (x, y) result (xy)
complex(kind=single), intent(in) :: x
type(vector), intent(in) :: y
type(vector) :: xy
xy%t = x * y%t
xy%x = x * y%x
end function complex_vector
pure function dcomplex_vector (x, y) result (xy)
complex(kind=default), intent(in) :: x
type(vector), intent(in) :: y
type(vector) :: xy
xy%t = x * y%t
xy%x = x * y%x
end function dcomplex_vector
@
<<Implementation of operations for vectors>>=
pure function integer_tensor2odd (x, t2) result (xt2)
integer, intent(in) :: x
type(tensor2odd), intent(in) :: t2
type(tensor2odd) :: xt2
xt2%e = x * t2%e
xt2%b = x * t2%b
end function integer_tensor2odd
pure function real_tensor2odd (x, t2) result (xt2)
real(kind=single), intent(in) :: x
type(tensor2odd), intent(in) :: t2
type(tensor2odd) :: xt2
xt2%e = x * t2%e
xt2%b = x * t2%b
end function real_tensor2odd
pure function double_tensor2odd (x, t2) result (xt2)
real(kind=default), intent(in) :: x
type(tensor2odd), intent(in) :: t2
type(tensor2odd) :: xt2
xt2%e = x * t2%e
xt2%b = x * t2%b
end function double_tensor2odd
pure function complex_tensor2odd (x, t2) result (xt2)
complex(kind=single), intent(in) :: x
type(tensor2odd), intent(in) :: t2
type(tensor2odd) :: xt2
xt2%e = x * t2%e
xt2%b = x * t2%b
end function complex_tensor2odd
pure function dcomplex_tensor2odd (x, t2) result (xt2)
complex(kind=default), intent(in) :: x
type(tensor2odd), intent(in) :: t2
type(tensor2odd) :: xt2
xt2%e = x * t2%e
xt2%b = x * t2%b
end function dcomplex_tensor2odd
@
<<Implementation of operations for vectors>>=
pure function momentum_integer (y, x) result (xy)
integer, intent(in) :: x
type(momentum), intent(in) :: y
type(momentum) :: xy
xy%t = x * y%t
xy%x = x * y%x
end function momentum_integer
pure function momentum_real (y, x) result (xy)
real(kind=single), intent(in) :: x
type(momentum), intent(in) :: y
type(momentum) :: xy
xy%t = x * y%t
xy%x = x * y%x
end function momentum_real
pure function momentum_double (y, x) result (xy)
real(kind=default), intent(in) :: x
type(momentum), intent(in) :: y
type(momentum) :: xy
xy%t = x * y%t
xy%x = x * y%x
end function momentum_double
pure function momentum_complex (y, x) result (xy)
complex(kind=single), intent(in) :: x
type(momentum), intent(in) :: y
type(vector) :: xy
xy%t = x * y%t
xy%x = x * y%x
end function momentum_complex
pure function momentum_dcomplex (y, x) result (xy)
complex(kind=default), intent(in) :: x
type(momentum), intent(in) :: y
type(vector) :: xy
xy%t = x * y%t
xy%x = x * y%x
end function momentum_dcomplex
@
<<Implementation of operations for vectors>>=
pure function vector_integer (y, x) result (xy)
integer, intent(in) :: x
type(vector), intent(in) :: y
type(vector) :: xy
xy%t = x * y%t
xy%x = x * y%x
end function vector_integer
pure function vector_real (y, x) result (xy)
real(kind=single), intent(in) :: x
type(vector), intent(in) :: y
type(vector) :: xy
xy%t = x * y%t
xy%x = x * y%x
end function vector_real
pure function vector_double (y, x) result (xy)
real(kind=default), intent(in) :: x
type(vector), intent(in) :: y
type(vector) :: xy
xy%t = x * y%t
xy%x = x * y%x
end function vector_double
pure function vector_complex (y, x) result (xy)
complex(kind=single), intent(in) :: x
type(vector), intent(in) :: y
type(vector) :: xy
xy%t = x * y%t
xy%x = x * y%x
end function vector_complex
pure function vector_dcomplex (y, x) result (xy)
complex(kind=default), intent(in) :: x
type(vector), intent(in) :: y
type(vector) :: xy
xy%t = x * y%t
xy%x = x * y%x
end function vector_dcomplex
@
<<Implementation of operations for vectors>>=
pure function tensor2odd_integer (t2, x) result (t2x)
type(tensor2odd), intent(in) :: t2
integer, intent(in) :: x
type(tensor2odd) :: t2x
t2x%e = x * t2%e
t2x%b = x * t2%b
end function tensor2odd_integer
pure function tensor2odd_real (t2, x) result (t2x)
type(tensor2odd), intent(in) :: t2
real(kind=single), intent(in) :: x
type(tensor2odd) :: t2x
t2x%e = x * t2%e
t2x%b = x * t2%b
end function tensor2odd_real
pure function tensor2odd_double (t2, x) result (t2x)
type(tensor2odd), intent(in) :: t2
real(kind=default), intent(in) :: x
type(tensor2odd) :: t2x
t2x%e = x * t2%e
t2x%b = x * t2%b
end function tensor2odd_double
pure function tensor2odd_complex (t2, x) result (t2x)
type(tensor2odd), intent(in) :: t2
complex(kind=single), intent(in) :: x
type(tensor2odd) :: t2x
t2x%e = x * t2%e
t2x%b = x * t2%b
end function tensor2odd_complex
pure function tensor2odd_dcomplex (t2, x) result (t2x)
type(tensor2odd), intent(in) :: t2
complex(kind=default), intent(in) :: x
type(tensor2odd) :: t2x
t2x%e = x * t2%e
t2x%b = x * t2%b
end function tensor2odd_dcomplex
@
\subsubsection{Unary Plus and Minus}
<<Declaration of operations for vectors>>=
interface operator (+)
module procedure plus_momentum, plus_vector, plus_tensor2odd
end interface
private :: plus_momentum, plus_vector, plus_tensor2odd
interface operator (-)
module procedure neg_momentum, neg_vector, neg_tensor2odd
end interface
private :: neg_momentum, neg_vector, neg_tensor2odd
@
<<Implementation of operations for vectors>>=
pure function plus_momentum (x) result (plus_x)
type(momentum), intent(in) :: x
type(momentum) :: plus_x
plus_x = x
end function plus_momentum
pure function neg_momentum (x) result (neg_x)
type(momentum), intent(in) :: x
type(momentum) :: neg_x
neg_x%t = - x%t
neg_x%x = - x%x
end function neg_momentum
@
<<Implementation of operations for vectors>>=
pure function plus_vector (x) result (plus_x)
type(vector), intent(in) :: x
type(vector) :: plus_x
plus_x = x
end function plus_vector
pure function neg_vector (x) result (neg_x)
type(vector), intent(in) :: x
type(vector) :: neg_x
neg_x%t = - x%t
neg_x%x = - x%x
end function neg_vector
@
<<Implementation of operations for vectors>>=
pure function plus_tensor2odd (x) result (plus_x)
type(tensor2odd), intent(in) :: x
type(tensor2odd) :: plus_x
plus_x = x
end function plus_tensor2odd
pure function neg_tensor2odd (x) result (neg_x)
type(tensor2odd), intent(in) :: x
type(tensor2odd) :: neg_x
neg_x%e = - x%e
neg_x%b = - x%b
end function neg_tensor2odd
@
\subsubsection{Addition and Subtraction}
<<Declaration of operations for vectors>>=
interface operator (+)
module procedure add_momentum, add_vector, &
add_vector_momentum, add_momentum_vector, add_tensor2odd
end interface
private :: add_momentum, add_vector, add_vector_momentum, &
add_momentum_vector, add_tensor2odd
interface operator (-)
module procedure sub_momentum, sub_vector, &
sub_vector_momentum, sub_momentum_vector, sub_tensor2odd
end interface
private :: sub_momentum, sub_vector, sub_vector_momentum, &
sub_momentum_vector, sub_tensor2odd
@
<<Implementation of operations for vectors>>=
pure function add_momentum (x, y) result (xy)
type(momentum), intent(in) :: x, y
type(momentum) :: xy
xy%t = x%t + y%t
xy%x = x%x + y%x
end function add_momentum
pure function add_vector (x, y) result (xy)
type(vector), intent(in) :: x, y
type(vector) :: xy
xy%t = x%t + y%t
xy%x = x%x + y%x
end function add_vector
pure function add_momentum_vector (x, y) result (xy)
type(momentum), intent(in) :: x
type(vector), intent(in) :: y
type(vector) :: xy
xy%t = x%t + y%t
xy%x = x%x + y%x
end function add_momentum_vector
pure function add_vector_momentum (x, y) result (xy)
type(vector), intent(in) :: x
type(momentum), intent(in) :: y
type(vector) :: xy
xy%t = x%t + y%t
xy%x = x%x + y%x
end function add_vector_momentum
pure function add_tensor2odd (x, y) result (xy)
type(tensor2odd), intent(in) :: x, y
type(tensor2odd) :: xy
xy%e = x%e + y%e
xy%b = x%b + y%b
end function add_tensor2odd
@
<<Implementation of operations for vectors>>=
pure function sub_momentum (x, y) result (xy)
type(momentum), intent(in) :: x, y
type(momentum) :: xy
xy%t = x%t - y%t
xy%x = x%x - y%x
end function sub_momentum
pure function sub_vector (x, y) result (xy)
type(vector), intent(in) :: x, y
type(vector) :: xy
xy%t = x%t - y%t
xy%x = x%x - y%x
end function sub_vector
pure function sub_momentum_vector (x, y) result (xy)
type(momentum), intent(in) :: x
type(vector), intent(in) :: y
type(vector) :: xy
xy%t = x%t - y%t
xy%x = x%x - y%x
end function sub_momentum_vector
pure function sub_vector_momentum (x, y) result (xy)
type(vector), intent(in) :: x
type(momentum), intent(in) :: y
type(vector) :: xy
xy%t = x%t - y%t
xy%x = x%x - y%x
end function sub_vector_momentum
pure function sub_tensor2odd (x, y) result (xy)
type(tensor2odd), intent(in) :: x, y
type(tensor2odd) :: xy
xy%e = x%e - y%e
xy%b = x%b - y%b
end function sub_tensor2odd
@
\subsection{Norm}
\emph{Not} the covariant length!
<<Declaration of operations for vectors>>=
interface abs
module procedure abs_momentum, abs_vector, abs_tensor2odd
end interface
private :: abs_momentum, abs_vector, abs_tensor2odd
@
<<Implementation of operations for vectors>>=
pure function abs_momentum (x) result (absx)
type(momentum), intent(in) :: x
real(kind=default) :: absx
absx = sqrt (real (x%t*x%t + dot_product (x%x, x%x)))
end function abs_momentum
pure function abs_vector (x) result (absx)
type(vector), intent(in) :: x
real(kind=default) :: absx
absx = sqrt (real (conjg(x%t)*x%t + dot_product (x%x, x%x)))
end function abs_vector
pure function abs_tensor2odd (x) result (absx)
type(tensor2odd), intent(in) :: x
real(kind=default) :: absx
absx = sqrt (real (dot_product (x%e, x%e) + dot_product (x%b, x%b)))
end function abs_tensor2odd
@
\subsection{Conjugation}
<<Declaration of operations for vectors>>=
interface conjg
module procedure conjg_momentum, conjg_vector, conjg_tensor2odd
end interface
private :: conjg_momentum, conjg_vector, conjg_tensor2odd
@
<<Implementation of operations for vectors>>=
pure function conjg_momentum (x) result (conjg_x)
type(momentum), intent(in) :: x
type(momentum) :: conjg_x
conjg_x = x
end function conjg_momentum
pure function conjg_vector (x) result (conjg_x)
type(vector), intent(in) :: x
type(vector) :: conjg_x
conjg_x%t = conjg (x%t)
conjg_x%x = conjg (x%x)
end function conjg_vector
pure function conjg_tensor2odd (t2) result (conjg_t2)
type(tensor2odd), intent(in) :: t2
type(tensor2odd) :: conjg_t2
conjg_t2%e = conjg (t2%e)
conjg_t2%b = conjg (t2%b)
end function conjg_tensor2odd
@
\subsection{$\epsilon$-Tensors}
\begin{equation}
\epsilon_{0123} = 1 = - \epsilon^{0123}
\end{equation}
in particular
\begin{equation}
\epsilon(p_1,p_2,p_3,p_4)
= \epsilon_{\mu_1\mu_2\mu_3\mu_4}
p_1^{\mu_1}p_2^{\mu_2}p_3^{\mu_3}p_4^{\mu_4}
= p_1^0 p_2^1 p_3^2 p_4^3 \pm \ldots
\end{equation}
<<Declaration of operations for vectors>>=
interface pseudo_scalar
module procedure pseudo_scalar_momentum, pseudo_scalar_vector, &
pseudo_scalar_vec_mom
end interface
public :: pseudo_scalar
private :: pseudo_scalar_momentum, pseudo_scalar_vector
@
<<Implementation of operations for vectors>>=
pure function pseudo_scalar_momentum (p1, p2, p3, p4) result (eps1234)
type(momentum), intent(in) :: p1, p2, p3, p4
real(kind=default) :: eps1234
eps1234 = &
p1%t * p2%x(1) * (p3%x(2) * p4%x(3) - p3%x(3) * p4%x(2)) &
+ p1%t * p2%x(2) * (p3%x(3) * p4%x(1) - p3%x(1) * p4%x(3)) &
+ p1%t * p2%x(3) * (p3%x(1) * p4%x(2) - p3%x(2) * p4%x(1)) &
- p1%x(1) * p2%x(2) * (p3%x(3) * p4%t - p3%t * p4%x(3)) &
- p1%x(1) * p2%x(3) * (p3%t * p4%x(2) - p3%x(2) * p4%t ) &
- p1%x(1) * p2%t * (p3%x(2) * p4%x(3) - p3%x(3) * p4%x(2)) &
+ p1%x(2) * p2%x(3) * (p3%t * p4%x(1) - p3%x(1) * p4%t ) &
+ p1%x(2) * p2%t * (p3%x(1) * p4%x(3) - p3%x(3) * p4%x(1)) &
+ p1%x(2) * p2%x(1) * (p3%x(3) * p4%t - p3%t * p4%x(3)) &
- p1%x(3) * p2%t * (p3%x(1) * p4%x(2) - p3%x(2) * p4%x(1)) &
- p1%x(3) * p2%x(1) * (p3%x(2) * p4%t - p3%t * p4%x(2)) &
- p1%x(3) * p2%x(2) * (p3%t * p4%x(1) - p3%x(1) * p4%t )
end function pseudo_scalar_momentum
@
<<Implementation of operations for vectors>>=
pure function pseudo_scalar_vector (p1, p2, p3, p4) result (eps1234)
type(vector), intent(in) :: p1, p2, p3, p4
complex(kind=default) :: eps1234
eps1234 = &
p1%t * p2%x(1) * (p3%x(2) * p4%x(3) - p3%x(3) * p4%x(2)) &
+ p1%t * p2%x(2) * (p3%x(3) * p4%x(1) - p3%x(1) * p4%x(3)) &
+ p1%t * p2%x(3) * (p3%x(1) * p4%x(2) - p3%x(2) * p4%x(1)) &
- p1%x(1) * p2%x(2) * (p3%x(3) * p4%t - p3%t * p4%x(3)) &
- p1%x(1) * p2%x(3) * (p3%t * p4%x(2) - p3%x(2) * p4%t ) &
- p1%x(1) * p2%t * (p3%x(2) * p4%x(3) - p3%x(3) * p4%x(2)) &
+ p1%x(2) * p2%x(3) * (p3%t * p4%x(1) - p3%x(1) * p4%t ) &
+ p1%x(2) * p2%t * (p3%x(1) * p4%x(3) - p3%x(3) * p4%x(1)) &
+ p1%x(2) * p2%x(1) * (p3%x(3) * p4%t - p3%t * p4%x(3)) &
- p1%x(3) * p2%t * (p3%x(1) * p4%x(2) - p3%x(2) * p4%x(1)) &
- p1%x(3) * p2%x(1) * (p3%x(2) * p4%t - p3%t * p4%x(2)) &
- p1%x(3) * p2%x(2) * (p3%t * p4%x(1) - p3%x(1) * p4%t )
end function pseudo_scalar_vector
@
<<Implementation of operations for vectors>>=
pure function pseudo_scalar_vec_mom (p1, v1, p2, v2) result (eps1234)
type(momentum), intent(in) :: p1, p2
type(vector), intent(in) :: v1, v2
complex(kind=default) :: eps1234
eps1234 = &
p1%t * v1%x(1) * (p2%x(2) * v2%x(3) - p2%x(3) * v2%x(2)) &
+ p1%t * v1%x(2) * (p2%x(3) * v2%x(1) - p2%x(1) * v2%x(3)) &
+ p1%t * v1%x(3) * (p2%x(1) * v2%x(2) - p2%x(2) * v2%x(1)) &
- p1%x(1) * v1%x(2) * (p2%x(3) * v2%t - p2%t * v2%x(3)) &
- p1%x(1) * v1%x(3) * (p2%t * v2%x(2) - p2%x(2) * v2%t ) &
- p1%x(1) * v1%t * (p2%x(2) * v2%x(3) - p2%x(3) * v2%x(2)) &
+ p1%x(2) * v1%x(3) * (p2%t * v2%x(1) - p2%x(1) * v2%t ) &
+ p1%x(2) * v1%t * (p2%x(1) * v2%x(3) - p2%x(3) * v2%x(1)) &
+ p1%x(2) * v1%x(1) * (p2%x(3) * v2%t - p2%t * v2%x(3)) &
- p1%x(3) * v1%t * (p2%x(1) * v2%x(2) - p2%x(2) * v2%x(1)) &
- p1%x(3) * v1%x(1) * (p2%x(2) * v2%t - p2%t * v2%x(2)) &
- p1%x(3) * v1%x(2) * (p2%t * v2%x(1) - p2%x(1) * v2%t )
end function pseudo_scalar_vec_mom
@
\begin{equation}
\epsilon_\mu(p_1,p_2,p_3)
= \epsilon_{\mu\mu_1\mu_2\mu_3}
p_1^{\mu_1}p_2^{\mu_2}p_3^{\mu_3}
\end{equation}
i.\,e.
\begin{subequations}
\begin{align}
\epsilon_0(p_1,p_2,p_3) &= p_1^1 p_2^2 p_3^3 \pm \ldots \\
\epsilon_1(p_1,p_2,p_3) &= p_1^2 p_2^3 p_3^0 \pm \ldots \\
\epsilon_2(p_1,p_2,p_3) &= - p_1^3 p_2^0 p_3^1 \pm \ldots \\
\epsilon_3(p_1,p_2,p_3) &= p_1^0 p_2^1 p_3^2 \pm \ldots
\end{align}
\end{subequations}
<<Declaration of operations for vectors>>=
interface pseudo_vector
module procedure pseudo_vector_momentum, pseudo_vector_vector, &
pseudo_vector_vec_mom
end interface
public :: pseudo_vector
private :: pseudo_vector_momentum, pseudo_vector_vector
@
<<Implementation of operations for vectors>>=
pure function pseudo_vector_momentum (p1, p2, p3) result (eps123)
type(momentum), intent(in) :: p1, p2, p3
type(momentum) :: eps123
eps123%t = &
+ p1%x(1) * (p2%x(2) * p3%x(3) - p2%x(3) * p3%x(2)) &
+ p1%x(2) * (p2%x(3) * p3%x(1) - p2%x(1) * p3%x(3)) &
+ p1%x(3) * (p2%x(1) * p3%x(2) - p2%x(2) * p3%x(1))
eps123%x(1) = &
+ p1%x(2) * (p2%x(3) * p3%t - p2%t * p3%x(3)) &
+ p1%x(3) * (p2%t * p3%x(2) - p2%x(2) * p3%t ) &
+ p1%t * (p2%x(2) * p3%x(3) - p2%x(3) * p3%x(2))
eps123%x(2) = &
- p1%x(3) * (p2%t * p3%x(1) - p2%x(1) * p3%t ) &
- p1%t * (p2%x(1) * p3%x(3) - p2%x(3) * p3%x(1)) &
- p1%x(1) * (p2%x(3) * p3%t - p2%t * p3%x(3))
eps123%x(3) = &
+ p1%t * (p2%x(1) * p3%x(2) - p2%x(2) * p3%x(1)) &
+ p1%x(1) * (p2%x(2) * p3%t - p2%t * p3%x(2)) &
+ p1%x(2) * (p2%t * p3%x(1) - p2%x(1) * p3%t )
end function pseudo_vector_momentum
@
<<Implementation of operations for vectors>>=
pure function pseudo_vector_vector (p1, p2, p3) result (eps123)
type(vector), intent(in) :: p1, p2, p3
type(vector) :: eps123
eps123%t = &
+ p1%x(1) * (p2%x(2) * p3%x(3) - p2%x(3) * p3%x(2)) &
+ p1%x(2) * (p2%x(3) * p3%x(1) - p2%x(1) * p3%x(3)) &
+ p1%x(3) * (p2%x(1) * p3%x(2) - p2%x(2) * p3%x(1))
eps123%x(1) = &
+ p1%x(2) * (p2%x(3) * p3%t - p2%t * p3%x(3)) &
+ p1%x(3) * (p2%t * p3%x(2) - p2%x(2) * p3%t ) &
+ p1%t * (p2%x(2) * p3%x(3) - p2%x(3) * p3%x(2))
eps123%x(2) = &
- p1%x(3) * (p2%t * p3%x(1) - p2%x(1) * p3%t ) &
- p1%t * (p2%x(1) * p3%x(3) - p2%x(3) * p3%x(1)) &
- p1%x(1) * (p2%x(3) * p3%t - p2%t * p3%x(3))
eps123%x(3) = &
+ p1%t * (p2%x(1) * p3%x(2) - p2%x(2) * p3%x(1)) &
+ p1%x(1) * (p2%x(2) * p3%t - p2%t * p3%x(2)) &
+ p1%x(2) * (p2%t * p3%x(1) - p2%x(1) * p3%t )
end function pseudo_vector_vector
@
<<Implementation of operations for vectors>>=
pure function pseudo_vector_vec_mom (p1, p2, v) result (eps123)
type(momentum), intent(in) :: p1, p2
type(vector), intent(in) :: v
type(vector) :: eps123
eps123%t = &
+ p1%x(1) * (p2%x(2) * v%x(3) - p2%x(3) * v%x(2)) &
+ p1%x(2) * (p2%x(3) * v%x(1) - p2%x(1) * v%x(3)) &
+ p1%x(3) * (p2%x(1) * v%x(2) - p2%x(2) * v%x(1))
eps123%x(1) = &
+ p1%x(2) * (p2%x(3) * v%t - p2%t * v%x(3)) &
+ p1%x(3) * (p2%t * v%x(2) - p2%x(2) * v%t ) &
+ p1%t * (p2%x(2) * v%x(3) - p2%x(3) * v%x(2))
eps123%x(2) = &
- p1%x(3) * (p2%t * v%x(1) - p2%x(1) * v%t ) &
- p1%t * (p2%x(1) * v%x(3) - p2%x(3) * v%x(1)) &
- p1%x(1) * (p2%x(3) * v%t - p2%t * v%x(3))
eps123%x(3) = &
+ p1%t * (p2%x(1) * v%x(2) - p2%x(2) * v%x(1)) &
+ p1%x(1) * (p2%x(2) * v%t - p2%t * v%x(2)) &
+ p1%x(2) * (p2%t * v%x(1) - p2%x(1) * v%t )
end function pseudo_vector_vec_mom
@
\subsection{Utilities}
<<Declaration of operations for vectors>>=
@
<<Implementation of operations for vectors>>=
subroutine random_momentum (p, pabs, m)
type(momentum), intent(out) :: p
real(kind=default), intent(in) :: pabs, m
real(kind=default), dimension(2) :: r
real(kind=default) :: phi, cos_th
call random_number (r)
phi = 2*PI * r(1)
cos_th = 2 * r(2) - 1
p%t = sqrt (pabs**2 + m**2)
p%x = pabs * (/ cos_th * cos(phi), cos_th * sin(phi), sqrt (1 - cos_th**2) /)
end subroutine random_momentum
@
\section{Polarization vectors}
<<[[omega_polarizations.f90]]>>=
<<Copyleft>>
module omega_polarizations
use kinds
use constants
use omega_vectors
implicit none
private
<<Declaration of polarization vectors>>
integer, parameter, public :: omega_polarizations_2010_01_A = 0
contains
<<Implementation of polarization vectors>>
end module omega_polarizations
@
Here we use a phase convention for the polarization vectors compatible
with the angular momentum coupling to spin 3/2 and spin 2.
\begin{subequations}
\begin{align}
\epsilon^\mu_1(k) &=
\frac{1}{|\vec k|\sqrt{k_x^2+k_y^2}}
\left(0; k_z k_x, k_y k_z, - k_x^2 - k_y^2\right) \\
\epsilon^\mu_2(k) &=
\frac{1}{\sqrt{k_x^2+k_y^2}}
\left(0; -k_y, k_x, 0\right) \\
\epsilon^\mu_3(k) &=
\frac{k_0}{m|\vec k|} \left({\vec k}^2/k_0; k_x, k_y, k_z\right)
\end{align}
\end{subequations}
and
\begin{subequations}
\begin{align}
\epsilon^\mu_\pm(k) &=
\frac{1}{\sqrt{2}} (\epsilon^\mu_1(k) \pm \ii\epsilon^\mu_2(k) ) \\
\epsilon^\mu_0(k) &= \epsilon^\mu_3(k)
\end{align}
\end{subequations}
i.\,e.
\begin{subequations}
\begin{align}
\epsilon^\mu_+(k) &=
\frac{1}{\sqrt{2}\sqrt{k_x^2+k_y^2}}
\left(0; \frac{k_zk_x}{|\vec k|} - \ii k_y,
\frac{k_yk_z}{|\vec k|} + \ii k_x,
- \frac{k_x^2+k_y^2}{|\vec k|}\right) \\
\epsilon^\mu_-(k) &=
\frac{1}{\sqrt{2}\sqrt{k_x^2+k_y^2}}
\left(0; \frac{k_zk_x}{|\vec k|} + \ii k_y,
\frac{k_yk_z}{|\vec k|} - \ii k_x,
-\frac{k_x^2+k_y^2}{|\vec k|}\right) \\
\epsilon^\mu_0(k) &=
\frac{k_0}{m|\vec k|} \left({\vec k}^2/k_0; k_x, k_y, k_z\right)
\end{align}
\end{subequations}
Determining the mass from the momenta is a numerically haphazardous for
light particles. Therefore, we accept some redundancy and pass the
mass explicitely.
<<Declaration of polarization vectors>>=
public :: eps
@
<<Implementation of polarization vectors>>=
pure function eps (m, k, s) result (e)
type(vector) :: e
real(kind=default), intent(in) :: m
type(momentum), intent(in) :: k
integer, intent(in) :: s
real(kind=default) :: kt, kabs, kabs2, sqrt2
sqrt2 = sqrt (2.0_default)
kabs2 = dot_product (k%x, k%x)
e%t = 0
e%x = 0
if (kabs2 > 0) then
kabs = sqrt (kabs2)
select case (s)
case (1)
kt = sqrt (k%x(1)**2 + k%x(2)**2)
if (abs(kt) <= epsilon(kt) * kabs) then
if (k%x(3) > 0) then
e%x(1) = cmplx ( 1, 0, kind=default) / sqrt2
e%x(2) = cmplx ( 0, 1, kind=default) / sqrt2
else
e%x(1) = cmplx ( - 1, 0, kind=default) / sqrt2
e%x(2) = cmplx ( 0, 1, kind=default) / sqrt2
end if
else
e%x(1) = cmplx ( k%x(3)*k%x(1)/kabs, &
- k%x(2), kind=default) / kt / sqrt2
e%x(2) = cmplx ( k%x(2)*k%x(3)/kabs, &
k%x(1), kind=default) / kt / sqrt2
e%x(3) = - kt / kabs / sqrt2
end if
case (-1)
kt = sqrt (k%x(1)**2 + k%x(2)**2)
if (abs(kt) <= epsilon(kt) * kabs) then
if (k%x(3) > 0) then
e%x(1) = cmplx ( 1, 0, kind=default) / sqrt2
e%x(2) = cmplx ( 0, - 1, kind=default) / sqrt2
else
e%x(1) = cmplx ( -1, 0, kind=default) / sqrt2
e%x(2) = cmplx ( 0, - 1, kind=default) / sqrt2
end if
else
e%x(1) = cmplx ( k%x(3)*k%x(1)/kabs, &
k%x(2), kind=default) / kt / sqrt2
e%x(2) = cmplx ( k%x(2)*k%x(3)/kabs, &
- k%x(1), kind=default) / kt / sqrt2
e%x(3) = - kt / kabs / sqrt2
end if
case (0)
if (m > 0) then
e%t = kabs / m
e%x = k%t / (m*kabs) * k%x
end if
case (3)
e = (0,1) * k
case (4)
if (m > 0) then
e = (1 / m) * k
else
e = (1 / k%t) * k
end if
end select
else !!! for particles in their rest frame defined to be
!!! polarized along the 3-direction
select case (s)
case (1)
e%x(1) = cmplx ( 1, 0, kind=default) / sqrt2
e%x(2) = cmplx ( 0, 1, kind=default) / sqrt2
case (-1)
e%x(1) = cmplx ( 1, 0, kind=default) / sqrt2
e%x(2) = cmplx ( 0, - 1, kind=default) / sqrt2
case (0)
if (m > 0) then
e%x(3) = 1
end if
case (4)
if (m > 0) then
e = (1 / m) * k
else
e = (1 / k%t) * k
end if
end select
end if
end function eps
@
\section{Polarization vectors revisited}
<<[[omega_polarizations_madgraph.f90]]>>=
<<Copyleft>>
module omega_polarizations_madgraph
use kinds
use constants
use omega_vectors
implicit none
private
<<Declaration of polarization vectors for madgraph>>
integer, parameter, public :: omega_pols_madgraph_2010_01_A = 0
contains
<<Implementation of polarization vectors for madgraph>>
end module omega_polarizations_madgraph
@
This set of polarization vectors is compatible with HELAS~\cite{HELAS}:
\begin{subequations}
\begin{align}
\epsilon^\mu_1(k) &=
\frac{1}{|\vec k|\sqrt{k_x^2+k_y^2}}
\left(0; k_z k_x, k_y k_z, - k_x^2 - k_y^2\right) \\
\epsilon^\mu_2(k) &=
\frac{1}{\sqrt{k_x^2+k_y^2}}
\left(0; -k_y, k_x, 0\right) \\
\epsilon^\mu_3(k) &=
\frac{k_0}{m|\vec k|} \left({\vec k}^2/k_0; k_x, k_y, k_z\right)
\end{align}
\end{subequations}
and
\begin{subequations}
\begin{align}
\epsilon^\mu_\pm(k) &=
\frac{1}{\sqrt{2}} (\mp \epsilon^\mu_1(k) - \ii\epsilon^\mu_2(k) ) \\
\epsilon^\mu_0(k) &= \epsilon^\mu_3(k)
\end{align}
\end{subequations}
i.\,e.
\begin{subequations}
\begin{align}
\epsilon^\mu_+(k) &=
\frac{1}{\sqrt{2}\sqrt{k_x^2+k_y^2}}
\left(0; -\frac{k_zk_x}{|\vec k|} + \ii k_y,
-\frac{k_yk_z}{|\vec k|} - \ii k_x,
\frac{k_x^2+k_y^2}{|\vec k|}\right) \\
\epsilon^\mu_-(k) &=
\frac{1}{\sqrt{2}\sqrt{k_x^2+k_y^2}}
\left(0; \frac{k_zk_x}{|\vec k|} + \ii k_y,
\frac{k_yk_z}{|\vec k|} - \ii k_x,
-\frac{k_x^2+k_y^2}{|\vec k|}\right) \\
\epsilon^\mu_0(k) &=
\frac{k_0}{m|\vec k|} \left({\vec k}^2/k_0; k_x, k_y, k_z\right)
\end{align}
\end{subequations}
Fortunately, for comparing with squared matrix generated by Madgraph
we can also use the modified version, since the difference is only a
phase and does \emph{not} mix helicity states.
@ Determining the mass from the momenta is a numerically haphazardous for
light particles. Therefore, we accept some redundancy and pass the
mass explicitely.
<<Declaration of polarization vectors for madgraph>>=
public :: eps
@
<<Implementation of polarization vectors for madgraph>>=
pure function eps (m, k, s) result (e)
type(vector) :: e
real(kind=default), intent(in) :: m
type(momentum), intent(in) :: k
integer, intent(in) :: s
real(kind=default) :: kt, kabs, kabs2, sqrt2
sqrt2 = sqrt (2.0_default)
kabs2 = dot_product (k%x, k%x)
e%t = 0
e%x = 0
if (kabs2 > 0) then
kabs = sqrt (kabs2)
select case (s)
case (1)
kt = sqrt (k%x(1)**2 + k%x(2)**2)
if (abs(kt) <= epsilon(kt) * kabs) then
if (k%x(3) > 0) then
e%x(1) = cmplx ( - 1, 0, kind=default) / sqrt2
e%x(2) = cmplx ( 0, - 1, kind=default) / sqrt2
else
e%x(1) = cmplx ( 1, 0, kind=default) / sqrt2
e%x(2) = cmplx ( 0, - 1, kind=default) / sqrt2
end if
else
e%x(1) = cmplx ( - k%x(3)*k%x(1)/kabs, &
k%x(2), kind=default) / kt / sqrt2
e%x(2) = cmplx ( - k%x(2)*k%x(3)/kabs, &
- k%x(1), kind=default) / kt / sqrt2
e%x(3) = kt / kabs / sqrt2
end if
case (-1)
kt = sqrt (k%x(1)**2 + k%x(2)**2)
if (abs(kt) <= epsilon(kt) * kabs) then
if (k%x(3) > 0) then
e%x(1) = cmplx ( 1, 0, kind=default) / sqrt2
e%x(2) = cmplx ( 0, - 1, kind=default) / sqrt2
else
e%x(1) = cmplx ( -1, 0, kind=default) / sqrt2
e%x(2) = cmplx ( 0, - 1, kind=default) / sqrt2
end if
else
e%x(1) = cmplx ( k%x(3)*k%x(1)/kabs, &
k%x(2), kind=default) / kt / sqrt2
e%x(2) = cmplx ( k%x(2)*k%x(3)/kabs, &
- k%x(1), kind=default) / kt / sqrt2
e%x(3) = - kt / kabs / sqrt2
end if
case (0)
if (m > 0) then
e%t = kabs / m
e%x = k%t / (m*kabs) * k%x
end if
case (3)
e = (0,1) * k
case (4)
if (m > 0) then
e = (1 / m) * k
else
e = (1 / k%t) * k
end if
end select
else !!! for particles in their rest frame defined to be
!!! polarized along the 3-direction
select case (s)
case (1)
e%x(1) = cmplx ( - 1, 0, kind=default) / sqrt2
e%x(2) = cmplx ( 0, - 1, kind=default) / sqrt2
case (-1)
e%x(1) = cmplx ( 1, 0, kind=default) / sqrt2
e%x(2) = cmplx ( 0, - 1, kind=default) / sqrt2
case (0)
if (m > 0) then
e%x(3) = 1
end if
case (4)
if (m > 0) then
e = (1 / m) * k
else
e = (1 / k%t) * k
end if
end select
end if
end function eps
@
\section{Symmetric Tensors}
Spin-2 polarization tensors are symmetric, transversal and traceless
\begin{subequations}
\begin{align}
\epsilon^{\mu\nu}_{m}(k) &= \epsilon^{\nu\mu}_{m}(k) \\
k_\mu \epsilon^{\mu\nu}_{m}(k) &= k_\nu \epsilon^{\mu\nu}_{m}(k) = 0 \\
\epsilon^{\mu}_{m,\mu}(k) &= 0
\end{align}
\end{subequations}
with $m=1,2,3,4,5$. Our current representation is redundant and does
\emph{not} enforce symmetry or tracelessness.
<<[[omega_tensors.f90]]>>=
<<Copyleft>>
module omega_tensors
use kinds
use constants
use omega_vectors
implicit none
private
public :: operator (*), operator (+), operator (-), &
operator (.tprod.)
public :: abs, conjg, set_zero
<<[[intrinsic :: abs]]>>
<<[[intrinsic :: conjg]]>>
type, public :: tensor
! private (omegalib needs access, but DON'T TOUCH IT!)
complex(kind=default), dimension(0:3,0:3) :: t
end type tensor
<<Declaration of operations for tensors>>
integer, parameter, public :: omega_tensors_2010_01_A = 0
contains
<<Implementation of operations for tensors>>
end module omega_tensors
@
\subsection{Vector Space}
<<Declaration of operations for tensors>>=
interface set_zero
module procedure set_zero_tensor
end interface
private :: set_zero_tensor
@
<<Implementation of operations for tensors>>=
elemental subroutine set_zero_tensor (x)
type(tensor), intent(out) :: x
x%t = 0
end subroutine set_zero_tensor
@
\subsubsection{Scalar Multliplication}
<<Declaration of operations for tensors>>=
interface operator (*)
module procedure integer_tensor, real_tensor, double_tensor, &
complex_tensor, dcomplex_tensor
end interface
private :: integer_tensor, real_tensor, double_tensor
private :: complex_tensor, dcomplex_tensor
@
<<Implementation of operations for tensors>>=
pure function integer_tensor (x, y) result (xy)
integer, intent(in) :: x
type(tensor), intent(in) :: y
type(tensor) :: xy
xy%t = x * y%t
end function integer_tensor
pure function real_tensor (x, y) result (xy)
real(kind=single), intent(in) :: x
type(tensor), intent(in) :: y
type(tensor) :: xy
xy%t = x * y%t
end function real_tensor
pure function double_tensor (x, y) result (xy)
real(kind=default), intent(in) :: x
type(tensor), intent(in) :: y
type(tensor) :: xy
xy%t = x * y%t
end function double_tensor
pure function complex_tensor (x, y) result (xy)
complex(kind=single), intent(in) :: x
type(tensor), intent(in) :: y
type(tensor) :: xy
xy%t = x * y%t
end function complex_tensor
pure function dcomplex_tensor (x, y) result (xy)
complex(kind=default), intent(in) :: x
type(tensor), intent(in) :: y
type(tensor) :: xy
xy%t = x * y%t
end function dcomplex_tensor
@
\subsubsection{Addition and Subtraction}
<<Declaration of operations for tensors>>=
interface operator (+)
module procedure plus_tensor
end interface
private :: plus_tensor
interface operator (-)
module procedure neg_tensor
end interface
private :: neg_tensor
@
<<Implementation of operations for tensors>>=
pure function plus_tensor (t1) result (t2)
type(tensor), intent(in) :: t1
type(tensor) :: t2
t2 = t1
end function plus_tensor
pure function neg_tensor (t1) result (t2)
type(tensor), intent(in) :: t1
type(tensor) :: t2
t2%t = - t1%t
end function neg_tensor
@
<<Declaration of operations for tensors>>=
interface operator (+)
module procedure add_tensor
end interface
private :: add_tensor
interface operator (-)
module procedure sub_tensor
end interface
private :: sub_tensor
@
<<Implementation of operations for tensors>>=
pure function add_tensor (x, y) result (xy)
type(tensor), intent(in) :: x, y
type(tensor) :: xy
xy%t = x%t + y%t
end function add_tensor
pure function sub_tensor (x, y) result (xy)
type(tensor), intent(in) :: x, y
type(tensor) :: xy
xy%t = x%t - y%t
end function sub_tensor
@
<<Declaration of operations for tensors>>=
interface operator (.tprod.)
module procedure out_prod_vv, out_prod_vm, &
out_prod_mv, out_prod_mm
end interface
private :: out_prod_vv, out_prod_vm, &
out_prod_mv, out_prod_mm
@
<<Implementation of operations for tensors>>=
pure function out_prod_vv (v, w) result (t)
type(tensor) :: t
type(vector), intent(in) :: v, w
integer :: i, j
t%t(0,0) = v%t * w%t
t%t(0,1:3) = v%t * w%x
t%t(1:3,0) = v%x * w%t
do i = 1, 3
do j = 1, 3
t%t(i,j) = v%x(i) * w%x(j)
end do
end do
end function out_prod_vv
@
<<Implementation of operations for tensors>>=
pure function out_prod_vm (v, m) result (t)
type(tensor) :: t
type(vector), intent(in) :: v
type(momentum), intent(in) :: m
integer :: i, j
t%t(0,0) = v%t * m%t
t%t(0,1:3) = v%t * m%x
t%t(1:3,0) = v%x * m%t
do i = 1, 3
do j = 1, 3
t%t(i,j) = v%x(i) * m%x(j)
end do
end do
end function out_prod_vm
@
<<Implementation of operations for tensors>>=
pure function out_prod_mv (m, v) result (t)
type(tensor) :: t
type(vector), intent(in) :: v
type(momentum), intent(in) :: m
integer :: i, j
t%t(0,0) = m%t * v%t
t%t(0,1:3) = m%t * v%x
t%t(1:3,0) = m%x * v%t
do i = 1, 3
do j = 1, 3
t%t(i,j) = m%x(i) * v%x(j)
end do
end do
end function out_prod_mv
@
<<Implementation of operations for tensors>>=
pure function out_prod_mm (m, n) result (t)
type(tensor) :: t
type(momentum), intent(in) :: m, n
integer :: i, j
t%t(0,0) = m%t * n%t
t%t(0,1:3) = m%t * n%x
t%t(1:3,0) = m%x * n%t
do i = 1, 3
do j = 1, 3
t%t(i,j) = m%x(i) * n%x(j)
end do
end do
end function out_prod_mm
@
<<Declaration of operations for tensors>>=
interface abs
module procedure abs_tensor
end interface
private :: abs_tensor
@
<<Implementation of operations for tensors>>=
pure function abs_tensor (t) result (abs_t)
type(tensor), intent(in) :: t
real(kind=default) :: abs_t
abs_t = sqrt (sum ((abs (t%t))**2))
end function abs_tensor
@
<<Declaration of operations for tensors>>=
interface conjg
module procedure conjg_tensor
end interface
private :: conjg_tensor
@
<<Implementation of operations for tensors>>=
pure function conjg_tensor (t) result (conjg_t)
type(tensor), intent(in) :: t
type(tensor) :: conjg_t
conjg_t%t = conjg (t%t)
end function conjg_tensor
@
<<Declaration of operations for tensors>>=
interface operator (*)
module procedure tensor_tensor, vector_tensor, tensor_vector, &
momentum_tensor, tensor_momentum
end interface
private :: tensor_tensor, vector_tensor, tensor_vector, &
momentum_tensor, tensor_momentum
@
<<Implementation of operations for tensors>>=
pure function tensor_tensor (t1, t2) result (t1t2)
type(tensor), intent(in) :: t1
type(tensor), intent(in) :: t2
complex(kind=default) :: t1t2
integer :: i1, i2
t1t2 = t1%t(0,0)*t2%t(0,0) &
- dot_product (conjg (t1%t(0,1:)), t2%t(0,1:)) &
- dot_product (conjg (t1%t(1:,0)), t2%t(1:,0))
do i1 = 1, 3
do i2 = 1, 3
t1t2 = t1t2 + t1%t(i1,i2)*t2%t(i1,i2)
end do
end do
end function tensor_tensor
@
<<Implementation of operations for tensors>>=
pure function tensor_vector (t, v) result (tv)
type(tensor), intent(in) :: t
type(vector), intent(in) :: v
type(vector) :: tv
tv%t = t%t(0,0) * v%t - dot_product (conjg (t%t(0,1:)), v%x)
tv%x(1) = t%t(0,1) * v%t - dot_product (conjg (t%t(1,1:)), v%x)
tv%x(2) = t%t(0,2) * v%t - dot_product (conjg (t%t(2,1:)), v%x)
tv%x(3) = t%t(0,3) * v%t - dot_product (conjg (t%t(3,1:)), v%x)
end function tensor_vector
@
<<Implementation of operations for tensors>>=
pure function vector_tensor (v, t) result (vt)
type(vector), intent(in) :: v
type(tensor), intent(in) :: t
type(vector) :: vt
vt%t = v%t * t%t(0,0) - dot_product (conjg (v%x), t%t(1:,0))
vt%x(1) = v%t * t%t(0,1) - dot_product (conjg (v%x), t%t(1:,1))
vt%x(2) = v%t * t%t(0,2) - dot_product (conjg (v%x), t%t(1:,2))
vt%x(3) = v%t * t%t(0,3) - dot_product (conjg (v%x), t%t(1:,3))
end function vector_tensor
@
<<Implementation of operations for tensors>>=
pure function tensor_momentum (t, p) result (tp)
type(tensor), intent(in) :: t
type(momentum), intent(in) :: p
type(vector) :: tp
tp%t = t%t(0,0) * p%t - dot_product (conjg (t%t(0,1:)), p%x)
tp%x(1) = t%t(0,1) * p%t - dot_product (conjg (t%t(1,1:)), p%x)
tp%x(2) = t%t(0,2) * p%t - dot_product (conjg (t%t(2,1:)), p%x)
tp%x(3) = t%t(0,3) * p%t - dot_product (conjg (t%t(3,1:)), p%x)
end function tensor_momentum
@
<<Implementation of operations for tensors>>=
pure function momentum_tensor (p, t) result (pt)
type(momentum), intent(in) :: p
type(tensor), intent(in) :: t
type(vector) :: pt
pt%t = p%t * t%t(0,0) - dot_product (p%x, t%t(1:,0))
pt%x(1) = p%t * t%t(0,1) - dot_product (p%x, t%t(1:,1))
pt%x(2) = p%t * t%t(0,2) - dot_product (p%x, t%t(1:,2))
pt%x(3) = p%t * t%t(0,3) - dot_product (p%x, t%t(1:,3))
end function momentum_tensor
@
\section{Symmetric Polarization Tensors}
\begin{subequations}
\begin{align}
\epsilon^{\mu\nu}_{+2}(k) &= \epsilon^{\mu}_{+}(k)\epsilon^{\nu}_{+}(k) \\
\epsilon^{\mu\nu}_{+1}(k) &= \frac{1}{\sqrt{2}}
\left( \epsilon^{\mu}_{+}(k)\epsilon^{\nu}_{0}(k)
+ \epsilon^{\mu}_{0}(k)\epsilon^{\nu}_{+}(k) \right) \\
\epsilon^{\mu\nu}_{0}(k) &= \frac{1}{\sqrt{6}}
\left( \epsilon^{\mu}_{+}(k)\epsilon^{\nu}_{-}(k)
+ \epsilon^{\mu}_{-}(k)\epsilon^{\nu}_{+}(k)
- 2 \epsilon^{\mu}_{0}(k)\epsilon^{\nu}_{0}(k) \right) \\
\epsilon^{\mu\nu}_{-1}(k) &= \frac{1}{\sqrt{2}}
\left( \epsilon^{\mu}_{-}(k)\epsilon^{\nu}_{0}(k)
+ \epsilon^{\mu}_{0}(k)\epsilon^{\nu}_{-}(k) \right) \\
\epsilon^{\mu\nu}_{-2}(k) &= \epsilon^{\mu}_{-}(k)\epsilon^{\nu}_{-}(k)
\end{align}
\end{subequations}
Note that~$\epsilon^{\mu}_{\pm2,\mu}(k) =
\epsilon^{\mu}_{\pm}(k)\epsilon_{\pm,\mu}(k) \propto
\epsilon^{\mu}_{\pm}(k)\epsilon_{\mp,\mu}^{*}(k) = 0$ and that the sign in
$\epsilon^{\mu\nu}_{0}(k)$ insures its tracelessness\footnote{
On the other hand, with the shift operator
$L_{-}\ket{+}=\ee^{\ii\phi}\ket{0}$ and
$L_{-}\ket{0}=\ee^{\ii\chi}\ket{-}$, we find
\begin{equation*}
L_{-}^{2}\ket{++} =
2\ee^{2\ii\phi}\ket{00} + \ee^{\ii(\phi+\chi)}(\ket{+-}+\ket{-+})
\end{equation*}
i.\,e.~$\chi-\phi=\pi$, if we want to identify
$\epsilon^{\mu}_{-,0,+}$ with $\ket{-,0,+}$.}.
<<[[omega_tensor_polarizations.f90]]>>=
<<Copyleft>>
module omega_tensor_polarizations
use kinds
use constants
use omega_vectors
use omega_tensors
use omega_polarizations
implicit none
private
<<Declaration of polarization tensors>>
integer, parameter, public :: omega_tensor_pols_2010_01_A = 0
contains
<<Implementation of polarization tensors>>
end module omega_tensor_polarizations
@
<<Declaration of polarization tensors>>=
public :: eps2
@
<<Implementation of polarization tensors>>=
pure function eps2 (m, k, s) result (t)
type(tensor) :: t
real(kind=default), intent(in) :: m
type(momentum), intent(in) :: k
integer, intent(in) :: s
type(vector) :: ep, em, e0
t%t = 0
select case (s)
case (2)
ep = eps (m, k, 1)
t = ep.tprod.ep
case (1)
ep = eps (m, k, 1)
e0 = eps (m, k, 0)
t = (1 / sqrt (2.0_default)) &
* ((ep.tprod.e0) + (e0.tprod.ep))
case (0)
ep = eps (m, k, 1)
e0 = eps (m, k, 0)
em = eps (m, k, -1)
t = (1 / sqrt (6.0_default)) &
* ((ep.tprod.em) + (em.tprod.ep) - 2*(e0.tprod.e0))
case (-1)
e0 = eps (m, k, 0)
em = eps (m, k, -1)
t = (1 / sqrt (2.0_default)) &
* ((em.tprod.e0) + (e0.tprod.em))
case (-2)
em = eps (m, k, -1)
t = em.tprod.em
end select
end function eps2
@ \section{Couplings}
<<[[omega_couplings.f90]]>>=
<<Copyleft>>
module omega_couplings
use kinds
use constants
use omega_vectors
use omega_tensors
implicit none
private
<<Declaration of couplings>>
<<Declaration of propagators>>
integer, parameter, public :: omega_couplings_2010_01_A = 0
contains
<<Implementation of couplings>>
<<Implementation of propagators>>
end module omega_couplings
@
<<Declaration of propagators>>=
public :: wd_tl
@
<<Declaration of propagators>>=
public :: wd_run
@
<<Declaration of propagators>>=
public :: gauss
@
\begin{equation}
\Theta(p^2)\Gamma
\end{equation}
<<Implementation of propagators>>=
pure function wd_tl (p, w) result (width)
real(kind=default) :: width
type(momentum), intent(in) :: p
real(kind=default), intent(in) :: w
if (p*p > 0) then
width = w
else
width = 0
end if
end function wd_tl
@
\begin{equation}
\frac{p^2}{m^2} \Gamma
\end{equation}
<<Implementation of propagators>>=
pure function wd_run (p, m, w) result (width)
real(kind=default) :: width
type(momentum), intent(in) :: p
real(kind=default), intent(in) :: m
real(kind=default), intent(in) :: w
if (p*p > 0) then
width = w * (p*p) / m**2
else
width = 0
end if
end function wd_run
@
<<Implementation of propagators>>=
pure function gauss (x, mu, w) result (gg)
real(kind=default) :: gg
real(kind=default), intent(in) :: x, mu, w
if (w > 0) then
gg = exp(-(x - mu**2)**2/4.0_default/mu**2/w**2) * &
sqrt(sqrt(PI/2)) / w / mu
else
gg = 1.0_default
end if
end function gauss
@
<<Declaration of propagators>>=
public :: pr_phi, pr_unitarity, pr_feynman, pr_gauge, pr_rxi
public :: pr_vector_pure
public :: pj_phi, pj_unitarity
public :: pg_phi, pg_unitarity
@
\begin{equation}
\frac{\ii}{p^2-m^2+\ii m\Gamma}\phi
\end{equation}
<<Implementation of propagators>>=
pure function pr_phi (p, m, w, phi) result (pphi)
complex(kind=default) :: pphi
type(momentum), intent(in) :: p
real(kind=default), intent(in) :: m, w
complex(kind=default), intent(in) :: phi
pphi = (1 / cmplx (p*p - m**2, m*w, kind=default)) * phi
end function pr_phi
@
\begin{equation}
\sqrt{\frac{\pi}{M\Gamma}}
\phi
\end{equation}
<<Implementation of propagators>>=
pure function pj_phi (m, w, phi) result (pphi)
complex(kind=default) :: pphi
real(kind=default), intent(in) :: m, w
complex(kind=default), intent(in) :: phi
pphi = (0, -1) * sqrt (PI / m / w) * phi
end function pj_phi
@
<<Implementation of propagators>>=
pure function pg_phi (p, m, w, phi) result (pphi)
complex(kind=default) :: pphi
type(momentum), intent(in) :: p
real(kind=default), intent(in) :: m, w
complex(kind=default), intent(in) :: phi
pphi = ((0, 1) * gauss (p*p, m, w)) * phi
end function pg_phi
@
\begin{equation}
\frac{\ii}{p^2-m^2+\ii m\Gamma}
\left( -g_{\mu\nu} + \frac{p_\mu p_\nu}{m^2} \right) \epsilon^\nu(p)
\end{equation}
NB: the explicit cast to [[vector]] is required here, because a specific
[[complex_momentum]] procedure for [[operator (*)]] would introduce
ambiguities.
NB: we used to use the constructor [[vector (p%t, p%x)]] instead of
the temporary variable, but the Intel Fortran Compiler choked on it.
<<Implementation of propagators>>=
pure function pr_unitarity (p, m, w, cms, e) result (pe)
type(vector) :: pe
type(momentum), intent(in) :: p
real(kind=default), intent(in) :: m, w
type(vector), intent(in) :: e
logical, intent(in) :: cms
type(vector) :: pv
complex(kind=default) :: c_mass2
pv = p
if (cms) then
c_mass2 = cmplx (m**2, -m*w, kind=default)
else
c_mass2 = m**2
end if
pe = - (1 / cmplx (p*p - m**2, m*w, kind=default)) &
* (e - (p*e / c_mass2) * pv)
end function pr_unitarity
@
\begin{equation}
\sqrt{\frac{\pi}{M\Gamma}}
\left( -g_{\mu\nu} + \frac{p_\mu p_\nu}{m^2} \right) \epsilon^\nu(p)
\end{equation}
<<Implementation of propagators>>=
pure function pj_unitarity (p, m, w, e) result (pe)
type(vector) :: pe
type(momentum), intent(in) :: p
real(kind=default), intent(in) :: m, w
type(vector), intent(in) :: e
type(vector) :: pv
pv = p
pe = (0, 1) * sqrt (PI / m / w) * (e - (p*e / m**2) * pv)
end function pj_unitarity
@
<<Implementation of propagators>>=
pure function pg_unitarity (p, m, w, e) result (pe)
type(vector) :: pe
type(momentum), intent(in) :: p
real(kind=default), intent(in) :: m, w
type(vector), intent(in) :: e
type(vector) :: pv
pv = p
pe = - gauss (p*p, m, w) &
* (e - (p*e / m**2) * pv)
end function pg_unitarity
@
\begin{equation}
\frac{-i}{p^2} \epsilon^\nu(p)
\end{equation}
<<Implementation of propagators>>=
pure function pr_feynman (p, e) result (pe)
type(vector) :: pe
type(momentum), intent(in) :: p
type(vector), intent(in) :: e
pe = - (1 / (p*p)) * e
end function pr_feynman
@
\begin{equation}
\frac{\ii}{p^2}
\left( -g_{\mu\nu} + (1-\xi)\frac{p_\mu p_\nu}{p^2} \right)
\epsilon^\nu(p)
\end{equation}
<<Implementation of propagators>>=
pure function pr_gauge (p, xi, e) result (pe)
type(vector) :: pe
type(momentum), intent(in) :: p
real(kind=default), intent(in) :: xi
type(vector), intent(in) :: e
real(kind=default) :: p2
type(vector) :: pv
p2 = p*p
pv = p
pe = - (1 / p2) * (e - ((1 - xi) * (p*e) / p2) * pv)
end function pr_gauge
@
\begin{equation}
\frac{\ii}{p^2-m^2+\ii m\Gamma}
\left( -g_{\mu\nu} + (1-\xi)\frac{p_\mu p_\nu}{p^2-\xi m^2} \right)
\epsilon^\nu(p)
\end{equation}
<<Implementation of propagators>>=
pure function pr_rxi (p, m, w, xi, e) result (pe)
type(vector) :: pe
type(momentum), intent(in) :: p
real(kind=default), intent(in) :: m, w, xi
type(vector), intent(in) :: e
real(kind=default) :: p2
type(vector) :: pv
p2 = p*p
pv = p
pe = - (1 / cmplx (p2 - m**2, m*w, kind=default)) &
* (e - ((1 - xi) * (p*e) / (p2 - xi * m**2)) * pv)
end function pr_rxi
@
\begin{equation}
\frac{\ii}{p^2-m^2+\ii m\Gamma}
\left( -g_{\mu\nu} \right)
\epsilon^\nu(p)
\end{equation}
<<Implementation of propagators>>=
pure function pr_vector_pure (p, m, w, e) result (pe)
type(vector) :: pe
type(momentum), intent(in) :: p
real(kind=default), intent(in) :: m, w
type(vector), intent(in) :: e
real(kind=default) :: p2
type(vector) :: pv
p2 = p*p
pv = p
pe = - (1 / cmplx (p2 - m**2, m*w, kind=default)) * e
end function pr_vector_pure
@
<<Declaration of propagators>>=
public :: pr_tensor, pr_tensor_pure
@
\begin{subequations}
\begin{equation}
\frac{\ii P^{\mu\nu,\rho\sigma}(p,m)}{p^2-m^2+\ii m\Gamma} T_{\rho\sigma}
\end{equation}
with
\begin{multline}
P^{\mu\nu,\rho\sigma}(p,m)
= \frac{1}{2} \left(g^{\mu\rho}-\frac{p^{\mu}p^{\nu}}{m^2}\right)
\left(g^{\nu\sigma}-\frac{p^{\nu}p^{\sigma}}{m^2}\right)
+ \frac{1}{2} \left(g^{\mu\sigma}-\frac{p^{\mu}p^{\sigma}}{m^2}\right)
\left(g^{\nu\rho}-\frac{p^{\nu}p^{\rho}}{m^2}\right) \\
- \frac{1}{3} \left(g^{\mu\nu}-\frac{p^{\mu}p^{\nu}}{m^2}\right)
\left(g^{\rho\sigma}-\frac{p^{\rho}p^{\sigma}}{m^2}\right)
\end{multline}
\end{subequations}
Be careful with raising and lowering of indices:
\begin{subequations}
\begin{align}
g^{\mu\nu}-\frac{k^{\mu}k^{\nu}}{m^2}
&= \begin{pmatrix}
1 - k^0k^0 / m^2 & - k^0 \vec k / m^2 \\
- \vec k k^0 / m^2 & - \mathbf{1} - \vec k \otimes \vec k / m^2
\end{pmatrix} \\
g^{\mu}_{\hphantom{\mu}\nu}-\frac{k^{\mu}k_{\nu}}{m^2}
&= \begin{pmatrix}
1 - k^0k^0 / m^2 & k^0 \vec k / m^2 \\
- \vec k k^0 / m^2 & \mathbf{1} + \vec k \otimes \vec k / m^2
\end{pmatrix}
\end{align}
\end{subequations}
<<Implementation of propagators>>=
pure function pr_tensor (p, m, w, t) result (pt)
type(tensor) :: pt
type(momentum), intent(in) :: p
real(kind=default), intent(in) :: m, w
type(tensor), intent(in) :: t
complex(kind=default) :: p_dd_t
real(kind=default), dimension(0:3,0:3) :: p_uu, p_ud, p_du, p_dd
integer :: i, j
p_uu(0,0) = 1 - p%t * p%t / m**2
p_uu(0,1:3) = - p%t * p%x / m**2
p_uu(1:3,0) = p_uu(0,1:3)
do i = 1, 3
do j = 1, 3
p_uu(i,j) = - p%x(i) * p%x(j) / m**2
end do
end do
do i = 1, 3
p_uu(i,i) = - 1 + p_uu(i,i)
end do
p_ud(:,0) = p_uu(:,0)
p_ud(:,1:3) = - p_uu(:,1:3)
p_du = transpose (p_ud)
p_dd(:,0) = p_du(:,0)
p_dd(:,1:3) = - p_du(:,1:3)
p_dd_t = 0
do i = 0, 3
do j = 0, 3
p_dd_t = p_dd_t + p_dd(i,j) * t%t(i,j)
end do
end do
pt%t = matmul (p_ud, matmul (0.5_default * (t%t + transpose (t%t)), p_du)) &
- (p_dd_t / 3.0_default) * p_uu
pt%t = pt%t / cmplx (p*p - m**2, m*w, kind=default)
end function pr_tensor
@
\begin{subequations}
\begin{equation}
\frac{\ii P_p^{\mu\nu,\rho\sigma}}{p^2-m^2+\ii m\Gamma} T_{\rho\sigma}
\end{equation}
with
\begin{multline}
P_p^{\mu\nu,\rho\sigma}
= \frac{1}{2} g^{\mu\rho} g^{\nu\sigma}
+ \frac{1}{2} g^{\mu\sigma} g^{\nu\rho}
- \frac{1}{2} g^{\mu\nu}g^{\rho\sigma}
\end{multline}
\end{subequations}
<<Implementation of propagators>>=
pure function pr_tensor_pure (p, m, w, t) result (pt)
type(tensor) :: pt
type(momentum), intent(in) :: p
real(kind=default), intent(in) :: m, w
type(tensor), intent(in) :: t
complex(kind=default) :: p_dd_t
real(kind=default), dimension(0:3,0:3) :: g_uu
integer :: i, j
g_uu(0,0) = 1
g_uu(0,1:3) = 0
g_uu(1:3,0) = g_uu(0,1:3)
do i = 1, 3
do j = 1, 3
g_uu(i,j) = 0
end do
end do
do i = 1, 3
g_uu(i,i) = - 1
end do
p_dd_t = t%t(0,0) - t%t(1,1) - t%t(2,2) - t%t(3,3)
pt%t = 0.5_default * ((t%t + transpose (t%t)) &
- p_dd_t * g_uu )
pt%t = pt%t / cmplx (p*p - m**2, m*w, kind=default)
end function pr_tensor_pure
@ \subsection{Triple Gauge Couplings}
<<Declaration of couplings>>=
public :: g_gg
@ According to~(\ref{eq:fuse-gauge})
\begin{multline}
A^{a,\mu}(k_1+k_2) = - \ii g
\bigl( (k_1^{\mu}-k_2^{\mu})A^{a_1}(k_1) \cdot A^{a_2}(k_2) \\
+ (2k_2+k_1)\cdot A^{a_1}(k_1)A^{a_2,\mu}(k_2)
- A^{a_1,\mu}(k_1)A^{a_2}(k_2)\cdot(2k_1+k_2) \bigr)
\end{multline}
<<Implementation of couplings>>=
pure function g_gg (g, a1, k1, a2, k2) result (a)
complex(kind=default), intent(in) :: g
type(vector), intent(in) :: a1, a2
type(momentum), intent(in) :: k1, k2
type(vector) :: a
a = (0, -1) * g * ((k1 - k2) * (a1 * a2) &
+ ((2*k2 + k1) * a1) * a2 - a1 * ((2*k1 + k2) * a2))
end function g_gg
@ \subsection{Quadruple Gauge Couplings}
<<Declaration of couplings>>=
public :: x_gg, g_gx
@
\begin{equation}
T^{a,\mu\nu}(k_1+k_2) = g
\bigl( A^{a_1,\mu}(k_1) A^{a_2,\nu}(k_2) - A^{a_1,\nu}(k_1) A^{a_2,\mu}(k_2) \bigr)
\end{equation}
<<Implementation of couplings>>=
pure function x_gg (g, a1, a2) result (x)
complex(kind=default), intent(in) :: g
type(vector), intent(in) :: a1, a2
type(tensor2odd) :: x
x = g * (a1 .wedge. a2)
end function x_gg
@
\begin{equation}
A^{a,\mu}(k_1+k_2) = g A^{a_1}_\nu(k_1) T^{a_2,\nu\mu}(k_2)
\end{equation}
<<Implementation of couplings>>=
pure function g_gx (g, a1, x) result (a)
complex(kind=default), intent(in) :: g
type(vector), intent(in) :: a1
type(tensor2odd), intent(in) :: x
type(vector) :: a
a = g * (a1 * x)
end function g_gx
@ \subsection{Scalar Current}
<<Declaration of couplings>>=
public :: v_ss, s_vs
@
\begin{equation}
V^\mu(k_1+k_2) = g(k_1^\mu - k_2^\mu)\phi_1(k_1)\phi_2(k_2)
\end{equation}
<<Implementation of couplings>>=
pure function v_ss (g, phi1, k1, phi2, k2) result (v)
complex(kind=default), intent(in) :: g, phi1, phi2
type(momentum), intent(in) :: k1, k2
type(vector) :: v
v = (k1 - k2) * (g * phi1 * phi2)
end function v_ss
@
\begin{equation}
\phi(k_1+k_2) = g(k_1^\mu + 2k_2^\mu)V_\mu(k_1)\phi(k_2)
\end{equation}
<<Implementation of couplings>>=
pure function s_vs (g, v1, k1, phi2, k2) result (phi)
complex(kind=default), intent(in) :: g, phi2
type(vector), intent(in) :: v1
type(momentum), intent(in) :: k1, k2
complex(kind=default) :: phi
phi = g * ((k1 + 2*k2) * v1) * phi2
end function s_vs
@ \subsection{Transversal Scalar-Vector Coupling}
<<Declaration of couplings>>=
public :: s_vv_t, v_sv_t
@
\begin{equation}
phi(k_1+k_2) = g((V_1(k_1) V_2(k_2))(k_1 k_2)
- (V_1(k_1) k_2)(V_2(k_2) k_1))
\end{equation}
<<Implementation of couplings>>=
pure function s_vv_t (g, v1, k1, v2, k2) result (phi)
complex(kind=default), intent(in) :: g
type(vector), intent(in) :: v1, v2
type(momentum), intent(in) :: k1, k2
complex(kind=default) :: phi
phi = g * ((v1*v2) * (k1*k2) - (v1*k2) * (v2*k1))
end function s_vv_t
@
\begin{equation}
V_1^\mu(k_\phi+k_V) = g phi(((k_\phi+k_V)k_V)V_2^\mu-
(k_\phi+k_V)V_2)k_V^\mu )
\end{equation}
<<Implementation of couplings>>=
pure function v_sv_t (g, phi, kphi,v, kv) result (vout)
complex(kind=default), intent(in) :: g, phi
type(vector), intent(in) :: v
type(momentum), intent(in) :: kv, kphi
type(momentum) :: kout
type(vector) :: vout
kout = - (kv + kphi)
vout = g * phi * ((kout*kv) * v - (v * kout) * kv)
end function v_sv_t
@ \subsection{Transversal TensorScalar-Vector Coupling}
<<Declaration of couplings>>=
public :: tphi_vv, tphi_vv_cf, v_tphiv, v_tphiv_cf
@
\begin{equation}
phi(k_1 + k_2) = g (V_1(k_1) (k_1 +k_2)) *
( V_2(k_2) (k_1 + k_2))
\end{equation}
<<Implementation of couplings>>=
pure function tphi_vv (g, v1, k1, v2, k2) result (phi)
complex(kind=default), intent(in) :: g
type(vector), intent(in) :: v1, v2
type(momentum), intent(in) :: k1, k2
complex(kind=default) :: phi
type(momentum) :: k
k = - (k1 + k2)
phi = 2 * g * (v1*k) * (v2*k)
end function tphi_vv
@
\begin{equation}
phi(k_1+k_2) = g((V_1(k_1) V_2(k_2))(k_1 + k_2)^2)
\end{equation}
<<Implementation of couplings>>=
pure function tphi_vv_cf (g, v1, k1, v2, k2) result (phi)
complex(kind=default), intent(in) :: g
type(vector), intent(in) :: v1, v2
type(momentum), intent(in) :: k1, k2
complex(kind=default) :: phi
type(momentum) :: k
k = - (k1 + k2)
phi = - g/2 * (v1*v2) * (k*k)
end function tphi_vv_cf
@
\begin{equation}
V_1^\mu(k_\phi+k_V) = g phi ((k_\phi+k_V)V_2) (k_\phi+k_V)^\mu
\end{equation}
<<Implementation of couplings>>=
pure function v_tphiv (g, phi, kphi,v, kv) result (vout)
complex(kind=default), intent(in) :: g, phi
type(vector), intent(in) :: v
type(momentum), intent(in) :: kv, kphi
type(momentum) :: kout
type(vector) :: vout
kout = - (kv + kphi)
vout = 2 * g * phi * ((v * kout) * kout)
end function v_tphiv
@
\begin{equation}
V_1^\mu(k_\phi+k_V) = g phi((k_\phi+k_V)(k_\phi+k_V))V_2^\mu
\end{equation}
<<Implementation of couplings>>=
pure function v_tphiv_cf (g, phi, kphi,v, kv) result (vout)
complex(kind=default), intent(in) :: g, phi
type(vector), intent(in) :: v
type(momentum), intent(in) :: kv, kphi
type(momentum) :: kout
type(vector) :: vout
kout = - (kv + kphi)
vout = -g/2 * phi * (kout*kout) * v
end function v_tphiv_cf
@ \subsection{Triple Vector Couplings}
<<Declaration of couplings>>=
public :: tkv_vv, lkv_vv, tv_kvv, lv_kvv, kg_kgkg
public :: t5kv_vv, l5kv_vv, t5v_kvv, l5v_kvv, kg5_kgkg, kg_kg5kg
public :: dv_vv, v_dvv, dv_vv_cf, v_dvv_cf
@
\begin{equation}
V^\mu(k_1+k_2) = \ii g(k_1-k_2)^\mu V_1^\nu(k_1)V_{2,\nu}(k_2)
\end{equation}
<<Implementation of couplings>>=
pure function tkv_vv (g, v1, k1, v2, k2) result (v)
complex(kind=default), intent(in) :: g
type(vector), intent(in) :: v1, v2
type(momentum), intent(in) :: k1, k2
type(vector) :: v
v = (k1 - k2) * ((0, 1) * g * (v1*v2))
end function tkv_vv
@
\begin{equation}
V^\mu(k_1+k_2) = \ii g \epsilon^{\mu\nu\rho\sigma}
(k_1-k_2)_{\nu} V_{1,\rho}(k_1)V_{2,\sigma}(k_2)
\end{equation}
<<Implementation of couplings>>=
pure function t5kv_vv (g, v1, k1, v2, k2) result (v)
complex(kind=default), intent(in) :: g
type(vector), intent(in) :: v1, v2
type(momentum), intent(in) :: k1, k2
type(vector) :: v
type(vector) :: k
k = k1 - k2
v = (0, 1) * g * pseudo_vector (k, v1, v2)
end function t5kv_vv
@
\begin{equation}
V^\mu(k_1+k_2) = \ii g(k_1+k_2)^\mu V_1^\nu(k_1)V_{2,\nu}(k_2)
\end{equation}
<<Implementation of couplings>>=
pure function lkv_vv (g, v1, k1, v2, k2) result (v)
complex(kind=default), intent(in) :: g
type(vector), intent(in) :: v1, v2
type(momentum), intent(in) :: k1, k2
type(vector) :: v
v = (k1 + k2) * ((0, 1) * g * (v1*v2))
end function lkv_vv
@
\begin{equation}
V^\mu(k_1+k_2) = \ii g \epsilon^{\mu\nu\rho\sigma}
(k_1+k_2)_{\nu} V_{1,\rho}(k_1)V_{2,\sigma}(k_2)
\end{equation}
<<Implementation of couplings>>=
pure function l5kv_vv (g, v1, k1, v2, k2) result (v)
complex(kind=default), intent(in) :: g
type(vector), intent(in) :: v1, v2
type(momentum), intent(in) :: k1, k2
type(vector) :: v
type(vector) :: k
k = k1 + k2
v = (0, 1) * g * pseudo_vector (k, v1, v2)
end function l5kv_vv
@
\begin{equation}
V^\mu(k_1+k_2) = \ii g (k_2-k)^\nu V_{1,\nu}(k_1)V_2^\mu(k_2)
= \ii g (2k_2+k_1)^\nu V_{1,\nu}(k_1)V_2^\mu(k_2)
\end{equation}
using $k=-k_1-k_2$
<<Implementation of couplings>>=
pure function tv_kvv (g, v1, k1, v2, k2) result (v)
complex(kind=default), intent(in) :: g
type(vector), intent(in) :: v1, v2
type(momentum), intent(in) :: k1, k2
type(vector) :: v
v = v2 * ((0, 1) * g * ((2*k2 + k1)*v1))
end function tv_kvv
@
\begin{equation}
V^\mu(k_1+k_2) = \ii g \epsilon^{\mu\nu\rho\sigma}
(2k_2+k_1)_{\nu} V_{1,\rho}(k_1)V_{2,\sigma}(k_2)
\end{equation}
<<Implementation of couplings>>=
pure function t5v_kvv (g, v1, k1, v2, k2) result (v)
complex(kind=default), intent(in) :: g
type(vector), intent(in) :: v1, v2
type(momentum), intent(in) :: k1, k2
type(vector) :: v
type(vector) :: k
k = k1 + 2*k2
v = (0, 1) * g * pseudo_vector (k, v1, v2)
end function t5v_kvv
@
\begin{equation}
V^\mu(k_1+k_2) = - \ii g k_1^\nu V_{1,\nu}(k_1)V_2^\mu(k_2)
\end{equation}
using $k=-k_1-k_2$
<<Implementation of couplings>>=
pure function lv_kvv (g, v1, k1, v2) result (v)
complex(kind=default), intent(in) :: g
type(vector), intent(in) :: v1, v2
type(momentum), intent(in) :: k1
type(vector) :: v
v = v2 * ((0, -1) * g * (k1*v1))
end function lv_kvv
@
\begin{equation}
V^\mu(k_1+k_2) = - \ii g \epsilon^{\mu\nu\rho\sigma}
k_{1,\nu} V_{1,\rho}(k_1)V_{2,\sigma}(k_2)
\end{equation}
<<Implementation of couplings>>=
pure function l5v_kvv (g, v1, k1, v2) result (v)
complex(kind=default), intent(in) :: g
type(vector), intent(in) :: v1, v2
type(momentum), intent(in) :: k1
type(vector) :: v
type(vector) :: k
k = k1
v = (0, -1) * g * pseudo_vector (k, v1, v2)
end function l5v_kvv
@
\begin{equation}
A^\mu(k_1+k_2) = \ii g k^\nu
\Bigl( F_{1,\nu}^{\hphantom{1,\nu}\rho}(k_1)F_{2,\rho\mu}(k_2)
- F_{1,\mu}^{\hphantom{1,\mu}\rho}(k_1)F_{2,\rho\nu}(k_2) \Bigr)
\end{equation}
with $k=-k_1-k_2$, i.\,e.
\begin{multline}
A^\mu(k_1+k_2) = -\ii g
\Bigl( [(kk_2)(k_1A_2) - (k_1k_2)(kA_2)] A_1^\mu \\
+ [(k_1k_2)(kA_1) - (kk_1)(k_2A_1)] A_2^\mu \\
+ [(k_2A_1)(kA_2) - (kk_2)(A_1A_2)] k_1^\mu \\
+ [(kk_1)(A_1A_2) - (kA_1)(k_1A_2)] k_2^\mu \Bigr)
\end{multline}
<<Implementation of couplings>>=
pure function kg_kgkg (g, a1, k1, a2, k2) result (a)
complex(kind=default), intent(in) :: g
type(vector), intent(in) :: a1, a2
type(momentum), intent(in) :: k1, k2
type(vector) :: a
real(kind=default) :: k1k1, k2k2, k1k2, kk1, kk2
complex(kind=default) :: a1a2, k2a1, ka1, k1a2, ka2
k1k1 = k1 * k1
k1k2 = k1 * k2
k2k2 = k2 * k2
kk1 = k1k1 + k1k2
kk2 = k1k2 + k2k2
k2a1 = k2 * a1
ka1 = k2a1 + k1 * a1
k1a2 = k1 * a2
ka2 = k1a2 + k2 * a2
a1a2 = a1 * a2
a = (0, -1) * g * ( (kk2 * k1a2 - k1k2 * ka2 ) * a1 &
+ (k1k2 * ka1 - kk1 * k2a1) * a2 &
+ (ka2 * k2a1 - kk2 * a1a2) * k1 &
+ (kk1 * a1a2 - ka1 * k1a2) * k2 )
end function kg_kgkg
@
\begin{equation}
A^\mu(k_1+k_2) = \ii g \epsilon^{\mu\nu\rho\sigma} k_{\nu}
F_{1,\rho}^{\hphantom{1,\rho}\lambda}(k_1)F_{2,\lambda\sigma}(k_2)
\end{equation}
with $k=-k_1-k_2$, i.\,e.
\begin{multline}
A^\mu(k_1+k_2) = -2\ii g \epsilon^{\mu\nu\rho\sigma} k_{\nu}
\Bigl( (k_2A_1) k_{1,\rho} A_{2,\sigma}
+ (k_1A_2) A_{1,\rho} k_{2,\sigma} \\
- (A_1A_2) k_{1,\rho} k_{2,\sigma}
- (k_1k_2) A_{1,\rho} A_{2,\sigma} \Bigr)
\end{multline}
<<Implementation of couplings>>=
pure function kg5_kgkg (g, a1, k1, a2, k2) result (a)
complex(kind=default), intent(in) :: g
type(vector), intent(in) :: a1, a2
type(momentum), intent(in) :: k1, k2
type(vector) :: a
type(vector) :: kv, k1v, k2v
kv = - k1 - k2
k1v = k1
k2v = k2
a = (0, -2) * g * ( (k2*A1) * pseudo_vector (kv, k1v, a2 ) &
+ (k1*A2) * pseudo_vector (kv, A1 , k2v) &
- (A1*A2) * pseudo_vector (kv, k1v, k2v) &
- (k1*k2) * pseudo_vector (kv, a1 , a2 ) )
end function kg5_kgkg
@
\begin{equation}
A^\mu(k_1+k_2) = \ii g k_{\nu} \Bigl(
\epsilon^{\mu\rho\lambda\sigma}
F_{1,\hphantom{\nu}\rho}^{\hphantom{1,}\nu}
- \epsilon^{\nu\rho\lambda\sigma}
F_{1,\hphantom{\mu}\rho}^{\hphantom{1,}\mu} \Bigr)
\frac{1}{2} F_{1,\lambda\sigma}
\end{equation}
with $k=-k_1-k_2$, i.\,e.
\begin{multline}
A^\mu(k_1+k_2) = -\ii g \Bigl(
\epsilon^{\mu\rho\lambda\sigma} (kk_2) A_{2,\rho}
- \epsilon^{\mu\rho\lambda\sigma} (kA_2) k_{2,\rho}
- k_2^\mu \epsilon^{\nu\rho\lambda\sigma} k_nu A_{2,\rho}
+ A_2^\mu \epsilon^{\nu\rho\lambda\sigma} k_nu k_{2,\rho}
\Bigr) k_{1,\lambda} A_{1,\sigma}
\end{multline}
\begin{dubious}
This is not the most efficienct way of doing it:
$\epsilon^{\mu\nu\rho\sigma}F_{1,\rho\sigma}$ should be cached!
\end{dubious}
<<Implementation of couplings>>=
pure function kg_kg5kg (g, a1, k1, a2, k2) result (a)
complex(kind=default), intent(in) :: g
type(vector), intent(in) :: a1, a2
type(momentum), intent(in) :: k1, k2
type(vector) :: a
type(vector) :: kv, k1v, k2v
kv = - k1 - k2
k1v = k1
k2v = k2
a = (0, -1) * g * ( (kv*k2v) * pseudo_vector (a2 , k1v, a1) &
- (kv*a2 ) * pseudo_vector (k2v, k1v, a1) &
- k2v * pseudo_scalar (kv, a2, k1v, a1) &
+ a2 * pseudo_scalar (kv, k2v, k1v, a1) )
end function kg_kg5kg
@
\begin{equation}
V^\mu(k_1+k_2) =
- g ((k_1+k_2) V_{1}) V_{2}^\mu
+ ((k_1+k_2) V_{2}) V_{1}^\mu
\end{equation}
<<Implementation of couplings>>=
pure function dv_vv (g, v1, k1, v2, k2) result (v)
complex(kind=default), intent(in) :: g
type(vector), intent(in) :: v1, v2
type(momentum), intent(in) :: k1, k2
type(vector) :: v
type(vector) :: k
k = -(k1 + k2)
v = g * ((k * v1) * v2 + (k * v2) * v1)
end function dv_vv
@
\begin{equation}
V^\mu(k_1+k_2) = \frac{g}{2}
( V_{1} (k_{1}) V_{2} (k_{2}) ) (k_{1}+k_{2})^\mu
\end{equation}
<<Implementation of couplings>>=
pure function dv_vv_cf (g, v1, k1, v2, k2) result (v)
complex(kind=default), intent(in) :: g
type(vector), intent(in) :: v1, v2
type(momentum), intent(in) :: k1, k2
type(vector) :: v
type(vector) :: k
k = -(k1 + k2)
v = - g/2 * (v1 * v2) * k
end function dv_vv_cf
@
\begin{equation}
V_{1}^\mu = g * ( k V_{2}) V (k) + ( V V_{2}) k
\end{equation}
<<Implementation of couplings>>=
pure function v_dvv (g, v, k, v2) result (v1)
complex(kind=default), intent(in) :: g
type(vector), intent(in) :: v, v2
type(momentum), intent(in) :: k
type(vector) :: v1
v1 = g * ((v * v2) * k + (k * v2) * v)
end function v_dvv
@
\begin{equation}
V_{1}^\mu = -\frac{g}{2}
( V (k) k ) V_{2}^\mu
\end{equation}
<<Implementation of couplings>>=
pure function v_dvv_cf (g, v, k, v2) result (v1)
complex(kind=default), intent(in) :: g
type(vector), intent(in) :: v, v2
type(momentum), intent(in) :: k
type(vector) :: v1
v1 = - g/2 * (v * k) * v2
end function v_dvv_cf
@ \section{Tensorvector - Scalar coupling }
<<Declaration of couplings>>=
public :: dv_phi2,phi_dvphi, dv_phi2_cf, phi_dvphi_cf
@
\begin{equation}
V^\mu (k_1 + k_2 ) =
g* ((k_1 k_2 + k_2 k_2) k_1^\mu
+ (k_1 k_2 + k_1 k_1) k_2^\mu ) * phi_1 (k_1) phi_2 (k_2)
\end{equation}
<<Implementation of couplings>>=
pure function dv_phi2 (g, phi1, k1, phi2, k2) result (v)
complex(kind=default), intent(in) :: g, phi1, phi2
type(momentum), intent(in) :: k1, k2
type(vector) :: v
v = g * phi1 * phi2 * ( &
(k1 * k2 + k2 * k2 ) * k1 + &
(k1 * k2 + k1 * k1 ) * k2 )
end function dv_phi2
@
\begin{equation}
V^\mu (k_1 + k_2 ) = - \frac{g}{2} * (k_1 k_2) * (k_1 + k_2 )^\mu
* phi_1 (k_1) phi_2 (k_2)
\end{equation}
<<Implementation of couplings>>=
pure function dv_phi2_cf (g, phi1, k1, phi2, k2) result (v)
complex(kind=default), intent(in) :: g, phi1, phi2
type(momentum), intent(in) :: k1, k2
type(vector) :: v
v = - g/2 * phi1 * phi2 * (k1 * k2) * (k1 + k2)
end function dv_phi2_cf
@
\begin{equation}
phi_1 (k_1) =
g * ((k_1 k_2 + k_2 k_2) (k_1 * V(-k_1 - k_2) )
+ (k_1 k_2 + k_1 k_1) (k_2 * V(-k_1 - k_2) ) ) * phi_2 (k_2)
\end{equation}
<<Implementation of couplings>>=
pure function phi_dvphi (g, v, k, phi2, k2) result (phi1)
complex(kind=default), intent(in) :: g, phi2
type(vector), intent(in) :: v
type(momentum), intent(in) :: k, k2
complex(kind=default) :: phi1
type(momentum) :: k1
k1 = - (k + k2)
phi1 = g * phi2 * ( &
(k1 * k2 + k2 * k2 ) * ( k1 * V ) + &
(k1 * k2 + k1 * k1 ) * ( k2 * V ) )
end function phi_dvphi
@
\begin{equation}
phi_1 (k_1 ) = - \frac{g}{2} * (k_1 k_2) * ((k_1 + k_2 ) V(- k_1 - k_2))
\end{equation}
<<Implementation of couplings>>=
pure function phi_dvphi_cf (g, v, k, phi2, k2) result (phi1)
complex(kind=default), intent(in) :: g, phi2
type(vector), intent(in) :: v
type(momentum), intent(in) :: k, k2
complex(kind=default) :: phi1
type(momentum) :: k1
k1 = -(k + k2)
phi1 = - g/2 * phi2 * (k1 * k2) * ((k1 + k2) * v)
end function phi_dvphi_cf
@ \section{Scalar-Vector Dim-5 Couplings}
<<Declaration of couplings>>=
public :: phi_vv, v_phiv, phi_u_vv, v_u_phiv
@
<<Implementation of couplings>>=
pure function phi_vv (g, k1, k2, v1, v2) result (phi)
complex(kind=default), intent(in) :: g
type(momentum), intent(in) :: k1, k2
type(vector), intent(in) :: v1, v2
complex(kind=default) :: phi
phi = g * pseudo_scalar (k1, v1, k2, v2)
end function phi_vv
@
<<Implementation of couplings>>=
pure function v_phiv (g, phi, k1, k2, v) result (w)
complex(kind=default), intent(in) :: g, phi
type(vector), intent(in) :: v
type(momentum), intent(in) :: k1, k2
type(vector) :: w
w = g * phi * pseudo_vector (k1, k2, v)
end function v_phiv
@
<<Implementation of couplings>>=
pure function phi_u_vv (g, k1, k2, v1, v2) result (phi)
complex(kind=default), intent(in) :: g
type(momentum), intent(in) :: k1, k2
type(vector), intent(in) :: v1, v2
complex(kind=default) :: phi
phi = g * ((k1*v2)*((-(k1+k2))*v1) + &
(k2*v1)*((-(k1+k2))*v2) + &
(((k1+k2)*(k1+k2)) * (v1*v2)))
end function phi_u_vv
@
<<Implementation of couplings>>=
pure function v_u_phiv (g, phi, k1, k2, v) result (w)
complex(kind=default), intent(in) :: g, phi
type(vector), intent(in) :: v
type(momentum), intent(in) :: k1, k2
type(vector) :: w
w = g * phi * ((k1*v)*k2 + &
((-(k1+k2))*v)*k1 + &
((k1*k1)*v))
end function v_u_phiv
@ \section{Dim-6 Anoumalous Couplings with Higgs}
<<Declaration of couplings>>=
public :: s_vv_6D, v_sv_6D, s_vv_6DP, v_sv_6DP, a_hz_D, h_az_D, z_ah_D, &
a_hz_DP, h_az_DP, z_ah_DP, h_hh_6
<<Implementation of couplings>>=
pure function s_vv_6D (g, v1, k1, v2, k2) result (phi)
complex(kind=default), intent(in) :: g
type(vector), intent(in) :: v1, v2
type(momentum), intent(in) :: k1, k2
complex(kind=default) :: phi
phi = g * (-(k1 * v1) * (k1 * v2) - (k2 * v1) * (k2 * v2) &
+ ((k1 * k1) + (k2 * k2)) * (v1 * v2))
end function s_vv_6D
<<Implementation of couplings>>=
pure function v_sv_6D (g, phi, kphi, v, kv) result (vout)
complex(kind=default), intent(in) :: g
complex(kind=default), intent(in) :: phi
type(vector), intent(in) :: v
type(momentum), intent(in) :: kphi, kv
type(vector) :: vout
vout = g * ( - phi * (kv * v) * kv - phi * ((kphi + kv) * v) * (kphi + kv) &
+ phi * (kv * kv) * v + phi * ((kphi + kv)*(kphi + kv)) * v)
end function v_sv_6D
<<Implementation of couplings>>=
pure function s_vv_6DP (g, v1, k1, v2, k2) result (phi)
complex(kind=default), intent(in) :: g
type(vector), intent(in) :: v1, v2
type(momentum), intent(in) :: k1, k2
complex(kind=default) :: phi
phi = g * ( (-(k1+k2)*v1) * (k1*v2) - ((k1+k2)*v2) * (k2*v1) + &
((k1+k2)*(k1+k2))*(v1*v2) )
end function s_vv_6DP
<<Implementation of couplings>>=
pure function v_sv_6DP (g, phi, kphi, v, kv) result (vout)
complex(kind=default), intent(in) :: g
complex(kind=default), intent(in) :: phi
type(vector), intent(in) :: v
type(momentum), intent(in) :: kphi, kv
type(vector) :: vout
vout = g * phi * ((-(kphi + kv)*v) * kphi + (kphi * v) * kv + &
(kphi*kphi) * v )
end function v_sv_6DP
<<Implementation of couplings>>=
pure function a_hz_D (g, h1, k1, v2, k2) result (vout)
complex(kind=default), intent(in) :: g
complex(kind=default), intent(in) :: h1
type(vector), intent(in) :: v2
type(momentum), intent(in) :: k1, k2
type(vector) :: vout
vout = g * h1 * (((k1 + k2) * v2) * (k1 + k2) + &
((k1 + k2) * (k1 + k2)) * v2)
end function a_hz_D
<<Implementation of couplings>>=
pure function h_az_D (g, v1, k1, v2, k2) result (hout)
complex(kind=default), intent(in) :: g
type(vector), intent(in) :: v1, v2
type(momentum), intent(in) :: k1, k2
complex(kind=default) :: hout
hout = g * ((k1 * v1) * (k1 * v2) + (k1 * k1) * (v1 * v2))
end function h_az_D
<<Implementation of couplings>>=
pure function z_ah_D (g, v1, k1, h2, k2) result (vout)
complex(kind=default), intent(in) :: g
complex(kind=default), intent(in) :: h2
type(vector), intent(in) :: v1
type(momentum), intent(in) :: k1, k2
type(vector) :: vout
vout = g * h2 * ((k1 * v1) * k1 + ((k1 * k1)) *v1)
end function z_ah_D
<<Implementation of couplings>>=
pure function a_hz_DP (g, h1, k1, v2, k2) result (vout)
complex(kind=default), intent(in) :: g
complex(kind=default), intent(in) :: h1
type(vector), intent(in) :: v2
type(momentum), intent(in) :: k1, k2
type(vector) :: vout
vout = g * ((- h1 * (k1 + k2) * v2) * (k1) &
+ h1 * ((k1 + k2) * (k1)) *v2)
end function a_hz_DP
<<Implementation of couplings>>=
pure function h_az_DP (g, v1, k1, v2, k2) result (hout)
complex(kind=default), intent(in) :: g
type(vector), intent(in) :: v1, v2
type(momentum), intent(in) :: k1, k2
complex(kind=default) :: hout
hout = g * (- (k1 * v2) * ((k1 + k2) * v1) + (k1 * (k1 + k2)) * (v1 * v2))
end function h_az_DP
<<Implementation of couplings>>=
pure function z_ah_DP (g, v1, k1, h2, k2) result (vout)
complex(kind=default), intent(in) :: g
complex(kind=default), intent(in) :: h2
type(vector), intent(in) :: v1
type(momentum), intent(in) :: k1, k2
type(vector) :: vout
vout = g * h2* ((k2 * v1) * k1 - (k1 * k2) * v1)
end function z_ah_DP
<<Implementation of couplings>>=
pure function h_hh_6 (g, h1, k1, h2, k2) result (hout)
complex(kind=default), intent(in) :: g
complex(kind=default), intent(in) :: h1, h2
type(momentum), intent(in) :: k1, k2
complex(kind=default) :: hout
hout = g * ((k1* k1) + (k2 * k2) + (k1* k2)) * h1 * h2
end function h_hh_6
@ \section{Dim-6 Anoumalous Couplings without Higgs}
<<Declaration of couplings>>=
public :: g_gg_13, g_gg_23, g_gg_6, kg_kgkg_i
<<Implementation of couplings>>=
pure function g_gg_23 (g, v1, k1, v2, k2) result (vout)
complex(kind=default), intent(in) :: g
type(vector), intent(in) :: v1, v2
type(momentum), intent(in) :: k1, k2
type(vector) :: vout
vout = g * (v1 * (-2*(k1*v2)) + v2 * (2*k2 * v1) + (k1 - k2) * (v1*v2))
end function g_gg_23
<<Implementation of couplings>>=
pure function g_gg_13 (g, v1, k1, v2, k2) result (vout)
complex(kind=default), intent(in) :: g
type(vector), intent(in) :: v1, v2
type(momentum), intent(in) :: k1, k2
type(vector) :: vout
vout = g * (v1 * (2*(k1 + k2)*v2) - v2 * ((k1 + 2*k2) * v1) + 2*k2 * (v1 * v2))
end function g_gg_13
<<Implementation of couplings>>=
pure function g_gg_6 (g, v1, k1, v2, k2) result (vout)
complex(kind=default), intent(in) :: g
type(vector), intent(in) :: v1, v2
type(momentum), intent(in) :: k1, k2
type(vector) :: vout
vout = g * &
( k1 * ((-(k1 + k2) * v2) * (k2 * v1) + ((k1 + k2) * k2) * (v1 * v2)) &
+ k2 * (((k1 + k2) * v1) * (k1 * v2) - ((k1 + k2) * k1) * (v1 * v2)) &
+ v1 * (-((k1 + k2) * k2) * (k1 * v2) + (k1 * k2) * ((k1 + k2) * v2)) &
+ v2 * (((k1 + k2) * k1) * (k2 * v1) - (k1 * k2) * ((k1 + k2) * v1)))
end function g_gg_6
<<Implementation of couplings>>=
pure function kg_kgkg_i (g, a1, k1, a2, k2) result (a)
complex(kind=default), intent(in) :: g
type(vector), intent(in) :: a1, a2
type(momentum), intent(in) :: k1, k2
type(vector) :: a
real(kind=default) :: k1k1, k2k2, k1k2, kk1, kk2
complex(kind=default) :: a1a2, k2a1, ka1, k1a2, ka2
k1k1 = k1 * k1
k1k2 = k1 * k2
k2k2 = k2 * k2
kk1 = k1k1 + k1k2
kk2 = k1k2 + k2k2
k2a1 = k2 * a1
ka1 = k2a1 + k1 * a1
k1a2 = k1 * a2
ka2 = k1a2 + k2 * a2
a1a2 = a1 * a2
a = (-1) * g * ( (kk2 * k1a2 - k1k2 * ka2 ) * a1 &
+ (k1k2 * ka1 - kk1 * k2a1) * a2 &
+ (ka2 * k2a1 - kk2 * a1a2) * k1 &
+ (kk1 * a1a2 - ka1 * k1a2) * k2 )
end function kg_kgkg_i
@ \section{Dim-6 Anoumalous Couplings with AWW}
<<Declaration of couplings>>=
public ::a_ww_DP, w_aw_DP, a_ww_DW
<<Implementation of couplings>>=
pure function a_ww_DP (g, v1, k1, v2, k2) result (vout)
complex(kind=default), intent(in) :: g
type(vector), intent(in) :: v1, v2
type(momentum), intent(in) :: k1, k2
type(vector) :: vout
vout = g * ( - ((k1 + k2) * v2) * v1 + ((k1 + k2) * v1) * v2)
end function a_ww_DP
<<Implementation of couplings>>=
pure function w_aw_DP (g, v1, k1, v2, k2) result (vout)
complex(kind=default), intent(in) :: g
type(vector), intent(in) :: v1, v2
type(momentum), intent(in) :: k1, k2
type(vector) :: vout
vout = g * ((k1 * v2) * v1 - (v1 * v2) * k1)
end function w_aw_DP
<<Implementation of couplings>>=
pure function a_ww_DW (g, v1, k1, v2, k2) result (vout)
complex(kind=default), intent(in) :: g
type(vector), intent(in) :: v1, v2
type(momentum), intent(in) :: k1, k2
type(vector) :: vout
vout = g * (v1 * (- (4*k1 + 2*k2) * v2) &
+ v2 * ( (2*k1 + 4*k2) * v1) &
+ (k1 - k2) * (2*v1*v2))
end function a_ww_DW
<<Declaration of couplings>>=
public :: w_wz_DPW, z_ww_DPW, w_wz_DW, z_ww_DW, w_wz_D, z_ww_D
<<Implementation of couplings>>=
pure function w_wz_DPW (g, v1, k1, v2, k2) result (vout)
complex(kind=default), intent(in) :: g
type(vector), intent(in) :: v1, v2
type(momentum), intent(in) :: k1, k2
type(vector) :: vout
vout = g * (v1 * (-(k1+k2)*v2 - k1*v2) + v2 * ((k1+k2)*v1) + k1 * (v1*v2))
end function w_wz_DPW
<<Implementation of couplings>>=
pure function z_ww_DPW (g, v1, k1, v2, k2) result (vout)
complex(kind=default), intent(in) :: g
type(vector), intent(in) :: v1, v2
type(momentum), intent(in) :: k1, k2
type(vector) :: vout
vout = g * (k1*(v1*v2) - k2*(v1*v2) - v1*(k1*v2) + v2*(k2*v1))
end function z_ww_DPW
<<Implementation of couplings>>=
pure function w_wz_DW (g, v1, k1, v2, k2) result (vout)
complex(kind=default), intent(in) :: g
type(vector), intent(in) :: v1, v2
type(momentum), intent(in) :: k1, k2
type(vector) :: vout
vout = g * (v2 * (v1 * k2) - k2 * (v1 * v2))
end function w_wz_DW
<<Implementation of couplings>>=
pure function z_ww_DW (g, v1, k1, v2, k2) result (vout)
complex(kind=default), intent(in) :: g
type(vector), intent(in) :: v1, v2
type(momentum), intent(in) :: k1, k2
type(vector) :: vout
vout = g * (v1 * ((-1)*(k1+k2) * v2) + v2 * ((k1+k2) * v1))
end function z_ww_DW
<<Implementation of couplings>>=
pure function w_wz_D (g, v1, k1, v2, k2) result (vout)
complex(kind=default), intent(in) :: g
type(vector), intent(in) :: v1, v2
type(momentum), intent(in) :: k1, k2
type(vector) :: vout
vout = g * (v2 * (k2*v1) - k2 * (v1*v2))
end function w_wz_D
<<Implementation of couplings>>=
pure function z_ww_D (g, v1, k1, v2, k2) result (vout)
complex(kind=default), intent(in) :: g
type(vector), intent(in) :: v1, v2
type(momentum), intent(in) :: k1, k2
type(vector) :: vout
vout = g * (v1 * (- (k1 + k2) * v2) + v2 * ((k1 + k2) * v1))
end function z_ww_D
@ \section{Dim-6 Quartic Couplings}
<<Declaration of couplings>>=
public :: hhhh_p2, a_hww_DPB, h_aww_DPB, w_ahw_DPB, a_hww_DPW, h_aww_DPW, &
w_ahw_DPW, a_hww_DW, h_aww_DW, w3_ahw_DW, w4_ahw_DW
<<Implementation of couplings>>=
pure function hhhh_p2 (g, h1, k1, h2, k2, h3, k3) result (hout)
complex(kind=default), intent(in) :: g
complex(kind=default), intent(in) :: h1, h2, h3
type(momentum), intent(in) :: k1, k2, k3
complex(kind=default) :: hout
hout = g * h1*h2*h3* (k1*k1 + k2*k2 +k3*k3 + k1*k3 + k1*k2 + k2*k3)
end function hhhh_p2
<<Implementation of couplings>>=
pure function a_hww_DPB (g, h1, k1, v2, k2, v3, k3) result (vout)
complex(kind=default), intent(in) :: g
complex(kind=default), intent(in) :: h1
type(vector), intent(in) :: v2, v3
type(momentum), intent(in) :: k1, k2, k3
type(vector) :: vout
vout = g * h1 * (v3*((k1+k2+k3)*v2) - v2*((k1+k2+k3)*v3))
end function a_hww_DPB
<<Implementation of couplings>>=
pure function h_aww_DPB (g, v1, k1, v2, k2, v3, k3) result (hout)
complex(kind=default), intent(in) :: g
type(vector), intent(in) :: v1, v2, v3
type(momentum), intent(in) :: k1, k2, k3
complex(kind=default) :: hout
hout = g * ((k1 * v3) * (v1 * v2) - (k1 * v2) * (v1 * v3))
end function h_aww_DPB
<<Implementation of couplings>>=
pure function w_ahw_DPB (g, v1, k1, h2, k2, v3, k3) result (vout)
complex(kind=default), intent(in) :: g
complex(kind=default), intent(in) :: h2
type(vector), intent(in) :: v1, v3
type(momentum), intent(in) :: k1, k2, k3
type(vector) :: vout
vout = g * h2 * (v1 * (k1 * v3) - k1 * (v1 * v3))
end function w_ahw_DPB
<<Implementation of couplings>>=
pure function a_hww_DPW (g, h1, k1, v2, k2, v3, k3) result (vout)
complex(kind=default), intent(in) :: g
complex(kind=default), intent(in) :: h1
type(vector), intent(in) :: v2, v3
type(momentum), intent(in) :: k1, k2, k3
type(vector) :: vout
vout = g * h1 * (v3 * ((2*k1+k2+k3)*v2) - v2 * ((2*k1+k2+k3)*v3))
end function a_hww_DPW
<<Implementation of couplings>>=
pure function h_aww_DPW (g, v1, k1, v2, k2, v3, k3) result (hout)
complex(kind=default), intent(in) :: g
type(vector), intent(in) :: v1, v2, v3
type(momentum), intent(in) :: k1, k2, k3
complex(kind=default) :: hout
hout = g * ((-(2*k1+k2+k3)*v2)*(v1*v3)+((2*k1+k2+k3)*v3)*(v1*v2))
end function h_aww_DPW
<<Implementation of couplings>>=
pure function w_ahw_DPW (g, v1, k1, h2, k2, v3, k3) result (vout)
complex(kind=default), intent(in) :: g
complex(kind=default), intent(in) :: h2
type(vector), intent(in) :: v1, v3
type(momentum), intent(in) :: k1, k2, k3
type(vector) :: vout
vout = g * h2 * ((k2 - k1) * (v1 * v3) + v1 * ((k1 - k2) * v3))
end function w_ahw_DPW
<<Implementation of couplings>>=
pure function a_hww_DW (g, h1, k1, v2, k2, v3, k3) result (vout)
complex(kind=default), intent(in) :: g
complex(kind=default), intent(in) :: h1
type(vector), intent(in) :: v2, v3
type(momentum), intent(in) :: k1, k2, k3
type(vector) :: vout
vout = g * h1 * ( v2 * (-(3*k1 + 4*k2 + 4*k3) * v3) &
+ v3 * ((3*k1 + 2*k2 + 4*k3) * v2) &
+ (k2 - k3) *2*(v2 * v3))
end function a_hww_DW
<<Implementation of couplings>>=
pure function h_aww_DW (g, v1, k1, v2, k2, v3, k3) result (hout)
complex(kind=default), intent(in) :: g
type(vector), intent(in) :: v1, v2, v3
type(momentum), intent(in) :: k1, k2, k3
complex(kind=default) :: hout
hout = g * ((v1*v2) * ((3*k1 - k2 - k3)*v3) &
+ (v1*v3) * ((-3*k1 - k2 + k3)*v2) &
+ (v2*v3) * (2*(k2-k3)*v1))
end function h_aww_DW
<<Implementation of couplings>>=
pure function w3_ahw_DW (g, v1, k1, h2, k2, v3, k3) result (vout)
complex(kind=default), intent(in) :: g
complex(kind=default), intent(in) :: h2
type(vector), intent(in) :: v1, v3
type(momentum), intent(in) :: k1, k2, k3
type(vector) :: vout
vout = g * h2 * (v1 * ((4*k1 + k2) * v3) &
+v3 * (-2*(k1 + k2 + 2*k3) * v1) &
+(-2*k1 + k2 + 2*k3) * (v1*v3))
end function w3_ahw_DW
<<Implementation of couplings>>=
pure function w4_ahw_DW (g, v1, k1, h2, k2, v3, k3) result (vout)
complex(kind=default), intent(in) :: g
complex(kind=default), intent(in) :: h2
type(vector), intent(in) :: v1, v3
type(momentum), intent(in) :: k1, k2, k3
type(vector) :: vout
vout = g * h2 * (v1 * (-(4*k1 + k2 + 2*k3) * v3) &
+ v3 * (2*(k1 + k2 + 2*k3) * v1) &
+(4*k1 + k2) * (v1*v3))
end function w4_ahw_DW
<<Declaration of couplings>>=
public ::a_aww_DW, w_aaw_DW, a_aww_W, w_aaw_W
<<Implementation of couplings>>=
pure function a_aww_DW (g, v1, k1, v2, k2, v3, k3) result (vout)
complex(kind=default), intent(in) :: g
type(vector), intent(in) :: v1, v2, v3
type(momentum), intent(in) :: k1, k2, k3
type(vector) :: vout
vout = g * (2*v1*(v2*v3) - v2*(v1*v3) - v3*(v1*v2))
end function a_aww_DW
pure function w_aaw_DW (g, v1, k1, v2, k2, v3, k3) result (vout)
complex(kind=default), intent(in) :: g
type(vector), intent(in) :: v1, v2, v3
type(momentum), intent(in) :: k1, k2, k3
type(vector) :: vout
vout = g * (2*v3*(v1*v2) - v2*(v1*v3) - v1*(v2*v3))
end function w_aaw_DW
pure function a_aww_W (g, v1, k1, v2, k2, v3, k3) result (vout)
complex(kind=default), intent(in) :: g
type(vector), intent(in) :: v1, v2, v3
type(momentum), intent(in) :: k1, k2, k3
type(vector) :: vout
- vout = g * (v1*((-(k2+k3)*v2)*(k2*v3) + (-(k2+k3)*v3)*(k3*v2)) &
- +v2*((-((k2-k3)*v1)*(k1+k2+k3)*v3) - (k1*v3)*(k2*v1) &
- + ((k1+k2+k3)*v1)*(k2*v3)) &
- +v3*(((k2-k3)*v1)*((k1+k2+k3)*v2) - (k1*v2)*(k3*v1) &
- + ((k1+k2+k3)*v1)*(k3*v2)) &
- +(v1*v2)*(((2*k1+k2+k3)*v3)*k2 - (k2*v3)*k1 -(k1*v3)*k3) &
- +(v1*v3)*(((2*k1+k2+k3)*v2)*k3 - (k3*v2)*k1 - (k1*v2)*k3) &
- +(v2*v3)*((-(k1+k2+k3)*v1)*(k2+k3) + ((k2+k3)*v1)*k1) &
- +(-(k1+k2+k3)*k3 +k1*k2)*((v1*v3)*v2 - (v2*v3)*v1) &
- +(-(k1+k2+k3)*k2 + k1*k3)*((v1*v2)*v3 - (v2*v3)*v1))
+!!! Recalculated WK 2018-08-24
+ type(momentum) :: k4
+ k4 = -(k1+k2+k3)
+!!! negative sign (-g) causes expected gauge cancellation
+ vout = (-g) * ( &
+ + (k1*v3)*(k3*v2)*v1 - (k3*v2)*(v1*v3)*k1 &
+ - (k1*k3)*(v2*v3)*v1 + (k3*v1)*(v2*v3)*k1 &
+ - (k1*v3)*(v1*v2)*k3 + (k1*v2)*(v1*v3)*k3 &
+ + (k1*k3)*(v1*v2)*v3 - (k3*v1)*(k1*v2)*v3 &
+ + (k3*v2)*(k4*v3)*v1 - (k3*v2)*(k4*v1)*v3 &
+ - (k3*k4)*(v2*v3)*v1 + (k4*v1)*(v2*v3)*k3 &
+ - (k3*v1)*(k4*v3)*v2 + (k3*v1)*(k4*v2)*v3 &
+ + (k3*k4)*(v1*v3)*v2 - (k4*v2)*(v1*v3)*k3 &
+ + (k1*v2)*(k2*v3)*v1 - (k2*v3)*(v1*v2)*k1 &
+ - (k1*k2)*(v2*v3)*v1 + (k2*v1)*(v2*v3)*k1 &
+ - (k1*v2)*(v1*v3)*k2 + (k1*v3)*(v1*v2)*k2 &
+ + (k1*k2)*(v1*v3)*v2 - (k2*v1)*(k1*v3)*v2 &
+ + (k2*v3)*(k4*v2)*v1 - (k2*v3)*(k4*v1)*v2 &
+ - (k2*k4)*(v2*v3)*v1 + (k4*v1)*(v2*v3)*k2 &
+ - (k2*v1)*(k4*v2)*v3 + (k2*v1)*(k4*v3)*v2 &
+ + (k2*k4)*(v1*v2)*v3 - (k4*v3)*(v1*v2)*k2 &
+ )
+!!! Original Version
+! vout = g * (v1*((-(k2+k3)*v2)*(k2*v3) + (-(k2+k3)*v3)*(k3*v2)) &
+! +v2*((-((k2-k3)*v1)*(k1+k2+k3)*v3) - (k1*v3)*(k2*v1) &
+! + ((k1+k2+k3)*v1)*(k2*v3)) &
+! +v3*(((k2-k3)*v1)*((k1+k2+k3)*v2) - (k1*v2)*(k3*v1) &
+! + ((k1+k2+k3)*v1)*(k3*v2)) &
+! +(v1*v2)*(((2*k1+k2+k3)*v3)*k2 - (k2*v3)*k1 -(k1*v3)*k3) &
+! +(v1*v3)*(((2*k1+k2+k3)*v2)*k3 - (k3*v2)*k1 - (k1*v2)*k3) &
+! +(v2*v3)*((-(k1+k2+k3)*v1)*(k2+k3) + ((k2+k3)*v1)*k1) &
+! +(-(k1+k2+k3)*k3 +k1*k2)*((v1*v3)*v2 - (v2*v3)*v1) &
+! +(-(k1+k2+k3)*k2 + k1*k3)*((v1*v2)*v3 - (v2*v3)*v1))
end function a_aww_W
pure function w_aaw_W (g, v1, k1, v2, k2, v3, k3) result (vout)
complex(kind=default), intent(in) :: g
type(vector), intent(in) :: v1, v2, v3
type(momentum), intent(in) :: k1, k2, k3
type(vector) :: vout
- vout = g * (v1*((k1*v3)*(-(k1+k2+2*k3)*v2) + (k2*v3)*((k1+k2+k3)*v2) &
- + (k1*v2)*((k1+k2+k3)*v3)) &
- + v2*(((k1-k2)*v3)*((k1+k2+k3)*v1) - (k2*v3)*(k3*v1) &
- + (k2*v1)*((k1+k2+k3)*v3)) &
- + v3*((k1*v2)*(-(k1+k2)*v1) + (k2*v1)*(-(k1+k2)*v2)) &
- + (v1*v2)*((k1+k2)*(-(k1+k2+k3)*v3) + k3*((k1+k2)*v3))&
- + (v1*v3)*(-k2*(k3*v2) - k3*(k1*v2) + k1*((k1+k2+2*k3)*v2)) &
- + (v2*v3)*(-k1*(k3*v1) - k3*(k2*v1) + k2*((k1+k2+2*k3)*v1)) &
- + (-k2*(k1+k2+k3) + k1*k3)*(v1*(v2*v3) - v3*(v1*v2)) &
- + (-k1*(k1+k2+k3) + k2*k3)*(v2*(v1*v3) - v3*(v1*v2)) )
+!!! Recalculated WK 2018-08-25
+ type(momentum) :: k4
+ k4 = -(k1+k2+k3)
+!!! negative sign (-g) causes expected gauge cancellation
+ vout = (-g) * ( &
+ + (k3*v1)*(k1*v2)*v3 - (k1*v2)*(v3*v1)*k3 &
+ - (k3*k1)*(v2*v1)*v3 + (k1*v3)*(v2*v1)*k3 &
+ - (k3*v1)*(v3*v2)*k1 + (k3*v2)*(v3*v1)*k1 &
+ + (k3*k1)*(v3*v2)*v1 - (k1*v3)*(k3*v2)*v1 &
+ + (k1*v2)*(k4*v1)*v3 - (k1*v2)*(k4*v3)*v1 &
+ - (k1*k4)*(v2*v1)*v3 + (k4*v3)*(v2*v1)*k1 &
+ - (k1*v3)*(k4*v1)*v2 + (k1*v3)*(k4*v2)*v1 &
+ + (k1*k4)*(v3*v1)*v2 - (k4*v2)*(v3*v1)*k1 &
+ + (k3*v2)*(k2*v1)*v3 - (k2*v1)*(v3*v2)*k3 &
+ - (k3*k2)*(v2*v1)*v3 + (k2*v3)*(v2*v1)*k3 &
+ - (k3*v2)*(v3*v1)*k2 + (k3*v1)*(v3*v2)*k2 &
+ + (k3*k2)*(v3*v1)*v2 - (k2*v3)*(k3*v1)*v2 &
+ + (k2*v1)*(k4*v2)*v3 - (k2*v1)*(k4*v3)*v2 &
+ - (k2*k4)*(v2*v1)*v3 + (k4*v3)*(v2*v1)*k2 &
+ - (k2*v3)*(k4*v2)*v1 + (k2*v3)*(k4*v1)*v2 &
+ + (k2*k4)*(v3*v2)*v1 - (k4*v1)*(v3*v2)*k2 &
+ )
+!!! Original Version
+! vout = g * (v1*((k1*v3)*(-(k1+k2+2*k3)*v2) + (k2*v3)*((k1+k2+k3)*v2) &
+! + (k1*v2)*((k1+k2+k3)*v3)) &
+! + v2*(((k1-k2)*v3)*((k1+k2+k3)*v1) - (k2*v3)*(k3*v1) &
+! + (k2*v1)*((k1+k2+k3)*v3)) &
+! + v3*((k1*v2)*(-(k1+k2)*v1) + (k2*v1)*(-(k1+k2)*v2)) &
+! + (v1*v2)*((k1+k2)*(-(k1+k2+k3)*v3) + k3*((k1+k2)*v3))&
+! + (v1*v3)*(-k2*(k3*v2) - k3*(k1*v2) + k1*((k1+k2+2*k3)*v2)) &
+! + (v2*v3)*(-k1*(k3*v1) - k3*(k2*v1) + k2*((k1+k2+2*k3)*v1)) &
+! + (-k2*(k1+k2+k3) + k1*k3)*(v1*(v2*v3) - v3*(v1*v2)) &
+! + (-k1*(k1+k2+k3) + k2*k3)*(v2*(v1*v3) - v3*(v1*v2)) )
end function w_aaw_W
<<Declaration of couplings>>=
public :: h_hww_D, w_hhw_D, h_hww_DP, w_hhw_DP, h_hvv_PB, v_hhv_PB
<<Implementation of couplings>>=
pure function h_hww_D (g, h1, k1, v2, k2, v3, k3) result (hout)
complex(kind=default), intent(in) :: g
complex(kind=default), intent(in) :: h1
type(vector), intent(in) :: v2, v3
type(momentum), intent(in) :: k1, k2, k3
complex(kind=default) :: hout
hout = g * h1 * ((v2*v3)*((k2*k2)+(k3*k3)) - (k2*v2)*(k2*v3) &
- (k3*v2)*(k3*v3))
end function h_hww_D
<<Implementation of couplings>>=
pure function w_hhw_D (g, h1, k1, h2, k2, v3, k3) result (vout)
complex(kind=default), intent(in) :: g
complex(kind=default), intent(in) :: h1, h2
type(vector), intent(in) :: v3
type(momentum), intent(in) :: k1, k2, k3
type(vector) :: vout
vout = g * h1 * h2 * (v3 * ((k1+k2+k3)*(k1+k2+k3)+(k3*k3)) &
- (k1+k2+k3) * ((k1+k2+k3)*v3) - k3 * (k3*v3))
end function w_hhw_D
<<Implementation of couplings>>=
pure function h_hww_DP (g, h1, k1, v2, k2, v3, k3) result (hout)
complex(kind=default), intent(in) :: g
complex(kind=default), intent(in) :: h1
type(vector), intent(in) :: v2, v3
type(momentum), intent(in) :: k1, k2, k3
complex(kind=default) :: hout
hout = g * h1 * (-((k2+k3)*v2)*(k2*v3) - &
((k2+k3)*v3)*(k3*v2)+ (v2*v3)*((k2+k3)*(k2+k3)))
end function h_hww_DP
<<Implementation of couplings>>=
pure function w_hhw_DP (g, h1, k1, h2, k2, v3, k3) result (vout)
complex(kind=default), intent(in) :: g
complex(kind=default), intent(in) :: h1, h2
type(vector), intent(in) :: v3
type(momentum), intent(in) :: k1, k2, k3
type(vector) :: vout
vout = g * h1 * h2 * (k3*((k1+k2)*v3) + (k1+k2)*(-(k1+k2+k3)*v3) &
+ v3*((k1+k2)*(k1+k2)))
end function w_hhw_DP
<<Implementation of couplings>>=
pure function h_hvv_PB (g, h1, k1, v2, k2, v3, k3) result (hout)
complex(kind=default), intent(in) :: g
complex(kind=default), intent(in) :: h1
type(vector), intent(in) :: v2, v3
type(momentum), intent(in) :: k1, k2, k3
complex(kind=default) :: hout
hout = g * h1 * ((k2*v3)*(k3*v2) - (k2*k3)*(v2*v3))
end function h_hvv_PB
<<Implementation of couplings>>=
pure function v_hhv_PB (g, h1, k1, h2, k2, v3, k3) result (vout)
complex(kind=default), intent(in) :: g
complex(kind=default), intent(in) :: h1, h2
type(vector), intent(in) :: v3
type(momentum), intent(in) :: k1, k2, k3
type(vector) :: vout
vout = g * h1 * h2 * ((-(k1+k2+k3)*v3)*k3 + ((k1+k2+k3)*k3)*v3)
end function v_hhv_PB
<<Declaration of couplings>>=
public :: a_hhz_D, h_ahz_D, z_ahh_D, a_hhz_DP, h_ahz_DP, z_ahh_DP, &
a_hhz_PB, h_ahz_PB, z_ahh_PB
<<Implementation of couplings>>=
pure function a_hhz_D (g, h1, k1, h2, k2, v3, k3) result (vout)
complex(kind=default), intent(in) :: g
complex(kind=default), intent(in) :: h1, h2
type(vector), intent(in) :: v3
type(momentum), intent(in) :: k1, k2, k3
type(vector) :: vout
vout = g * h1 * h2 * ((k1+k2+k3) * ((k1+k2+k3)*v3) &
- v3 * ((k1+k2+k3)*(k1+k2+k3)))
end function a_hhz_D
<<Implementation of couplings>>=
pure function h_ahz_D (g, v1, k1, h2, k2, v3, k3) result (hout)
complex(kind=default), intent(in) :: g
complex(kind=default), intent(in) :: h2
type(vector), intent(in) :: v1, v3
type(momentum), intent(in) :: k1, k2, k3
complex(kind=default) :: hout
hout = g * h2 * ((k1*v1)*(k1*v3) - (k1*k1)*(v1*v3))
end function h_ahz_D
<<Implementation of couplings>>=
pure function z_ahh_D (g, v1, k1, h2, k2, h3, k3) result (vout)
complex(kind=default), intent(in) :: g
type(vector), intent(in) :: v1
complex(kind=default), intent(in) :: h2, h3
type(momentum), intent(in) :: k1, k2, k3
type(vector) :: vout
vout = g * h2 * h3 * ((k1*v1)*k1 - (k1*k1)*v1)
end function z_ahh_D
<<Implementation of couplings>>=
pure function a_hhz_DP (g, h1, k1, h2, k2, v3, k3) result (vout)
complex(kind=default), intent(in) :: g
complex(kind=default), intent(in) :: h1, h2
type(vector), intent(in) :: v3
type(momentum), intent(in) :: k1, k2, k3
type(vector) :: vout
vout = g * h1 * h2 * ((-(k1+k2+k3)*v3)*(k1+k2) + ((k1+k2+k3)*(k1+k2))*v3)
end function a_hhz_DP
<<Implementation of couplings>>=
pure function h_ahz_DP (g, v1, k1, h2, k2, v3, k3) result (hout)
complex(kind=default), intent(in) :: g
complex(kind=default), intent(in) :: h2
type(vector), intent(in) :: v1, v3
type(momentum), intent(in) :: k1, k2, k3
complex(kind=default) :: hout
hout = g * h2 * ( (k1*v3)*(-(k1+k3)*v1) + (k1*(k1+k3))*(v1*v3) )
end function h_ahz_DP
<<Implementation of couplings>>=
pure function z_ahh_DP (g, v1, k1, h2, k2, h3, k3) result (vout)
complex(kind=default), intent(in) :: g
type(vector), intent(in) :: v1
complex(kind=default), intent(in) :: h2, h3
type(momentum), intent(in) :: k1, k2, k3
type(vector) :: vout
vout = g * h2 * h3 * (k1*((k2+k3)*v1) - v1*(k1*(k2+k3)))
end function z_ahh_DP
<<Implementation of couplings>>=
pure function a_hhz_PB (g, h1, k1, h2, k2, v3, k3) result (vout)
complex(kind=default), intent(in) :: g
complex(kind=default), intent(in) :: h1, h2
type(vector), intent(in) :: v3
type(momentum), intent(in) :: k1, k2, k3
type(vector) :: vout
vout = g * h1 * h2 * (k3*((k1+k2+k3)*v3) - v3*((k1+k2+k3)*k3))
end function a_hhz_PB
<<Implementation of couplings>>=
pure function h_ahz_PB (g, v1, k1, h2, k2, v3, k3) result (hout)
complex(kind=default), intent(in) :: g
complex(kind=default), intent(in) :: h2
type(vector), intent(in) :: v1, v3
type(momentum), intent(in) :: k1, k2, k3
complex(kind=default) :: hout
hout = g * h2 * ((-k1*v3)*(k3*v1) + (k1*k3)*(v1*v3))
end function h_ahz_PB
<<Implementation of couplings>>=
pure function z_ahh_PB (g, v1, k1, h2, k2, h3, k3) result (vout)
complex(kind=default), intent(in) :: g
type(vector), intent(in) :: v1
complex(kind=default), intent(in) :: h2, h3
type(momentum), intent(in) :: k1, k2, k3
type(vector) :: vout
vout = g * h2 * h3 * (k1*((k1+k2+k3)*v1) - v1*(k1*(k1+k2+k3)))
end function z_ahh_PB
<<Declaration of couplings>>=
public :: h_wwz_DW, w_hwz_DW, z_hww_DW, h_wwz_DPB, w_hwz_DPB, z_hww_DPB
public :: h_wwz_DDPW, w_hwz_DDPW, z_hww_DDPW, h_wwz_DPW, w_hwz_DPW, z_hww_DPW
<<Implementation of couplings>>=
pure function h_wwz_DW (g, v1, k1, v2, k2, v3, k3) result (hout)
complex(kind=default), intent(in) :: g
type(vector), intent(in) :: v1, v2, v3
type(momentum), intent(in) :: k1, k2, k3
complex(kind=default) :: hout
hout = g * (((k1-k2)*v3)*(v1*v2)-((2*k1+k2)*v2)*(v1*v3) + &
((k1+2*k2)*v1)*(v2*v3))
end function h_wwz_DW
<<Implementation of couplings>>=
pure function w_hwz_DW (g, h1, k1, v2, k2, v3, k3) result (vout)
complex(kind=default), intent(in) :: g
complex(kind=default), intent(in) :: h1
type(vector), intent(in) :: v2, v3
type(momentum), intent(in) :: k1, k2, k3
type(vector) :: vout
vout = g * h1 * ( v2*(-(k1+2*k2+k3)*v3) + v3*((2*k1+k2+2*k3)*v2) - &
(k1 - k2 + k3)*(v2*v3))
end function w_hwz_DW
<<Implementation of couplings>>=
pure function z_hww_DW (g, h1, k1, v2, k2, v3, k3) result (vout)
complex(kind=default), intent(in) :: g
complex(kind=default), intent(in) :: h1
type(vector), intent(in) :: v2, v3
type(momentum), intent(in) :: k1, k2, k3
type(vector) :: vout
vout = g * h1 * ((k2-k3)*(v2*v3) - v2*((2*k2+k3)*v3) + v3*((k2+2*k3)*v2))
end function z_hww_DW
<<Implementation of couplings>>=
pure function h_wwz_DPB (g, v1, k1, v2, k2, v3, k3) result (hout)
complex(kind=default), intent(in) :: g
type(vector), intent(in) :: v1, v2, v3
type(momentum), intent(in) :: k1, k2, k3
complex(kind=default) :: hout
hout = g * ((k3*v1)*(v2*v3) - (k3*v2)*(v1*v3))
end function h_wwz_DPB
<<Implementation of couplings>>=
pure function w_hwz_DPB (g, h1, k1, v2, k2, v3, k3) result (vout)
complex(kind=default), intent(in) :: g
complex(kind=default), intent(in) :: h1
type(vector), intent(in) :: v2, v3
type(momentum), intent(in) :: k1, k2, k3
type(vector) :: vout
vout = g * h1 * (k3*(v2*v3) - v3*(k3*v2))
end function w_hwz_DPB
<<Implementation of couplings>>=
pure function z_hww_DPB (g, h1, k1, v2, k2, v3, k3) result (vout)
complex(kind=default), intent(in) :: g
complex(kind=default), intent(in) :: h1
type(vector), intent(in) :: v2, v3
type(momentum), intent(in) :: k1, k2, k3
type(vector) :: vout
vout = g * h1 * (((k1+k2+k3)*v3)*v2 - ((k1+k2+k3)*v2)*v3)
end function z_hww_DPB
<<Implementation of couplings>>=
pure function h_wwz_DDPW (g, v1, k1, v2, k2, v3, k3) result (hout)
complex(kind=default), intent(in) :: g
type(vector), intent(in) :: v1, v2, v3
type(momentum), intent(in) :: k1, k2, k3
complex(kind=default) :: hout
hout = g * (((k1-k2)*v3)*(v1*v2)-((k1-k3)*v2)*(v1*v3)+((k2-k3)*v1)*(v2*v3))
end function h_wwz_DDPW
<<Implementation of couplings>>=
pure function w_hwz_DDPW (g, h1, k1, v2, k2, v3, k3) result (vout)
complex(kind=default), intent(in) :: g
complex(kind=default), intent(in) :: h1
type(vector), intent(in) :: v2, v3
type(momentum), intent(in) :: k1, k2, k3
type(vector) :: vout
vout = g * h1 * ((-(k1+2*k2+k3)*v3)*v2 + ((k1+k2+2*k3)*v2)*v3 + &
(v2*v3)*(k2-k3))
end function w_hwz_DDPW
<<Implementation of couplings>>=
pure function z_hww_DDPW (g, h1, k1, v2, k2, v3, k3) result (vout)
complex(kind=default), intent(in) :: g
complex(kind=default), intent(in) :: h1
type(vector), intent(in) :: v2, v3
type(momentum), intent(in) :: k1, k2, k3
type(vector) :: vout
vout = g * h1 * ((v2*v3)*(k2-k3) - ((k1+2*k2+k3)*v3) *v2 + &
((k1+k2+2*k3)*v2)*v3 )
end function z_hww_DDPW
<<Implementation of couplings>>=
pure function h_wwz_DPW (g, v1, k1, v2, k2, v3, k3) result (hout)
complex(kind=default), intent(in) :: g
type(vector), intent(in) :: v1, v2, v3
type(momentum), intent(in) :: k1, k2, k3
complex(kind=default) :: hout
hout = g * (((k1-k2)*v3)*(v1*v2) + (-(2*k1+k2+k3)*v2)*(v1*v3) + &
((k1+2*k2+k3)*v1)*(v2*v3))
end function h_wwz_DPW
<<Implementation of couplings>>=
pure function w_hwz_DPW (g, h1, k1, v2, k2, v3, k3) result (vout)
complex(kind=default), intent(in) :: g
complex(kind=default), intent(in) :: h1
type(vector), intent(in) :: v2, v3
type(momentum), intent(in) :: k1, k2, k3
type(vector) :: vout
vout = g * h1 * ((-(k1+2*k2+k3)*v3)*v2 + ((2*k1+k2+k3)*v2)*v3 + &
(v2*v3)*(k2-k1))
end function w_hwz_DPW
<<Implementation of couplings>>=
pure function z_hww_DPW (g, h1, k1, v2, k2, v3, k3) result (vout)
complex(kind=default), intent(in) :: g
complex(kind=default), intent(in) :: h1
type(vector), intent(in) :: v2, v3
type(momentum), intent(in) :: k1, k2, k3
type(vector) :: vout
vout = g * h1 * ((v2*v3)*(k2-k3) + ((k1-k2)*v3)*v2 + ((k3-k1)*v2)*v3)
end function z_hww_DPW
@ \section{Scalar3 Dim-5 Couplings}
<<Declaration of couplings>>=
public :: phi_dim5s2
@
\begin{equation}
\phi_1(k_1) = g (k_2 \cdot k_3) \phi_2 (k_2) \phi_3 (k_3)
\end{equation}
<<Implementation of couplings>>=
pure function phi_dim5s2 (g, phi2, k2, phi3, k3) result (phi1)
complex(kind=default), intent(in) :: g, phi2, phi3
type(momentum), intent(in) :: k2, k3
complex(kind=default) :: phi1
phi1 = g * phi2 * phi3 * (k2 * k3)
end function phi_dim5s2
@ \section{Tensorscalar-Scalar Couplings}
<<Declaration of couplings>>=
public :: tphi_ss, tphi_ss_cf, s_tphis, s_tphis_cf
@
\begin{equation}
\phi(k_1 + k_2) = 2 g ((k_1 \cdot k_2) + (k_1 \cdot k_1))
((k_1 \cdot k_2) + (k_2 \cdot k_2))
\phi_1 (k_1) \phi_2 (k_2)
\end{equation}
<<Implementation of couplings>>=
pure function tphi_ss (g, phi1, k1, phi2, k2) result (phi)
complex(kind=default), intent(in) :: g, phi1, phi2
type(momentum), intent(in) :: k1, k2
complex(kind=default) :: phi
phi = 2 * g * phi1 * phi2 * &
((k1 * k2)+ (k1 * k1)) * &
((k1 * k2)+ (k2 * k2))
end function tphi_ss
@
\begin{equation}
\phi(k_1 + k_2) = - g/2 (k_1 \cdot k_2)
((k_1 + k_2) \cdot (k_1 + k_2))
\phi_1 (k_1) \phi_2 (k_2)
\end{equation}
<<Implementation of couplings>>=
pure function tphi_ss_cf (g, phi1, k1, phi2, k2) result (phi)
complex(kind=default), intent(in) :: g, phi1, phi2
type(momentum), intent(in) :: k1, k2
complex(kind=default) :: phi
phi = - g/2 * phi1 * phi2 * &
(k1 * k2) * &
((k1 + k2) * (k1 + k2))
end function tphi_ss_cf
@
\begin{equation}
\phi_1(k_1) = 2 g ((k_1 \cdot k_2) + (k_1 \cdot k_1))
((k_1 \cdot k_2) + (k_2 \cdot k_2))
\phi(k_2-k_1) \phi_2 (k_2)
\end{equation}
<<Implementation of couplings>>=
pure function s_tphis (g, phi, k, phi2, k2) result (phi1)
complex(kind=default), intent(in) :: g, phi, phi2
type(momentum), intent(in) :: k, k2
complex(kind=default) :: phi1
type(momentum) :: k1
k1 = - ( k + k2)
phi1 = 2 * g * phi * phi2 * &
((k1 * k2)+ (k1 * k1)) * &
((k1 * k2)+ (k2 * k2))
end function s_tphis
@
\begin{equation}
\phi_1(k_1) = - g/2 (k_1 \cdot k_2)
((k_1 + k_2) \cdot (k_1 + k_2))
\phi (k_2 -k_1) \phi_2 (k_2)
\end{equation}
<<Implementation of couplings>>=
pure function s_tphis_cf (g, phi, k, phi2, k2) result (phi1)
complex(kind=default), intent(in) :: g, phi, phi2
type(momentum), intent(in) :: k, k2
complex(kind=default) :: phi1
type(momentum) :: k1
k1 = - ( k + k2)
phi1 = - g/2 * phi * phi2 * &
(k1 * k2) * &
((k1 + k2) * (k1 + k2))
end function s_tphis_cf
@ \section{Scalar2-Vector2 Dim-8 Couplings}
<<Declaration of couplings>>=
public :: phi_phi2v_1, v_phi2v_1, phi_phi2v_2, v_phi2v_2
@
\begin{equation}
\phi_2(k_2) = g \left (\left ( k_1 \cdot V_1 \right ) \left ( k_2 \cdot V_2 \right )
+ \left ( k_1 \cdot V_1 \right )\left ( k_1 \cdot V_2 \right ) \right )
\phi_1 (k_1)
\end{equation}
<<Implementation of couplings>>=
pure function phi_phi2v_1 (g, phi1, k1, v1, k_v1, v2, k_v2) result (phi2)
complex(kind=default), intent(in) :: g, phi1
type(momentum), intent(in) :: k1, k_v1, k_v2
type(momentum) :: k2
type(vector), intent(in) :: v1, v2
complex(kind=default) :: phi2
k2 = - k1 - k_v1 - k_v2
phi2 = g * phi1 * &
( (k1 * v1) * (k2 * v2) + (k1 * v2) * (k2 * v1) )
end function phi_phi2v_1
@
\begin{equation}
V_2^\mu =g \left ( k_1^\mu \left ( k_2 \cdot V_1 \right )
+ k_2^\mu \left ( k_1 \cdot V_1 \right ) \right )
\phi_1 (k_1) \phi_2 (k_2)
\end{equation}
<<Implementation of couplings>>=
pure function v_phi2v_1 (g, phi1, k1, phi2, k2, v1) result (v2)
complex(kind=default), intent(in) :: g, phi1, phi2
type(momentum), intent(in) :: k1, k2
type(vector), intent(in) :: v1
type(vector) :: v2
v2 = g * phi1 * phi2 * &
( k1 * (k2 * v1) + k2 * (k1 * v1) )
end function v_phi2v_1
@
\begin{equation}
\phi_2(k_2) = g \left ( k_1 \cdot k_2 \right ) \left ( V_1\cdot V_2 \right)
\phi_1 (k_1)
\end{equation}
<<Implementation of couplings>>=
pure function phi_phi2v_2 (g, phi1, k1, v1,k_v1, v2, k_v2) result (phi2)
complex(kind=default), intent(in) :: g, phi1
type(momentum), intent(in) :: k1, k_v1, k_v2
type(vector), intent(in) :: v1, v2
type(momentum) :: k2
complex(kind=default) :: phi2
k2 = - k1 - k_v1 - k_v2
phi2 = g * phi1 * (k1 * k2) * (v1 * v2)
end function phi_phi2v_2
@
\begin{equation}
V_2^\mu = g V_1^\mu \left ( k_1 \cdot k_2 \right ) \phi_1 \phi_2
\end{equation}
<<Implementation of couplings>>=
pure function v_phi2v_2 (g, phi1, k1, phi2, k2, v1) result (v2)
complex(kind=default), intent(in) :: g, phi1, phi2
type(momentum), intent(in) :: k1, k2
type(vector), intent(in) :: v1
type(vector) :: v2
v2 = g * phi1 * phi2 * &
( k1 * k2 ) * v1
end function v_phi2v_2
@ \section{Scalar4 Dim-8 Couplings}
<<Declaration of couplings>>=
public :: s_dim8s3
@
\begin{equation}
\phi(k_1) = g \left [ \left ( k_1 \cdot k_2 \right ) \left ( k_3 \cdot k_4 \right )+
\left ( k_1 \cdot k_3 \right ) \left ( k_2 \cdot k_4 \right ) +
\left ( k_1 \cdot k_4 \right )\left ( k_2 \cdot k_3 \right ) \right ]
\phi_2 (k_2) \phi_3 (k_3) \phi_4 (k_4)
\end{equation}
<<Implementation of couplings>>=
pure function s_dim8s3 (g, phi2, k2, phi3, k3, phi4, k4) result (phi1)
complex(kind=default), intent(in) :: g, phi2, phi3, phi4
type(momentum), intent(in) :: k2, k3, k4
type(momentum) :: k1
complex(kind=default) :: phi1
k1 = - k2 - k3 - k4
phi1 = g * ( (k1 * k2) * (k3 * k4) + (k1 * k3) * (k2 * k4) &
+ (k1 * k4) * (k2 * k3) ) * phi2 * phi3 * phi4
end function s_dim8s3
@ \section{Mixed Scalar2-Vector2 Dim-8 Couplings}
<<Declaration of couplings>>=
public :: phi_phi2v_m_0, v_phi2v_m_0, phi_phi2v_m_1, v_phi2v_m_1, phi_phi2v_m_7, v_phi2v_m_7
@
\begin{equation}
\phi_2(k_2) = g \left (\left ( V_1 \cdot k_{V_2} \right )
\left ( V_2 \cdot k_{V_1} \right )
\left ( k_1 \cdot k_2 \right )
- (\left ( V_1 \cdot V_2 \right )
\left ( k_{V_1} \cdot k_{V_2} \right )
\left ( k_1 \cdot k_2 \right ) \right )
\phi_1 (k_1)
\end{equation}
<<Implementation of couplings>>=
pure function phi_phi2v_m_0 (g, phi1, k1, v1, k_v1, v2, k_v2) result (phi2)
complex(kind=default), intent(in) :: g, phi1
type(momentum), intent(in) :: k1, k_v1, k_v2
type(momentum) :: k2
type(vector), intent(in) :: v1, v2
complex(kind=default) :: phi2
k2 = - k1 - k_v1 - k_v2
phi2 = g * phi1 * &
( (v1 * k_v2) * (v2 * k_v1) * (k1 * k2) &
- (v1 * v2) * (k_v1 * k_v2) * (k1 * k2) )
end function phi_phi2v_m_0
@
\begin{equation}
V_2^\mu =g \left ( k_{V_1}^\mu \left ( V_1 \cdot k_{V_2} \right )
\left ( k_1 \cdot k_2 \right )
- V_1^\mu \left ( k_{V_1} \cdot k_{V_2} \right )
\left ( k_1 \cdot k_2 \right )
\right )
\phi_1 (k_1) \phi_2 (k_2))
\end{equation}
<<Implementation of couplings>>=
pure function v_phi2v_m_0 (g, phi1, k1, phi2, k2, v1, k_v1) result (v2)
complex(kind=default), intent(in) :: g, phi1, phi2
type(momentum), intent(in) :: k1, k2, k_v1
type(vector), intent(in) :: v1
type(momentum) :: k_v2
type(vector) :: v2
k_v2 = - k_v1 - k1 - k2
v2 = g * phi1 * phi2 * &
( k_v1 * (v1 * k_v2) * (k1 * k2) &
- v1 * (k_v2 * k_v1) * (k1 * k2) )
end function v_phi2v_m_0
@
\begin{equation}
\phi_2(k_2) = g \left (\left ( V_1 \cdot V_2 \right )
\left ( k_1 \cdot k_{V_2} \right )
\left ( k_2 \cdot k_{V_1} \right )
+ (\left ( V_1 \cdot V_2 \right )
\left ( k_1 \cdot k_{V_1} \right )
\left ( k_2 \cdot k_{V_2} \right ) \\
+ (\left ( V_1 \cdot k_2 \right )
\left ( V_2 \cdot k_1 \right )
\left ( k_{V_1} \cdot k_{V_2} \right )
+ (\left ( V_1 \cdot k_1 \right )
\left ( V_2 \cdot k_2 \right )
\left ( k_{V_1} \cdot k_{V_2} \right ) \\
- (\left ( V_1 \cdot k_{V_2} \right )
\left ( V_2 \cdot k_2 \right )
\left ( k_1 \cdot k_{V_1} \right )
- (\left ( V_1 \cdot k_2 \right )
\left ( V_2 \cdot k_{V_1} \right )
\left ( k_1 \cdot k_{V_2} \right ) \\
- (\left ( V_1 \cdot k_{V_2} \right )
\left ( V_2 \cdot k_1 \right )
\left ( k_2 \cdot k_{V_1} \right )
- (\left ( V_1 \cdot k_1 \right )
\left ( V_2 \cdot k_{V_1} \right )
\left ( k_2 \cdot k_{V_2} \right )
\right )
\phi_1 (k_1)
\end{equation}
<<Implementation of couplings>>=
pure function phi_phi2v_m_1 (g, phi1, k1, v1, k_v1, v2, k_v2) result (phi2)
complex(kind=default), intent(in) :: g, phi1
type(momentum), intent(in) :: k1, k_v1, k_v2
type(momentum) :: k2
type(vector), intent(in) :: v1, v2
complex(kind=default) :: phi2
k2 = - k1 - k_v1 - k_v2
phi2 = g * phi1 * &
( (v1 * v2) * (k1 * k_v2) * (k2 * k_v1) &
+ (v1 * v2) * (k1 * k_v1) * (k2 * k_v2) &
+ (v1 * k2) * (v2 * k1) * (k_v1 * k_v2) &
+ (v1 * k1) * (v2 * k2) * (k_v1 * k_v2) &
- (v1 * k_v2) * (v2 * k2) * (k1 * k_v1) &
- (v1 * k2) * (v2 * k_v1) * (k1 * k_v2) &
- (v1 * k_v2) * (v2 * k1) * (k2 * k_v1) &
- (v1 * k1) * (v2 * k_v1) * (k2 * k_v2) )
end function phi_phi2v_m_1
@
\begin{equation}
V_2^\mu =g \left ( k_1^\mu \left ( V_1 \cdot k_2 \right )
\left ( k_{V_1} \cdot k_{V_2} \right ) \\
+ k_2^\mu \left ( V_1 \cdot k_1 \right )
\left ( k_{V_1} \cdot k_{V_2} \right ) \\
+ V_1^\mu \left ( k_{V_1} \cdot k_1 \right )
\left ( k_{V_2} \cdot k_2 \right ) \\
+ V_1^\mu \left ( k_{V_1} \cdot k_2 \right )
\left ( k_{V_2} \cdot k_1 \right ) \\
- k_1^\mu \left ( V_1 \cdot k_{V_2} \right )
\left ( k_{V_1} \cdot k_2 \right ) \\
- k_2^\mu \left ( V_1 \cdot k_{V_2} \right )
\left ( k_{V_1} \cdot k_1 \right ) \\
- k_{V_1}^\mu \left ( V_1 \cdot k_1 \right )
\left ( k_{V_2} \cdot k_2 \right ) \\
- k_{V_1}^\mu \left ( V_1 \cdot k_2 \right )
\left ( k_{V_2} \cdot k_1 \right )
\right ) \\
\phi_1 (k_1) \phi_2 (k_2)
\end{equation}
<<Implementation of couplings>>=
pure function v_phi2v_m_1 (g, phi1, k1, phi2, k2, v1, k_v1) result (v2)
complex(kind=default), intent(in) :: g, phi1, phi2
type(momentum), intent(in) :: k1, k2, k_v1
type(vector), intent(in) :: v1
type(momentum) :: k_v2
type(vector) :: v2
k_v2 = - k_v1 - k1 - k2
v2 = g * phi1 * phi2 * &
( k1 * (v1 * k2) * (k_v1 * k_v2) &
+ k2 * (v1 * k1) * (k_v1 * k_v2) &
+ v1 * (k_v1 * k1) * (k_v2 * k2) &
+ v1 * (k_v1 * k2) * (k_v2 * k1) &
- k1 * (v1 * k_v2) * (k_v1 * k2) &
- k2 * (v1 * k_v2) * (k_v1 * k1) &
- k_v1 * (v1 * k1) * (k_v2 * k2) &
- k_v1 * (v1 * k2) * (k_v2 * k1) )
end function v_phi2v_m_1
@
\begin{equation}
\phi_2(k_2) = g \left (\left ( V_1 \cdot k_{V_2} \right )
\left ( k_1 \cdot V_2 \right )
\left ( k_2 \cdot k_{V_1} \right )
+ (\left ( V_1 \cdot k_{V_2} \right )
\left ( k_1 \cdot k_{V_1} \right )
\left ( k_2 \cdot k_{V_2} \right ) \\
+ (\left ( V_1 \cdot k_1 \right )
\left ( V_2 \cdot k_{V_1} \right )
\left ( k_2 \cdot k_{V_2} \right )
+ (\left ( V_1 \cdot k_2 \right )
\left ( V_2 \cdot k_{V_1} \right )
\left ( k_1 \cdot k_{V_2} \right ) \\
- (\left ( V_1 \cdot V_2 \right )
\left ( k_1 \cdot k_{V_2} \right )
\left ( k_2 \cdot k_{V_1} \right )
- (\left ( V_1 \cdot V_2 \right )
\left ( k_1 \cdot k_{V_1} \right )
\left ( k_2 \cdot k_{V_2} \right ) \\
- (\left ( V_1 \cdot k_2 \right )
\left ( V_2 \cdot k_1 \right )
\left ( k_{V_1} \cdot k_{V_2} \right )
- (\left ( V_1 \cdot k_1 \right )
\left ( V_2 \cdot k_2 \right )
\left ( k_{V_1} \cdot k_{V_2} \right )
\right )
\phi_1 (k_1)
\end{equation}
<<Implementation of couplings>>=
pure function phi_phi2v_m_7 (g, phi1, k1, v1, k_v1, v2, k_v2) result (phi2)
complex(kind=default), intent(in) :: g, phi1
type(momentum), intent(in) :: k1, k_v1, k_v2
type(momentum) :: k2
type(vector), intent(in) :: v1, v2
complex(kind=default) :: phi2
k2 = - k1 - k_v1 - k_v2
phi2 = g * phi1 * &
( (v1 * k_v2) * (k1 * v2) * (k2 * k_v1) &
+ (v1 * k_v2) * (k1 * k_v1) * (k2 * v2) &
+ (v1 * k1) * (v2 * k_v1) * (k2 * k_v2) &
+ (v1 * k2) * (v2 * k_v1) * (k1 * k_v2) &
- (v1 * v2) * (k1 * k_v2) * (k2 * k_v1) &
- (v1 * v2) * (k1 * k_v1) * (k2 * k_v2) &
- (v1 * k2) * (v2 * k1) * (k_v1 * k_v2) &
- (v1 * k1) * (v2 * k2) * (k_v1 * k_v2) )
end function phi_phi2v_m_7
@
\begin{equation}
V_2^\mu =g \left ( k_1^\mu \left ( V_1 \cdot k_{V_2} \right )
\left ( k_2 \cdot k_{V_1} \right ) \\
+ k_2^\mu \left ( V_1 \cdot k_{V_2} \right )
\left ( k_1 \cdot k_{V_1} \right ) \\
+ k_{V_1}^\mu \left ( V_1 \cdot k_1 \right )
\left ( k_2 \cdot k_{V_2} \right ) \\
+ k_{V_1}^\mu \left ( V_1 \cdot k_2 \right )
\left ( k_1 \cdot k_{V_2} \right ) \\
- k_1^\mu \left ( V_1 \cdot k_2 \right )
\left ( k_{V_1} \cdot k_{V_2} \right ) \\
- k_2^\mu \left ( V_1 \cdot k_1 \right )
\left ( k_{V_1} \cdot k_{V_2} \right ) \\
- k_{V_1}^\mu \left ( k_1 \cdot k_{V_2} \right )
\left ( k_2 \cdot k_{V_1} \right ) \\
- k_{V_1}^\mu \left ( k_1 \cdot k_{V_1} \right )
\left ( k_2 \cdot k_{V_2} \right )
\right ) \\
\phi_1 (k_1) \phi_2 (k_2)
\end{equation}
<<Implementation of couplings>>=
pure function v_phi2v_m_7 (g, phi1, k1, phi2, k2, v1, k_v1) result (v2)
complex(kind=default), intent(in) :: g, phi1, phi2
type(momentum), intent(in) :: k1, k2, k_v1
type(vector), intent(in) :: v1
type(momentum) :: k_v2
type(vector) :: v2
k_v2 = - k_v1 - k1 - k2
v2 = g * phi1 * phi2 * &
( k1 * (v1 * k_v2) * (k2 * k_v1) &
+ k2 * (v1 * k_v2) * (k1 * k_v1) &
+ k_v1 * (v1 * k1) * (k2 * k_v2) &
+ k_v1 * (v1 * k2) * (k1 * k_v2) &
- k1 * (v1 * k2) * (k_v1 * k_v2) &
- k2 * (v1 * k1) * (k_v1 * k_v2) &
- v1 * (k1 * k_v2) * (k2 * k_v1) &
- v1 * (k1 * k_v1) * (k2 * k_v2) )
end function v_phi2v_m_7
@ \section{Transversal Gauge4 Dim-8 Couplings}
<<Declaration of couplings>>=
public :: g_dim8g3_t_0, g_dim8g3_t_1, g_dim8g3_t_2
@
\begin{equation}
V_1^\mu = g \left [ k_2^\mu \left ( k_1 \cdot V_2 \right ) - V_2^\mu
\left ( k_1 \cdot k_2 \right ) \right ] \left [ \left (
k_3 \cdot V_4 \right) \left ( k_4 \cdot V_3 \right ) -
\left (V_3 \cdot V_4 \right ) \left ( k_3 \cdot k_4 \right )
\right ]
\end{equation}
<<Implementation of couplings>>=
pure function g_dim8g3_t_0 (g, v2, k2, v3, k3, v4, k4) result (v1)
complex(kind=default), intent(in) :: g
type(vector), intent(in) :: v2, v3, v4
type(momentum), intent(in) :: k2, k3, k4
type(vector) :: v1
type(momentum) :: k1
k1 = - k2 - k3 - k4
v1 = g * (k2 * (k1 * v2) - v2 * (k1 * k2)) &
* ((k3 * v4) * (k4 * v3) - (v3 * v4) * (k3 * k4))
end function g_dim8g3_t_0
@
\begin{equation}
V_1^\mu = g \left [ k_2^\mu \left ( k_1 \cdot V_2 \right ) - V_2^\mu
\left ( k_1 \cdot k_2 \right ) \right ] \left [ \left (
k_3 \cdot V_4 \right) \left ( k_4 \cdot V_3 \right ) -
\left (V_3 \cdot V_4 \right ) \left ( k_3 \cdot k_4 \right )
\right ]
\end{equation}
<<Implementation of couplings>>=
pure function g_dim8g3_t_1 (g, v2, k2, v3, k3, v4, k4) result (v1)
complex(kind=default), intent(in) :: g
type(vector), intent(in) :: v2, v3, v4
type(momentum), intent(in) :: k2, k3, k4
type(vector) :: v1
type(momentum) :: k1
k1 = - k2 - k3 - k4
v1 = g * (v3 * (v2 * k4) * (k1 * k3) * (k2 * v4) &
+ v4 * (v2 * k3) * (k1 * k4) * (k2 * v3) &
+ k3 * (v2 * v4) * (k1 * v3) * (k2 * k4) &
+ k4 * (v2 * v3) * (k1 * v4) * (k2 * k3) &
- v3 * (v2 * v4) * (k1 * k3) * (k2 * k4) &
- v4 * (v2 * v3) * (k1 * k4) * (k2 * k3) &
- k3 * (v2 * k4) * (k1 * v3) * (k2 * v4) &
- k4 * (v2 * k3) * (k1 * v4) * (k2 * v3))
end function g_dim8g3_t_1
@
\begin{equation}
V_1^\mu = g \left [ k_2^\mu \left (V_2 \cdot k_3\right ) \left (V_3 \cdot k_4\right ) \left (V_4 \cdot k_1\right ) \\
+ k_3^\mu \left (V_2 \cdot k_1\right ) \left (V_3 \cdot k_4\right ) \left (V_4 \cdot k_2\right ) \\
+ k_2^\mu \left (V_2 \cdot k_4\right ) \left (V_3 \cdot k_1\right ) \left (V_4 \cdot k_3\right ) \\
+ k_4^\mu \left (V_2 \cdot k_1\right ) \left (V_3 \cdot k_2\right ) \left (V_4 \cdot k_3\right ) \\
+ k_4^\mu \left (V_2 \cdot k_3\right ) \left (V_3 \cdot V_4\right ) \left (k_1 \cdot k_2\right ) \\
+ k_3^\mu \left (V_2 \cdot k_4\right ) \left (V_3 \cdot V_4\right ) \left (k_1 \cdot k_2\right ) \\
- k_3^\mu \left (V_2 \cdot V_4\right ) \left (V_3 \cdot k_4\right ) \left (k_1 \cdot k_2\right ) \\
- V_4^\mu \left (V_2 \cdot k_3\right ) \left (V_3 \cdot k_4\right ) \left (k_1 \cdot k_2\right ) \\
- k_4^\mu \left (V_2 \cdot V_3\right ) \left (V_4 \cdot k_3\right ) \left (k_1 \cdot k_2\right ) \\
- V_3^\mu \left (V_2 \cdot k_4\right ) \left (V_4 \cdot k_3\right ) \left (k_1 \cdot k_2\right ) \\
- k_2^\mu \left (V_2 \cdot k_4\right ) \left (V_3 \cdot V_4\right ) \left (k_1 \cdot k_3\right ) \\
+ k_2^\mu \left (V_2 \cdot V_4\right ) \left (V_3 \cdot k_4\right ) \left (k_1 \cdot k_3\right ) \\
- V_2^\mu \left (V_3 \cdot k_4\right ) \left (V_4 \cdot k_2\right ) \left (k_1 \cdot k_3\right ) \\
- k_2^\mu \left (V_2 \cdot k_3\right ) \left (V_3 \cdot V_4\right ) \left (k_1 \cdot k_4\right ) \\
+ k_2^\mu \left (V_2 \cdot V_3\right ) \left (V_4 \cdot k_3\right ) \left (k_1 \cdot k_4\right ) \\
- V_2^\mu \left (V_3 \cdot k_2\right ) \left (V_4 \cdot k_3\right ) \left (k_1 \cdot k_4\right ) \\
- k_4^\mu \left (V_2 \cdot k_1\right ) \left (V_3 \cdot V_4\right ) \left (k_2 \cdot k_3\right ) \\
+ V_4^\mu \left (V_2 \cdot k_1\right ) \left (V_3 \cdot k_4\right ) \left (k_2 \cdot k_3\right ) \\
- V_2^\mu \left (V_3 \cdot k_4\right ) \left (V_4 \cdot k_1\right ) \left (k_2 \cdot k_3\right ) \\
+ V_2^\mu \left (V_3 \cdot V_4\right ) \left (k_1 \cdot k_4\right ) \left (k_2 \cdot k_3\right ) \\
- k_3^\mu \left (V_2 \cdot k_1\right ) \left (V_3 \cdot V_4\right ) \left (k_2 \cdot k_4\right ) \\
+ V_3^\mu \left (V_2 \cdot k_1\right ) \left (V_4 \cdot k_3\right ) \left (k_2 \cdot k_4\right ) \\
- V_2^\mu \left (V_3 \cdot k_1\right ) \left (V_4 \cdot k_3\right ) \left (k_2 \cdot k_4\right ) \\
+ V_2^\mu \left (V_3 \cdot V_4\right ) \left (k_1 \cdot k_3\right ) \left (k_2 \cdot k_4\right ) \\
- k_2^\mu \left (V_2 \cdot V_4\right ) \left (V_3 \cdot k_1\right ) \left (k_3 \cdot k_4\right ) \\
- V_4^\mu \left (V_2 \cdot k_1\right ) \left (V_3 \cdot k_2\right ) \left (k_3 \cdot k_4\right ) \\
- k_2^\mu \left (V_2 \cdot V_3\right ) \left (V_4 \cdot k_1\right ) \left (k_3 \cdot k_4\right ) \\
+ V_2^\mu \left (V_3 \cdot k_2\right ) \left (V_4 \cdot k_1\right ) \left (k_3 \cdot k_4\right ) \\
- V_3^\mu \left (V_2 \cdot k_1\right ) \left (V_4 \cdot k_2\right ) \left (k_3 \cdot k_4\right ) \\
+ V_2^\mu \left (V_3 \cdot k_1\right ) \left (V_4 \cdot k_2\right ) \left (k_3 \cdot k_4\right ) \\
+ V_4^\mu \left (V_2 \cdot V_3\right ) \left (k_1 \cdot k_2\right ) \left (k_3 \cdot k_4\right ) \\
+ V_3^\mu \left (V_2 \cdot V_4\right ) \left (k_1 \cdot k_2\right ) \left (k_3 \cdot k_4\right )
\right ]
\end{equation}
<<Implementation of couplings>>=
pure function g_dim8g3_t_2 (g, v2, k2, v3, k3, v4, k4) result (v1)
complex(kind=default), intent(in) :: g
type(vector), intent(in) :: v2, v3, v4
type(momentum), intent(in) :: k2, k3, k4
type(vector) :: v1
type(momentum) :: k1
k1 = - k2 - k3 - k4
v1 = g * (k2 * (v2 * k3) * (v3 * k4) * (v4 * k1) &
+ k3 * (v2 * k1) * (v3 * k4) * (v4 * k2) &
+ k2 * (v2 * k4) * (v3 * k1) * (v4 * k3) &
+ k4 * (v2 * k1) * (v3 * k2) * (v4 * k3) &
+ k4 * (v2 * k3) * (v3 * v4) * (k1 * k2) &
+ k3 * (v2 * k4) * (v3 * v4) * (k1 * k2) &
- k3 * (v2 * v4) * (v3 * k4) * (k1 * k2) &
- v4 * (v2 * k3) * (v3 * k4) * (k1 * k2) &
- k4 * (v2 * v3) * (v4 * k3) * (k1 * k2) &
- v3 * (v2 * k4) * (v4 * k3) * (k1 * k2) &
- k2 * (v2 * k4) * (v3 * v4) * (k1 * k3) &
+ k2 * (v2 * v4) * (v3 * k4) * (k1 * k3) &
- v2 * (v3 * k4) * (v4 * k2) * (k1 * k3) &
- k2 * (v2 * k3) * (v3 * v4) * (k1 * k4) &
+ k2 * (v2 * v3) * (v4 * k3) * (k1 * k4) &
- v2 * (v3 * k2) * (v4 * k3) * (k1 * k4) &
- k4 * (v2 * k1) * (v3 * v4) * (k2 * k3) &
+ v4 * (v2 * k1) * (v3 * k4) * (k2 * k3) &
- v2 * (v3 * k4) * (v4 * k1) * (k2 * k3) &
+ v2 * (v3 * v4) * (k1 * k4) * (k2 * k3) &
- k3 * (v2 * k1) * (v3 * v4) * (k2 * k4) &
+ v3 * (v2 * k1) * (v4 * k3) * (k2 * k4) &
- v2 * (v3 * k1) * (v4 * k3) * (k2 * k4) &
+ v2 * (v3 * v4) * (k1 * k3) * (k2 * k4) &
- k2 * (v2 * v4) * (v3 * k1) * (k3 * k4) &
- v4 * (v2 * k1) * (v3 * k2) * (k3 * k4) &
- k2 * (v2 * v3) * (v4 * k1) * (k3 * k4) &
+ v2 * (v3 * k2) * (v4 * k1) * (k3 * k4) &
- v3 * (v2 * k1) * (v4 * k2) * (k3 * k4) &
+ v2 * (v3 * k1) * (v4 * k2) * (k3 * k4) &
+ v4 * (v2 * v3) * (k1 * k2) * (k3 * k4) &
+ v3 * (v2 * v4) * (k1 * k2) * (k3 * k4))
end function g_dim8g3_t_2
@ \section{Mixed Gauge4 Dim-8 Couplings}
<<Declaration of couplings>>=
public :: g_dim8g3_m_0, g_dim8g3_m_1, g_dim8g3_m_7
@
\begin{equation}
V_1^\mu = g_1 \left [ V_2^\mu \left (V_3 \cdot V_4\right ) \left (k_1 \cdot k_2\right ) \\
- k_2^\mu \left (V_2 \cdot k_1\right ) \left (V_3 \cdot V_4\right ) \\
\right ] \\
+ g_2 \left [ V_2^\mu \left (V_3 \cdot V_4\right ) \left (k_3 \cdot k_4\right ) \\
- V_2^\mu \left (V_3 \cdot k_4\right ) \left (V_4 \cdot k_3\right ) \\
\right ]
\end{equation}
<<Implementation of couplings>>=
pure function g_dim8g3_m_0 (g1, g2, v2, k2, v3, k3, v4, k4) result (v1)
complex(kind=default), intent(in) :: g1, g2
type(vector), intent(in) :: v2, v3, v4
type(momentum), intent(in) :: k2, k3, k4
type(vector) :: v1
type(momentum) :: k1
k1 = - k2 - k3 - k4
v1 = g1 * (v2 * (v3 * v4) * (k1 * k2) &
- k2 * (v2 * k1) * (v3 * v4)) &
+ g2 * (v2 * (v3 * v4) * (k3 * k4) &
- v2 * (v3 * k4) * (v4 * k3))
end function g_dim8g3_m_0
@
\begin{equation}
V_1^\mu = g_1 \left [ k_2^\mu \left (V_2 \cdot V_4\right ) \left (V_3 \cdot k_1\right ) \\
+ V_4^\mu \left (V_2 \cdot k_1\right ) \left (V_3 \cdot k_2\right ) \\
+ k_2^\mu \left (V_2 \cdot V_3\right ) \left (V_4 \cdot k_1\right ) \\
+ V_3^\mu \left (V_2 \cdot k_1\right ) \left (V_4 \cdot k_2\right ) \\
- V_2^\mu \left (V_3 \cdot k_2\right ) \left (V_4 \cdot k_1\right ) \\
- V_2^\mu \left (V_3 \cdot k_1\right ) \left (V_4 \cdot k_2\right ) \\
- V_4^\mu \left (V_2 \cdot V_3\right ) \left (k_1 \cdot k_2\right ) \\
- V_3^\mu \left (V_2 \cdot V_4\right ) \left (k_1 \cdot k_2\right ) \\
\right ] \\
+ g_2 \left [ k_3^\mu \left (V_2 \cdot V_4\right ) \left (V_3 \cdot k_4\right ) \\
- k_4^\mu \left (V_2 \cdot k_3\right ) \left (V_3 \cdot V_4\right ) \\
- k_3^\mu \left (V_2 \cdot k_4\right ) \left (V_3 \cdot V_4\right ) \\
+ V_4^\mu \left (V_2 \cdot k_3\right ) \left (V_3 \cdot k_4\right ) \\
+ k_4^\mu \left (V_2 \cdot V_3\right ) \left (V_4 \cdot k_3\right ) \\
+ V_3^\mu \left (V_2 \cdot k_4\right ) \left (V_4 \cdot k_3\right ) \\
- V_4^\mu \left (V_2 \cdot V_3\right ) \left (k_3 \cdot k_4\right ) \\
- V_3^\mu \left (V_2 \cdot V_4\right ) \left (k_3 \cdot k_4\right ) \\
\right ]
\end{equation}
<<Implementation of couplings>>=
pure function g_dim8g3_m_1 (g1, g2, v2, k2, v3, k3, v4, k4) result (v1)
complex(kind=default), intent(in) :: g1, g2
type(vector), intent(in) :: v2, v3, v4
type(momentum), intent(in) :: k2, k3, k4
type(vector) :: v1
type(momentum) :: k1
k1 = - k2 - k3 - k4
v1 = g1 * (k2 * (v2 * v4) * (v3 * k1) &
+ v4 * (v2 * k1) * (v3 * k2) &
+ k2 * (v2 * v3) * (v4 * k1) &
+ v3 * (v2 * k1) * (v4 * k2) &
- v2 * (v3 * k2) * (v4 * k1) &
- v2 * (v3 * k1) * (v4 * k2) &
- v4 * (v2 * v3) * (k1 * k2) &
- v3 * (v2 * v4) * (k1 * k2)) &
+ g2 * (k3 * (v2 * v4) * (v3 * k4) &
- k4 * (v2 * k3) * (v3 * v4) &
- k3 * (v2 * k4) * (v3 * v4) &
+ v4 * (v2 * k3) * (v3 * k4) &
+ k4 * (v2 * v3) * (v4 * k3) &
+ v3 * (v2 * k4) * (v4 * k3) &
- v4 * (v2 * v3) * (k3 * k4) &
- v3 * (v2 * v4) * (k3 * k4))
end function g_dim8g3_m_1
@
\begin{equation}
V_1^\mu = g_1 \left [ V_2^\mu \left (V_3 \cdot k_2\right ) \left (V_4 \cdot k_1\right ) \\
+ V_2^\mu \left (V_4 \cdot k_1\right ) \left (V_4 \cdot k_2\right ) \\
+ V_4^\mu \left (V_2 \cdot V_3\right ) \left (k_1 \cdot k_2\right ) \\
+ V_3^\mu \left (V_2 \cdot V_4\right ) \left (k_1 \cdot k_2\right ) \\
- k_2^\mu \left (V_2 \cdot V_4\right ) \left (V_3 \cdot k_1\right ) \\
- V_4^\mu \left (V_2 \cdot k_1\right ) \left (V_3 \cdot k_2\right ) \\
- k_2^\mu \left (V_2 \cdot V_3\right ) \left (V_4 \cdot k_1\right ) \\
- V_3^\mu \left (V_2 \cdot k_1\right ) \left (V_4 \cdot k_2\right ) \\
\right ] \\
+ g_2 \left [ k_3^\mu \left (V_2 \cdot k_1\right ) \left (V_3 \cdot V_4\right ) \\
+ k_4^\mu \left (V_2 \cdot k_1\right ) \left (V_3 \cdot V_4\right ) \\
+ k_2^\mu \left (V_2 \cdot k_3\right ) \left (V_3 \cdot V_4\right ) \\
+ k_2^\mu \left (V_2 \cdot k_4\right ) \left (V_3 \cdot V_4\right ) \\
+ V_4^\mu \left (V_2 \cdot k_4\right ) \left (V_3 \cdot k_1\right ) \\
+ k_4^\mu \left (V_2 \cdot V_4\right ) \left (V_3 \cdot k_2\right ) \\
+ V_3^\mu \left (V_2 \cdot k_3\right ) \left (V_4 \cdot k_1\right ) \\
+ V_2^\mu \left (V_3 \cdot k_4\right ) \left (V_4 \cdot k_1\right ) \\
+ V_3^\mu \left (V_2 \cdot V_3\right ) \left (V_4 \cdot k_2\right ) \\
+ V_2^\mu \left (V_3 \cdot k_4\right ) \left (V_4 \cdot k_2\right ) \\
+ V_2^\mu \left (V_3 \cdot k_1\right ) \left (V_4 \cdot k_3\right ) \\
+ V_2^\mu \left (V_3 \cdot k_2\right ) \left (V_4 \cdot k_3\right ) \\
+ V_4^\mu \left (V_2 \cdot V_3\right ) \left (k_1 \cdot k_3\right ) \\
+ V_3^\mu \left (V_2 \cdot V_4\right ) \left (k_1 \cdot k_4\right ) \\
+ V_3^\mu \left (V_2 \cdot V_4\right ) \left (k_2 \cdot k_3\right ) \\
+ V_4^\mu \left (V_2 \cdot V_3\right ) \left (k_2 \cdot k_4\right ) \\
- k_4^\mu \left (V_2 \cdot V_4\right ) \left (V_3 \cdot k_1\right ) \\
- V_4^\mu \left (V_2 \cdot k_3\right ) \left (V_3 \cdot k_1\right ) \\
- k_3^\mu \left (V_2 \cdot V_4\right ) \left (V_3 \cdot k_2\right ) \\
- V_4^\mu \left (V_2 \cdot k_4\right ) \left (V_3 \cdot k_2\right ) \\
- k_2^\mu \left (V_2 \cdot V_4\right ) \left (V_3 \cdot k_4\right ) \\
- V_4^\mu \left (V_2 \cdot k_1\right ) \left (V_3 \cdot k_4\right ) \\
- k_3^\mu \left (V_2 \cdot V_3\right ) \left (V_4 \cdot k_1\right ) \\
- V_3^\mu \left (V_2 \cdot k_4\right ) \left (V_4 \cdot k_1\right ) \\
- k_4^\mu \left (V_2 \cdot V_3\right ) \left (V_4 \cdot k_2\right ) \\
- V_3^\mu \left (V_2 \cdot k_3\right ) \left (V_4 \cdot k_2\right ) \\
- k_2^\mu \left (V_2 \cdot V_3\right ) \left (V_4 \cdot k_3\right ) \\
- V_3^\mu \left (V_2 \cdot k_1\right ) \left (V_4 \cdot k_3\right ) \\
- V_2^\mu \left (V_3 \cdot V_4\right ) \left (k_1 \cdot k_3\right ) \\
- V_2^\mu \left (V_3 \cdot V_4\right ) \left (k_1 \cdot k_4\right ) \\
- V_2^\mu \left (V_3 \cdot V_4\right ) \left (k_2 \cdot k_3\right ) \\
- V_2^\mu \left (V_3 \cdot V_4\right ) \left (k_2 \cdot k_4\right ) \\
\right ]
+ g_3 \left [ k_4^\mu \left (V_2 \cdot k_3\right ) \left (V_3 \cdot V_4\right ) \\
+ k_3^\mu \left (V_2 \cdot k_4\right ) \left (V_3 \cdot V_4\right ) \\
+ V_4^\mu \left (V_2 \cdot V_3\right ) \left (k_3 \cdot k_4\right ) \\
+ V_3^\mu \left (V_2 \cdot V_4\right ) \left (k_3 \cdot k_4\right ) \\
- k_3^\mu \left (V_2 \cdot V_4\right ) \left (V_3 \cdot k_4\right ) \\
- V_4^\mu \left (V_2 \cdot k_3\right ) \left (V_3 \cdot k_4\right ) \\
- k_4^\mu \left (V_2 \cdot V_3\right ) \left (V_4 \cdot k_3\right ) \\
- V_3^\mu \left (V_2 \cdot k_4\right ) \left (V_4 \cdot k_3\right ) \\
\right ]
\end{equation}
<<Implementation of couplings>>=
pure function g_dim8g3_m_7 (g1, g2, g3, v2, k2, v3, k3, v4, k4) result (v1)
complex(kind=default), intent(in) :: g1, g2, g3
type(vector), intent(in) :: v2, v3, v4
type(momentum), intent(in) :: k2, k3, k4
type(vector) :: v1
type(momentum) :: k1
k1 = - k2 - k3 - k4
v1 = g1 * (v2 * (v3 * k2) * (v4 * k1) &
+ v2 * (v3 * k1) * (v4 * k2) &
+ v4 * (v2 * v3) * (k1 * k2) &
+ v3 * (v2 * v4) * (k1 * k2) &
- k2 * (v2 * v4) * (v3 * k1) &
- v4 * (v2 * k1) * (v3 * k2) &
- k2 * (v2 * v3) * (v4 * k1) &
- v3 * (v2 * k1) * (v4 * k2)) &
+ g2 * (k3 * (v2 * k1) * (v3 * v4) &
+ k4 * (v2 * k1) * (v3 * v4) &
+ k2 * (v2 * k3) * (v3 * v4) &
+ k2 * (v2 * k4) * (v3 * v4) &
+ v4 * (v2 * k4) * (v3 * k1) &
+ k4 * (v2 * v4) * (v3 * k2) &
+ v3 * (v2 * k3) * (v4 * k1) &
+ v2 * (v3 * k4) * (v4 * k1) &
+ k3 * (v2 * v3) * (v4 * k2) &
+ v2 * (v3 * k4) * (v4 * k2) &
+ v2 * (v3 * k1) * (v4 * k3) &
+ v2 * (v3 * k2) * (v4 * k3) &
+ v4 * (v2 * v3) * (k1 * k3) &
+ v3 * (v2 * v4) * (k1 * k4) &
+ v3 * (v2 * v4) * (k2 * k3) &
+ v4 * (v2 * v3) * (k2 * k4) &
- k4 * (v2 * v4) * (v3 * k1) &
- v4 * (v2 * k3) * (v3 * k1) &
- k3 * (v2 * v4) * (v3 * k2) &
- v4 * (v2 * k4) * (v3 * k2) &
- k2 * (v2 * v4) * (v3 * k4) &
- v4 * (v2 * k1) * (v3 * k4) &
- k3 * (v2 * v3) * (v4 * k1) &
- v3 * (v2 * k4) * (v4 * k1) &
- k4 * (v2 * v3) * (v4 * k2) &
- v3 * (v2 * k3) * (v4 * k2) &
- k2 * (v2 * v3) * (v4 * k3) &
- v3 * (v2 * k1) * (v4 * k3) &
- v2 * (v3 * v4) * (k1 * k3) &
- v2 * (v3 * v4) * (k1 * k4) &
- v2 * (v3 * v4) * (k2 * k3) &
- v2 * (v3 * v4) * (k2 * k4)) &
+ g3 * (k4 * (v2 * k3) * (v3 * v4) &
+ k3 * (v2 * k4) * (v3 * v4) &
+ v4 * (v2 * v3) * (k3 * k4) &
+ v3 * (v2 * v4) * (k3 * k4) &
- k3 * (v2 * v4) * (v3 * k4) &
- v4 * (v2 * k3) * (v3 * k4) &
- k4 * (v2 * v3) * (v4 * k3) &
- v3 * (v2 * k4) * (v4 * k3))
end function g_dim8g3_m_7
@ \section{Graviton Couplings}
<<Declaration of couplings>>=
public :: s_gravs, v_gravv, grav_ss, grav_vv
@
<<Implementation of couplings>>=
pure function s_gravs (g, m, k1, k2, t, s) result (phi)
complex(kind=default), intent(in) :: g, s
real(kind=default), intent(in) :: m
type(momentum), intent(in) :: k1, k2
type(tensor), intent(in) :: t
complex(kind=default) :: phi, t_tr
t_tr = t%t(0,0) - t%t(1,1) - t%t(2,2) - t%t(3,3)
phi = g * s * (((t*k1)*k2) + ((t*k2)*k1) &
- g * (m**2 + (k1*k2))*t_tr)/2.0_default
end function s_gravs
@
<<Implementation of couplings>>=
pure function grav_ss (g, m, k1, k2, s1, s2) result (t)
complex(kind=default), intent(in) :: g, s1, s2
real(kind=default), intent(in) :: m
type(momentum), intent(in) :: k1, k2
type(tensor) :: t_metric, t
t_metric%t = 0
t_metric%t(0,0) = 1.0_default
t_metric%t(1,1) = - 1.0_default
t_metric%t(2,2) = - 1.0_default
t_metric%t(3,3) = - 1.0_default
t = g*s1*s2/2.0_default * (-(m**2 + (k1*k2)) * t_metric &
+ (k1.tprod.k2) + (k2.tprod.k1))
end function grav_ss
@
<<Implementation of couplings>>=
pure function v_gravv (g, m, k1, k2, t, v) result (vec)
complex(kind=default), intent(in) :: g
real(kind=default), intent(in) :: m
type(momentum), intent(in) :: k1, k2
type(vector), intent(in) :: v
type(tensor), intent(in) :: t
complex(kind=default) :: t_tr
real(kind=default) :: xi
type(vector) :: vec
xi = 1.0_default
t_tr = t%t(0,0) - t%t(1,1) - t%t(2,2) - t%t(3,3)
vec = (-g)/ 2.0_default * (((k1*k2) + m**2) * &
(t*v + v*t - t_tr * v) + t_tr * (k1*v) * k2 &
- (k1*v) * ((k2*t) + (t*k2)) &
- ((k1*(t*v)) + (v*(t*k1))) * k2 &
+ ((k1*(t*k2)) + (k2*(t*k1))) * v)
!!! Unitarity gauge: xi -> Infinity
!!! + (1.0_default/xi) * (t_tr * ((k1*v)*k2) + &
!!! (k2*v)*k2 + (k2*v)*k1 - (k1*(t*v))*k1 + &
!!! (k2*v)*(k2*t) - (v*(t*k1))*k1 - (k2*v)*(t*k2)))
end function v_gravv
@
<<Implementation of couplings>>=
pure function grav_vv (g, m, k1, k2, v1, v2) result (t)
complex(kind=default), intent(in) :: g
type(momentum), intent(in) :: k1, k2
real(kind=default), intent(in) :: m
real(kind=default) :: xi
type(vector), intent (in) :: v1, v2
type(tensor) :: t_metric, t
xi = 0.00001_default
t_metric%t = 0
t_metric%t(0,0) = 1.0_default
t_metric%t(1,1) = - 1.0_default
t_metric%t(2,2) = - 1.0_default
t_metric%t(3,3) = - 1.0_default
t = (-g)/2.0_default * ( &
((k1*k2) + m**2) * ( &
(v1.tprod.v2) + (v2.tprod.v1) - (v1*v2) * t_metric) &
+ (v1*k2)*(v2*k1)*t_metric &
- (k2*v1)*((v2.tprod.k1) + (k1.tprod.v2)) &
- (k1*v2)*((v1.tprod.k2) + (k2.tprod.v1)) &
+ (v1*v2)*((k1.tprod.k2) + (k2.tprod.k1)))
!!! Unitarity gauge: xi -> Infinity
!!! + (1.0_default/xi) * ( &
!!! ((k1*v1)*(k1*v2) + (k2*v1)*(k2*v2) + (k1*v1)*(k2*v2))* &
!!! t_metric) - (k1*v1) * ((k1.tprod.v2) + (v2.tprod.k1)) &
!!! - (k2*v2) * ((k2.tprod.v1) + (v1.tprod.k2)))
end function grav_vv
@ \section{Tensor Couplings}
<<Declaration of couplings>>=
public :: t2_vv, v_t2v, t2_vv_cf, v_t2v_cf, &
t2_vv_1, v_t2v_1, t2_vv_t, v_t2v_t, &
t2_phi2, phi_t2phi, t2_phi2_cf, phi_t2phi_cf
@
\begin{equation}
T_{\mu\nu} = g * V_{1 \,\mu} V_{2\,\nu} + V_{1\,\nu} V_{2\,\mu}
\end{equation}
<<Implementation of couplings>>=
pure function t2_vv (g, v1, v2) result (t)
complex(kind=default), intent(in) :: g
type(vector), intent(in) :: v1, v2
type(tensor) :: t
type(tensor) :: tmp
tmp = v1.tprod.v2
t%t = g * (tmp%t + transpose (tmp%t))
end function t2_vv
@
\begin{equation}
V_{1\,\mu} = g * T_{\mu \nu} V_{2}^{\nu}+ T_{\nu \mu} V_{2}^{\nu}
\end{equation}
<<Implementation of couplings>>=
pure function v_t2v (g, t, v) result (tv)
complex(kind=default), intent(in) :: g
type(tensor), intent(in) :: t
type(vector), intent(in) :: v
type(vector) :: tv
type(tensor) :: tmp
tmp%t = t%t + transpose (t%t)
tv = g * (tmp * v)
end function v_t2v
@
\begin{equation}
T_{\mu\nu} =- \frac{g}{2} V_1^\rho V_{2 \,\rho}
\end{equation}
<<Implementation of couplings>>=
pure function t2_vv_cf (g, v1, v2) result (t)
complex(kind=default), intent(in) :: g
complex(kind=default) :: tmp_s
type(vector), intent(in) :: v1, v2
type(tensor) :: t_metric, t
t_metric%t = 0
t_metric%t(0,0) = 1.0_default
t_metric%t(1,1) = - 1.0_default
t_metric%t(2,2) = - 1.0_default
t_metric%t(3,3) = - 1.0_default
tmp_s = v1 * v2
t%t = - (g /2.0_default) * tmp_s * t_metric%t
end function t2_vv_cf
@
\begin{equation}
V_{1\,\mu} = -\frac{g}{2} T^{\nu}_{ \nu} V_{2}^{\mu}
\end{equation}
<<Implementation of couplings>>=
pure function v_t2v_cf (g, t, v) result (tv)
complex(kind=default), intent(in) :: g
type(tensor), intent(in) :: t
type(vector), intent(in) :: v
type(vector) :: tv, tmp_tv
tmp_tv = ( t%t(0,0)-t%t(1,1)-t%t(2,2)-t%t(3,3) ) * v
tv = - ( g /2.0_default) * tmp_tv
end function v_t2v_cf
@
\begin{equation}
T_{\mu\nu} = g * \left ( k_{1 \,\mu} k_{2\,\nu} + k_{1\,\nu} k_{2\,\mu} \right )
\phi_1 \left ( k_1 \right ) \phi_1 \left ( k_2 \right )
\end{equation}
<<Implementation of couplings>>=
pure function t2_phi2 (g, phi1, k1, phi2, k2) result (t)
complex(kind=default), intent(in) :: g, phi1, phi2
type(momentum), intent(in) :: k1, k2
type(tensor) :: t
type(tensor) :: tmp
tmp = k1.tprod.k2
t%t = g * (tmp%t + transpose (tmp%t)) * phi1 * phi2
end function t2_phi2
@
\begin{equation}
\phi_{1} (k_1) =g * \left ( T_{\mu \nu} k_{1}^{\mu}k_{2}^{\nu}
+ T_{\nu \mu} k_{2}^{\mu}k_{1}^{\nu}
\right ) \phi_2 \left (k_2 \right )
\end{equation}
<<Implementation of couplings>>=
pure function phi_t2phi (g, t, kt, phi2, k2) result (phi1)
complex(kind=default), intent(in) :: g, phi2
type(tensor), intent(in) :: t
type(momentum), intent(in) :: kt, k2
type(momentum) :: k1
complex(kind=default) :: phi1
type(tensor) :: tmp
k1 = -kt - k2
tmp%t = t%t + transpose (t%t)
phi1 = g * ( (tmp * k2) * k1) * phi2
end function phi_t2phi
@
\begin{equation}
T_{\mu\nu} =- \frac{g}{2} k_1^\rho k_{2 \,\rho}
\phi_1 \left ( k_1 \right ) \phi_2 \left ( k_2 \right )
\end{equation}
<<Implementation of couplings>>=
pure function t2_phi2_cf (g, phi1, k1, phi2, k2) result (t)
complex(kind=default), intent(in) :: g, phi1, phi2
complex(kind=default) :: tmp_s
type(momentum), intent(in) :: k1, k2
type(tensor) :: t_metric, t
t_metric%t = 0
t_metric%t(0,0) = 1.0_default
t_metric%t(1,1) = - 1.0_default
t_metric%t(2,2) = - 1.0_default
t_metric%t(3,3) = - 1.0_default
tmp_s = (k1 * k2) * phi1 * phi2
t%t = - (g /2.0_default) * tmp_s * t_metric%t
end function t2_phi2_cf
@
\begin{equation}
\phi_1 (k_1) = - \frac{g}{2} T^{\nu}_{ \nu}
\left (k_1 \cdot k_2 \right ) \phi_2 (k_2)
\end{equation}
<<Implementation of couplings>>=
pure function phi_t2phi_cf (g, t, kt, phi2, k2) result (phi1)
complex(kind=default), intent(in) :: g, phi2
type(tensor), intent(in) :: t
type(momentum), intent(in) :: kt, k2
type(momentum) :: k1
complex(kind=default) :: tmp_ts, phi1
k1 = - kt - k2
tmp_ts = ( t%t(0,0)-t%t(1,1)-t%t(2,2)-t%t(3,3) )
phi1 = - ( g /2.0_default) * tmp_ts * (k1 * k2) * phi2
end function phi_t2phi_cf
@
<<Implementation of couplings>>=
pure function t2_vv_1 (g, v1, v2) result (t)
complex(kind=default), intent(in) :: g
complex(kind=default) :: tmp_s
type(vector), intent(in) :: v1, v2
type(tensor) :: tmp
type(tensor) :: t_metric, t
t_metric%t = 0
t_metric%t(0,0) = 1.0_default
t_metric%t(1,1) = - 1.0_default
t_metric%t(2,2) = - 1.0_default
t_metric%t(3,3) = - 1.0_default
tmp = v1.tprod.v2
tmp_s = v1 * v2
t%t = g * (tmp%t + transpose (tmp%t) - tmp_s * t_metric%t )
end function t2_vv_1
@
<<Implementation of couplings>>=
pure function v_t2v_1 (g, t, v) result (tv)
complex(kind=default), intent(in) :: g
type(tensor), intent(in) :: t
type(vector), intent(in) :: v
type(vector) :: tv, tmp_tv
type(tensor) :: tmp
tmp_tv = ( t%t(0,0)-t%t(1,1)-t%t(2,2)-t%t(3,3) ) * v
tmp%t = t%t + transpose (t%t)
tv = g * (tmp * v - tmp_tv)
end function v_t2v_1
@
<<Implementation of couplings>>=
pure function t2_vv_t (g, v1, k1, v2, k2) result (t)
complex(kind=default), intent(in) :: g
complex(kind=default) :: tmp_s
type(vector), intent(in) :: v1, v2
type(momentum), intent(in) :: k1, k2
type(tensor) :: tmp, tmp_v1k2, tmp_v2k1, tmp_k1k2, tmp2
type(tensor) :: t_metric, t
t_metric%t = 0
t_metric%t(0,0) = 1.0_default
t_metric%t(1,1) = - 1.0_default
t_metric%t(2,2) = - 1.0_default
t_metric%t(3,3) = - 1.0_default
tmp = v1.tprod.v2
tmp_s = v1 * v2
tmp_v1k2 = (v2 * k1) * (v1.tprod.k2)
tmp_v2k1 = (v1 * k2) * (v2.tprod.k1)
tmp_k1k2 = tmp_s * (k1.tprod.k2)
tmp2%t = tmp_v1k2%t + tmp_v2k1%t - tmp_k1k2%t
t%t = g * ( (k1*k2) * (tmp%t + transpose (tmp%t) - tmp_s * t_metric%t ) &
+ ((v1 * k2) * (v2 * k1)) * t_metric%t &
- tmp2%t - transpose(tmp2%t))
end function t2_vv_t
@
<<Implementation of couplings>>=
pure function v_t2v_t (g, t, kt, v, kv) result (tv)
complex(kind=default), intent(in) :: g
type(tensor), intent(in) :: t
type(vector), intent(in) :: v
type(momentum), intent(in) :: kt, kv
type(momentum) :: kout
type(vector) :: tv, tmp_tv
type(tensor) :: tmp
kout = - (kt + kv)
tmp_tv = ( t%t(0,0)-t%t(1,1)-t%t(2,2)-t%t(3,3) ) * v
tmp%t = t%t + transpose (t%t)
tv = g * ( (tmp * v - tmp_tv) * (kv * kout )&
+ ( t%t(0,0)-t%t(1,1)-t%t(2,2)-t%t(3,3) ) * (kout * v ) * kv &
- (kout * v) * ( tmp * kv) &
- (v* (t * kout) + kout * (t * v)) * kv &
+ (kout* (t * kv) + kv * (t * kout)) * v)
end function v_t2v_t
@
<<Declaration of couplings>>=
public :: t2_vv_d5_1, v_t2v_d5_1
@
<<Implementation of couplings>>=
pure function t2_vv_d5_1 (g, v1, k1, v2, k2) result (t)
complex(kind=default), intent(in) :: g
type(vector), intent(in) :: v1, v2
type(momentum), intent(in) :: k1, k2
type(tensor) :: t
t = (g * (v1 * v2)) * (k1-k2).tprod.(k1-k2)
end function t2_vv_d5_1
@
<<Implementation of couplings>>=
pure function v_t2v_d5_1 (g, t1, k1, v2, k2) result (tv)
complex(kind=default), intent(in) :: g
type(tensor), intent(in) :: t1
type(vector), intent(in) :: v2
type(momentum), intent(in) :: k1, k2
type(vector) :: tv
tv = (g * ((k1+2*k2).tprod.(k1+2*k2) * t1)) * v2
end function v_t2v_d5_1
@
<<Declaration of couplings>>=
public :: t2_vv_d5_2, v_t2v_d5_2
@
<<Implementation of couplings>>=
pure function t2_vv_d5_2 (g, v1, k1, v2, k2) result (t)
complex(kind=default), intent(in) :: g
type(vector), intent(in) :: v1, v2
type(momentum), intent(in) :: k1, k2
type(tensor) :: t
t = (g * (k2 * v1)) * (k2-k1).tprod.v2
t%t = t%t + transpose (t%t)
end function t2_vv_d5_2
@
<<Implementation of couplings>>=
pure function v_t2v_d5_2 (g, t1, k1, v2, k2) result (tv)
complex(kind=default), intent(in) :: g
type(tensor), intent(in) :: t1
type(vector), intent(in) :: v2
type(momentum), intent(in) :: k1, k2
type(vector) :: tv
type(tensor) :: tmp
type(momentum) :: k1_k2, k1_2k2
k1_k2 = k1 + k2
k1_2k2 = k1_k2 + k2
tmp%t = t1%t + transpose (t1%t)
tv = (g * (k1_k2 * v2)) * (k1_2k2 * tmp)
end function v_t2v_d5_2
@
<<Declaration of couplings>>=
public :: t2_vv_d7, v_t2v_d7
@
<<Implementation of couplings>>=
pure function t2_vv_d7 (g, v1, k1, v2, k2) result (t)
complex(kind=default), intent(in) :: g
type(vector), intent(in) :: v1, v2
type(momentum), intent(in) :: k1, k2
type(tensor) :: t
t = (g * (k2 * v1) * (k1 * v2)) * (k1-k2).tprod.(k1-k2)
end function t2_vv_d7
@
<<Implementation of couplings>>=
pure function v_t2v_d7 (g, t1, k1, v2, k2) result (tv)
complex(kind=default), intent(in) :: g
type(tensor), intent(in) :: t1
type(vector), intent(in) :: v2
type(momentum), intent(in) :: k1, k2
type(vector) :: tv
type(vector) :: k1_k2, k1_2k2
k1_k2 = k1 + k2
k1_2k2 = k1_k2 + k2
tv = (- g * (k1_k2 * v2) * (k1_2k2.tprod.k1_2k2 * t1)) * k2
end function v_t2v_d7
@ \section{Spinor Couplings}
<<[[omega_spinor_couplings.f90]]>>=
<<Copyleft>>
module omega_spinor_couplings
use kinds
use constants
use omega_spinors
use omega_vectors
use omega_tensors
use omega_couplings
implicit none
private
<<Declaration of spinor on shell wave functions>>
<<Declaration of spinor off shell wave functions>>
<<Declaration of spinor currents>>
<<Declaration of spinor propagators>>
integer, parameter, public :: omega_spinor_cpls_2010_01_A = 0
contains
<<Implementation of spinor on shell wave functions>>
<<Implementation of spinor off shell wave functions>>
<<Implementation of spinor currents>>
<<Implementation of spinor propagators>>
end module omega_spinor_couplings
@
See table~\ref{tab:fermionic-currents} for the names of Fortran
functions. We could have used long names instead, but this would
increase the chance of running past continuation line limits without
adding much to the legibility.
@
\subsection{Fermionic Vector and Axial Couplings}
There's more than one chiral representation. This one is compatible
with HELAS~\cite{HELAS}.
\begin{equation}
\gamma^0 = \begin{pmatrix} 0 & \mathbf{1} \\ \mathbf{1} & 0 \end{pmatrix},\;
\gamma^i = \begin{pmatrix} 0 & \sigma^i \\ -\sigma^i & 0 \end{pmatrix},\;
\gamma_5 = i\gamma^0\gamma^1\gamma^2\gamma^3
= \begin{pmatrix} -\mathbf{1} & 0 \\ 0 & \mathbf{1} \end{pmatrix}
\end{equation}
Therefore
\begin{subequations}
\begin{align}
g_S + g_P\gamma_5 &=
\begin{pmatrix}
g_S - g_P & 0 & 0 & 0 \\
0 & g_S - g_P & 0 & 0 \\
0 & 0 & g_S + g_P & 0 \\
0 & 0 & 0 & g_S + g_P
\end{pmatrix} \\
g_V\gamma^0 - g_A\gamma^0\gamma_5 &=
\begin{pmatrix}
0 & 0 & g_V - g_A & 0 \\
0 & 0 & 0 & g_V - g_A \\
g_V + g_A & 0 & 0 & 0 \\
0 & g_V + g_A & 0 & 0
\end{pmatrix} \\
g_V\gamma^1 - g_A\gamma^1\gamma_5 &=
\begin{pmatrix}
0 & 0 & 0 & g_V - g_A \\
0 & 0 & g_V - g_A & 0 \\
0 & - g_V - g_A & 0 & 0 \\
- g_V - g_A & 0 & 0 & 0
\end{pmatrix} \\
g_V\gamma^2 - g_A\gamma^2\gamma_5 &=
\begin{pmatrix}
0 & 0 & 0 & -\ii(g_V - g_A) \\
0 & 0 & \ii(g_V - g_A) & 0 \\
0 & \ii(g_V + g_A) & 0 & 0 \\
-\ii(g_V + g_A) & 0 & 0 & 0
\end{pmatrix} \\
g_V\gamma^3 - g_A\gamma^3\gamma_5 &=
\begin{pmatrix}
0 & 0 & g_V - g_A & 0 \\
0 & 0 & 0 & - g_V + g_A \\
- g_V - g_A & 0 & 0 & 0 \\
0 & g_V + g_A & 0 & 0
\end{pmatrix}
\end{align}
\end{subequations}
\begin{table}
\begin{center}
\begin{tabular}{>{$}l<{$}|>{$}l<{$}}
\bar\psi(g_V\gamma^\mu - g_A\gamma^\mu\gamma_5)\psi
& \text{\texttt{va\_ff}}(g_V,g_A,\bar\psi,\psi) \\
g_V\bar\psi\gamma^\mu\psi
& \text{\texttt{v\_ff}}(g_V,\bar\psi,\psi) \\
g_A\bar\psi\gamma_5\gamma^\mu\psi
& \text{\texttt{a\_ff}}(g_A,\bar\psi,\psi) \\
g_L\bar\psi\gamma^\mu(1-\gamma_5)\psi
& \text{\texttt{vl\_ff}}(g_L,\bar\psi,\psi) \\
g_R\bar\psi\gamma^\mu(1+\gamma_5)\psi
& \text{\texttt{vr\_ff}}(g_R,\bar\psi,\psi) \\\hline
\fmslash{V}(g_V - g_A\gamma_5)\psi
& \text{\texttt{f\_vaf}}(g_V,g_A,V,\psi) \\
g_V\fmslash{V}\psi
& \text{\texttt{f\_vf}}(g_V,V,\psi) \\
g_A\gamma_5\fmslash{V}\psi
& \text{\texttt{f\_af}}(g_A,V,\psi) \\
g_L\fmslash{V}(1-\gamma_5)\psi
& \text{\texttt{f\_vlf}}(g_L,V,\psi) \\
g_R\fmslash{V}(1+\gamma_5)\psi
& \text{\texttt{f\_vrf}}(g_R,V,\psi) \\\hline
\bar\psi\fmslash{V}(g_V - g_A\gamma_5)
& \text{\texttt{f\_fva}}(g_V,g_A,\bar\psi,V) \\
g_V\bar\psi\fmslash{V}
& \text{\texttt{f\_fv}}(g_V,\bar\psi,V) \\
g_A\bar\psi\gamma_5\fmslash{V}
& \text{\texttt{f\_fa}}(g_A,\bar\psi,V) \\
g_L\bar\psi\fmslash{V}(1-\gamma_5)
& \text{\texttt{f\_fvl}}(g_L,\bar\psi,V) \\
g_R\bar\psi\fmslash{V}(1+\gamma_5)
& \text{\texttt{f\_fvr}}(g_R,\bar\psi,V)
\end{tabular}
\end{center}
\caption{\label{tab:fermionic-currents}
Mnemonically abbreviated names of Fortran functions implementing
fermionic vector and axial currents.}
\end{table}
\begin{table}
\begin{center}
\begin{tabular}{>{$}l<{$}|>{$}l<{$}}
\bar\psi(g_S + g_P\gamma_5)\psi
& \text{\texttt{sp\_ff}}(g_S,g_P,\bar\psi,\psi) \\
g_S\bar\psi\psi
& \text{\texttt{s\_ff}}(g_S,\bar\psi,\psi) \\
g_P\bar\psi\gamma_5\psi
& \text{\texttt{p\_ff}}(g_P,\bar\psi,\psi) \\
g_L\bar\psi(1-\gamma_5)\psi
& \text{\texttt{sl\_ff}}(g_L,\bar\psi,\psi) \\
g_R\bar\psi(1+\gamma_5)\psi
& \text{\texttt{sr\_ff}}(g_R,\bar\psi,\psi) \\\hline
\phi(g_S + g_P\gamma_5)\psi
& \text{\texttt{f\_spf}}(g_S,g_P,\phi,\psi) \\
g_S\phi\psi
& \text{\texttt{f\_sf}}(g_S,\phi,\psi) \\
g_P\phi\gamma_5\psi
& \text{\texttt{f\_pf}}(g_P,\phi,\psi) \\
g_L\phi(1-\gamma_5)\psi
& \text{\texttt{f\_slf}}(g_L,\phi,\psi) \\
g_R\phi(1+\gamma_5)\psi
& \text{\texttt{f\_srf}}(g_R,\phi,\psi) \\\hline
\bar\psi\phi(g_S + g_P\gamma_5)
& \text{\texttt{f\_fsp}}(g_S,g_P,\bar\psi,\phi) \\
g_S\bar\psi\phi
& \text{\texttt{f\_fs}}(g_S,\bar\psi,\phi) \\
g_P\bar\psi\phi\gamma_5
& \text{\texttt{f\_fp}}(g_P,\bar\psi,\phi) \\
g_L\bar\psi\phi(1-\gamma_5)
& \text{\texttt{f\_fsl}}(g_L,\bar\psi,\phi) \\
g_R\bar\psi\phi(1+\gamma_5)
& \text{\texttt{f\_fsr}}(g_R,\bar\psi,\phi)
\end{tabular}
\end{center}
\caption{\label{tab:fermionic-scalar currents}
Mnemonically abbreviated names of Fortran functions implementing
fermionic scalar and pseudo scalar ``currents''.}
\end{table}
<<Declaration of spinor currents>>=
public :: va_ff, v_ff, a_ff, vl_ff, vr_ff, vlr_ff, grav_ff, va2_ff, &
tva_ff, tlr_ff, trl_ff, tvam_ff, tlrm_ff, trlm_ff, va3_ff
@
<<Implementation of spinor currents>>=
pure function va_ff (gv, ga, psibar, psi) result (j)
type(vector) :: j
complex(kind=default), intent(in) :: gv, ga
type(conjspinor), intent(in) :: psibar
type(spinor), intent(in) :: psi
complex(kind=default) :: gl, gr
complex(kind=default) :: g13, g14, g23, g24, g31, g32, g41, g42
gl = gv + ga
gr = gv - ga
g13 = psibar%a(1)*psi%a(3)
g14 = psibar%a(1)*psi%a(4)
g23 = psibar%a(2)*psi%a(3)
g24 = psibar%a(2)*psi%a(4)
g31 = psibar%a(3)*psi%a(1)
g32 = psibar%a(3)*psi%a(2)
g41 = psibar%a(4)*psi%a(1)
g42 = psibar%a(4)*psi%a(2)
j%t = gr * ( g13 + g24) + gl * ( g31 + g42)
j%x(1) = gr * ( g14 + g23) - gl * ( g32 + g41)
j%x(2) = (gr * ( - g14 + g23) + gl * ( g32 - g41)) * (0, 1)
j%x(3) = gr * ( g13 - g24) + gl * ( - g31 + g42)
end function va_ff
@
<<Implementation of spinor currents>>=
pure function va2_ff (gva, psibar, psi) result (j)
type(vector) :: j
complex(kind=default), intent(in), dimension(2) :: gva
type(conjspinor), intent(in) :: psibar
type(spinor), intent(in) :: psi
complex(kind=default) :: gl, gr
complex(kind=default) :: g13, g14, g23, g24, g31, g32, g41, g42
gl = gva(1) + gva(2)
gr = gva(1) - gva(2)
g13 = psibar%a(1)*psi%a(3)
g14 = psibar%a(1)*psi%a(4)
g23 = psibar%a(2)*psi%a(3)
g24 = psibar%a(2)*psi%a(4)
g31 = psibar%a(3)*psi%a(1)
g32 = psibar%a(3)*psi%a(2)
g41 = psibar%a(4)*psi%a(1)
g42 = psibar%a(4)*psi%a(2)
j%t = gr * ( g13 + g24) + gl * ( g31 + g42)
j%x(1) = gr * ( g14 + g23) - gl * ( g32 + g41)
j%x(2) = (gr * ( - g14 + g23) + gl * ( g32 - g41)) * (0, 1)
j%x(3) = gr * ( g13 - g24) + gl * ( - g31 + g42)
end function va2_ff
@
<<Implementation of spinor currents>>=
pure function va3_ff (gv, ga, psibar, psi) result (j)
type(vector) :: j
complex(kind=default), intent(in) :: gv, ga
type(conjspinor), intent(in) :: psibar
type(spinor), intent(in) :: psi
j = va_ff (gv, ga, psibar, psi)
j%t = 0.0_default
end function va3_ff
@
<<Implementation of spinor currents>>=
pure function tva_ff (gv, ga, psibar, psi) result (t)
type(tensor2odd) :: t
complex(kind=default), intent(in) :: gv, ga
type(conjspinor), intent(in) :: psibar
type(spinor), intent(in) :: psi
complex(kind=default) :: gl, gr
complex(kind=default) :: g12, g21, g1m2, g34, g43, g3m4
gr = gv + ga
gl = gv - ga
g12 = psibar%a(1)*psi%a(2)
g21 = psibar%a(2)*psi%a(1)
g1m2 = psibar%a(1)*psi%a(1) - psibar%a(2)*psi%a(2)
g34 = psibar%a(3)*psi%a(4)
g43 = psibar%a(4)*psi%a(3)
g3m4 = psibar%a(3)*psi%a(3) - psibar%a(4)*psi%a(4)
t%e(1) = (gl * ( - g12 - g21) + gr * ( g34 + g43)) * (0, 1)
t%e(2) = gl * ( - g12 + g21) + gr * ( g34 - g43)
t%e(3) = (gl * ( - g1m2 ) + gr * ( g3m4 )) * (0, 1)
t%b(1) = gl * ( g12 + g21) + gr * ( g34 + g43)
t%b(2) = (gl * ( - g12 + g21) + gr * ( - g34 + g43)) * (0, 1)
t%b(3) = gl * ( g1m2 ) + gr * ( g3m4 )
end function tva_ff
@
<<Implementation of spinor currents>>=
pure function tlr_ff (gl, gr, psibar, psi) result (t)
type(tensor2odd) :: t
complex(kind=default), intent(in) :: gl, gr
type(conjspinor), intent(in) :: psibar
type(spinor), intent(in) :: psi
t = tva_ff (gr+gl, gr-gl, psibar, psi)
end function tlr_ff
@
<<Implementation of spinor currents>>=
pure function trl_ff (gr, gl, psibar, psi) result (t)
type(tensor2odd) :: t
complex(kind=default), intent(in) :: gl, gr
type(conjspinor), intent(in) :: psibar
type(spinor), intent(in) :: psi
t = tva_ff (gr+gl, gr-gl, psibar, psi)
end function trl_ff
@
<<Implementation of spinor currents>>=
pure function tvam_ff (gv, ga, psibar, psi, p) result (j)
type(vector) :: j
complex(kind=default), intent(in) :: gv, ga
type(conjspinor), intent(in) :: psibar
type(spinor), intent(in) :: psi
type(momentum), intent(in) :: p
j = (tva_ff(gv, ga, psibar, psi) * p) * (0,1)
end function tvam_ff
@
<<Implementation of spinor currents>>=
pure function tlrm_ff (gl, gr, psibar, psi, p) result (j)
type(vector) :: j
complex(kind=default), intent(in) :: gl, gr
type(conjspinor), intent(in) :: psibar
type(spinor), intent(in) :: psi
type(momentum), intent(in) :: p
j = tvam_ff (gr+gl, gr-gl, psibar, psi, p)
end function tlrm_ff
@
<<Implementation of spinor currents>>=
pure function trlm_ff (gr, gl, psibar, psi, p) result (j)
type(vector) :: j
complex(kind=default), intent(in) :: gl, gr
type(conjspinor), intent(in) :: psibar
type(spinor), intent(in) :: psi
type(momentum), intent(in) :: p
j = tvam_ff (gr+gl, gr-gl, psibar, psi, p)
end function trlm_ff
@ Special cases that avoid some multiplications
<<Implementation of spinor currents>>=
pure function v_ff (gv, psibar, psi) result (j)
type(vector) :: j
complex(kind=default), intent(in) :: gv
type(conjspinor), intent(in) :: psibar
type(spinor), intent(in) :: psi
complex(kind=default) :: g13, g14, g23, g24, g31, g32, g41, g42
g13 = psibar%a(1)*psi%a(3)
g14 = psibar%a(1)*psi%a(4)
g23 = psibar%a(2)*psi%a(3)
g24 = psibar%a(2)*psi%a(4)
g31 = psibar%a(3)*psi%a(1)
g32 = psibar%a(3)*psi%a(2)
g41 = psibar%a(4)*psi%a(1)
g42 = psibar%a(4)*psi%a(2)
j%t = gv * ( g13 + g24 + g31 + g42)
j%x(1) = gv * ( g14 + g23 - g32 - g41)
j%x(2) = gv * ( - g14 + g23 + g32 - g41) * (0, 1)
j%x(3) = gv * ( g13 - g24 - g31 + g42)
end function v_ff
@
<<Implementation of spinor currents>>=
pure function a_ff (ga, psibar, psi) result (j)
type(vector) :: j
complex(kind=default), intent(in) :: ga
type(conjspinor), intent(in) :: psibar
type(spinor), intent(in) :: psi
complex(kind=default) :: g13, g14, g23, g24, g31, g32, g41, g42
g13 = psibar%a(1)*psi%a(3)
g14 = psibar%a(1)*psi%a(4)
g23 = psibar%a(2)*psi%a(3)
g24 = psibar%a(2)*psi%a(4)
g31 = psibar%a(3)*psi%a(1)
g32 = psibar%a(3)*psi%a(2)
g41 = psibar%a(4)*psi%a(1)
g42 = psibar%a(4)*psi%a(2)
j%t = ga * ( - g13 - g24 + g31 + g42)
j%x(1) = - ga * ( g14 + g23 + g32 + g41)
j%x(2) = ga * ( g14 - g23 + g32 - g41) * (0, 1)
j%x(3) = ga * ( - g13 + g24 - g31 + g42)
end function a_ff
@
<<Implementation of spinor currents>>=
pure function vl_ff (gl, psibar, psi) result (j)
type(vector) :: j
complex(kind=default), intent(in) :: gl
type(conjspinor), intent(in) :: psibar
type(spinor), intent(in) :: psi
complex(kind=default) :: gl2
complex(kind=default) :: g31, g32, g41, g42
gl2 = 2 * gl
g31 = psibar%a(3)*psi%a(1)
g32 = psibar%a(3)*psi%a(2)
g41 = psibar%a(4)*psi%a(1)
g42 = psibar%a(4)*psi%a(2)
j%t = gl2 * ( g31 + g42)
j%x(1) = - gl2 * ( g32 + g41)
j%x(2) = gl2 * ( g32 - g41) * (0, 1)
j%x(3) = gl2 * ( - g31 + g42)
end function vl_ff
@
<<Implementation of spinor currents>>=
pure function vr_ff (gr, psibar, psi) result (j)
type(vector) :: j
complex(kind=default), intent(in) :: gr
type(conjspinor), intent(in) :: psibar
type(spinor), intent(in) :: psi
complex(kind=default) :: gr2
complex(kind=default) :: g13, g14, g23, g24
gr2 = 2 * gr
g13 = psibar%a(1)*psi%a(3)
g14 = psibar%a(1)*psi%a(4)
g23 = psibar%a(2)*psi%a(3)
g24 = psibar%a(2)*psi%a(4)
j%t = gr2 * ( g13 + g24)
j%x(1) = gr2 * ( g14 + g23)
j%x(2) = gr2 * ( - g14 + g23) * (0, 1)
j%x(3) = gr2 * ( g13 - g24)
end function vr_ff
@
<<Implementation of spinor currents>>=
pure function grav_ff (g, m, kb, k, psibar, psi) result (j)
type(tensor) :: j
complex(kind=default), intent(in) :: g
real(kind=default), intent(in) :: m
type(conjspinor), intent(in) :: psibar
type(spinor), intent(in) :: psi
type(momentum), intent(in) :: kb, k
complex(kind=default) :: g2, g8, c_dum
type(vector) :: v_dum
type(tensor) :: t_metric
t_metric%t = 0
t_metric%t(0,0) = 1.0_default
t_metric%t(1,1) = - 1.0_default
t_metric%t(2,2) = - 1.0_default
t_metric%t(3,3) = - 1.0_default
g2 = g/2.0_default
g8 = g/8.0_default
v_dum = v_ff(g8, psibar, psi)
c_dum = (- m) * s_ff (g2, psibar, psi) - (kb+k)*v_dum
j = c_dum*t_metric - (((kb+k).tprod.v_dum) + &
(v_dum.tprod.(kb+k)))
end function grav_ff
@
\begin{equation}
g_L\gamma_\mu(1-\gamma_5) + g_R\gamma_\mu(1+\gamma_5)
= (g_L+g_R)\gamma_\mu - (g_L-g_R)\gamma_\mu\gamma_5
= g_V\gamma_\mu - g_A\gamma_\mu\gamma_5
\end{equation}
\ldots{} give the compiler the benefit of the doubt that it will
optimize the function all. If not, we could inline it \ldots
<<Implementation of spinor currents>>=
pure function vlr_ff (gl, gr, psibar, psi) result (j)
type(vector) :: j
complex(kind=default), intent(in) :: gl, gr
type(conjspinor), intent(in) :: psibar
type(spinor), intent(in) :: psi
j = va_ff (gl+gr, gl-gr, psibar, psi)
end function vlr_ff
@
and
\begin{equation}
\fmslash{v} - \fmslash{a}\gamma_5 =
\begin{pmatrix}
0 & 0 & v_- - a_- & - v^* + a^* \\
0 & 0 & - v + a & v_+ - a_+ \\
v_+ + a_+ & v^* + a^* & 0 & 0 \\
v + a & v_- + a_- & 0 & 0
\end{pmatrix}
\end{equation}
with $v_\pm=v_0\pm v_3$, $a_\pm=a_0\pm a_3$, $v=v_1+\ii v_2$,
$v^*=v_1-\ii v_2$, $a=a_1+\ii a_2$, and $a^*=a_1-\ii a_2$. But note
that~$\cdot^*$ is \emph{not} complex conjugation for complex~$v_\mu$
or~$a_\mu$.
<<Declaration of spinor currents>>=
public :: f_vaf, f_vf, f_af, f_vlf, f_vrf, f_vlrf, f_va2f, &
f_tvaf, f_tlrf, f_trlf, f_tvamf, f_tlrmf, f_trlmf, f_va3f
@
<<Implementation of spinor currents>>=
pure function f_vaf (gv, ga, v, psi) result (vpsi)
type(spinor) :: vpsi
complex(kind=default), intent(in) :: gv, ga
type(vector), intent(in) :: v
type(spinor), intent(in) :: psi
complex(kind=default) :: gl, gr
complex(kind=default) :: vp, vm, v12, v12s
gl = gv + ga
gr = gv - ga
vp = v%t + v%x(3)
vm = v%t - v%x(3)
v12 = v%x(1) + (0,1)*v%x(2)
v12s = v%x(1) - (0,1)*v%x(2)
vpsi%a(1) = gr * ( vm * psi%a(3) - v12s * psi%a(4))
vpsi%a(2) = gr * ( - v12 * psi%a(3) + vp * psi%a(4))
vpsi%a(3) = gl * ( vp * psi%a(1) + v12s * psi%a(2))
vpsi%a(4) = gl * ( v12 * psi%a(1) + vm * psi%a(2))
end function f_vaf
@
<<Implementation of spinor currents>>=
pure function f_va2f (gva, v, psi) result (vpsi)
type(spinor) :: vpsi
complex(kind=default), intent(in), dimension(2) :: gva
type(vector), intent(in) :: v
type(spinor), intent(in) :: psi
complex(kind=default) :: gl, gr
complex(kind=default) :: vp, vm, v12, v12s
gl = gva(1) + gva(2)
gr = gva(1) - gva(2)
vp = v%t + v%x(3)
vm = v%t - v%x(3)
v12 = v%x(1) + (0,1)*v%x(2)
v12s = v%x(1) - (0,1)*v%x(2)
vpsi%a(1) = gr * ( vm * psi%a(3) - v12s * psi%a(4))
vpsi%a(2) = gr * ( - v12 * psi%a(3) + vp * psi%a(4))
vpsi%a(3) = gl * ( vp * psi%a(1) + v12s * psi%a(2))
vpsi%a(4) = gl * ( v12 * psi%a(1) + vm * psi%a(2))
end function f_va2f
@
<<Implementation of spinor currents>>=
pure function f_va3f (gv, ga, v, psi) result (vpsi)
type(spinor) :: vpsi
complex(kind=default), intent(in) :: gv, ga
type(vector), intent(in) :: v
type(spinor), intent(in) :: psi
complex(kind=default) :: gl, gr
complex(kind=default) :: vp, vm, v12, v12s
gl = gv + ga
gr = gv - ga
vp = v%x(3) !+ v%t
vm = - v%x(3) !+ v%t
v12 = v%x(1) + (0,1)*v%x(2)
v12s = v%x(1) - (0,1)*v%x(2)
vpsi%a(1) = gr * ( vm * psi%a(3) - v12s * psi%a(4))
vpsi%a(2) = gr * ( - v12 * psi%a(3) + vp * psi%a(4))
vpsi%a(3) = gl * ( vp * psi%a(1) + v12s * psi%a(2))
vpsi%a(4) = gl * ( v12 * psi%a(1) + vm * psi%a(2))
end function f_va3f
@
<<Implementation of spinor currents>>=
pure function f_tvaf (gv, ga, t, psi) result (tpsi)
type(spinor) :: tpsi
complex(kind=default), intent(in) :: gv, ga
type(tensor2odd), intent(in) :: t
type(spinor), intent(in) :: psi
complex(kind=default) :: gl, gr
complex(kind=default) :: e21, e21s, b12, b12s, be3, be3s
gr = gv + ga
gl = gv - ga
e21 = t%e(2) + t%e(1)*(0,1)
e21s = t%e(2) - t%e(1)*(0,1)
b12 = t%b(1) + t%b(2)*(0,1)
b12s = t%b(1) - t%b(2)*(0,1)
be3 = t%b(3) + t%e(3)*(0,1)
be3s = t%b(3) - t%e(3)*(0,1)
tpsi%a(1) = 2*gl * ( psi%a(1) * be3 + psi%a(2) * ( e21 +b12s))
tpsi%a(2) = 2*gl * ( - psi%a(2) * be3 + psi%a(1) * (-e21s+b12 ))
tpsi%a(3) = 2*gr * ( psi%a(3) * be3s + psi%a(4) * (-e21 +b12s))
tpsi%a(4) = 2*gr * ( - psi%a(4) * be3s + psi%a(3) * ( e21s+b12 ))
end function f_tvaf
@
<<Implementation of spinor currents>>=
pure function f_tlrf (gl, gr, t, psi) result (tpsi)
type(spinor) :: tpsi
complex(kind=default), intent(in) :: gl, gr
type(tensor2odd), intent(in) :: t
type(spinor), intent(in) :: psi
tpsi = f_tvaf (gr+gl, gr-gl, t, psi)
end function f_tlrf
@
<<Implementation of spinor currents>>=
pure function f_trlf (gr, gl, t, psi) result (tpsi)
type(spinor) :: tpsi
complex(kind=default), intent(in) :: gl, gr
type(tensor2odd), intent(in) :: t
type(spinor), intent(in) :: psi
tpsi = f_tvaf (gr+gl, gr-gl, t, psi)
end function f_trlf
@
<<Implementation of spinor currents>>=
pure function f_tvamf (gv, ga, v, psi, k) result (vpsi)
type(spinor) :: vpsi
complex(kind=default), intent(in) :: gv, ga
type(vector), intent(in) :: v
type(spinor), intent(in) :: psi
type(momentum), intent(in) :: k
type(tensor2odd) :: t
t = (v.wedge.k) * (0, 0.5)
vpsi = f_tvaf(gv, ga, t, psi)
end function f_tvamf
@
<<Implementation of spinor currents>>=
pure function f_tlrmf (gl, gr, v, psi, k) result (vpsi)
type(spinor) :: vpsi
complex(kind=default), intent(in) :: gl, gr
type(vector), intent(in) :: v
type(spinor), intent(in) :: psi
type(momentum), intent(in) :: k
vpsi = f_tvamf (gr+gl, gr-gl, v, psi, k)
end function f_tlrmf
@
<<Implementation of spinor currents>>=
pure function f_trlmf (gr, gl, v, psi, k) result (vpsi)
type(spinor) :: vpsi
complex(kind=default), intent(in) :: gl, gr
type(vector), intent(in) :: v
type(spinor), intent(in) :: psi
type(momentum), intent(in) :: k
vpsi = f_tvamf (gr+gl, gr-gl, v, psi, k)
end function f_trlmf
@
<<Implementation of spinor currents>>=
pure function f_vf (gv, v, psi) result (vpsi)
type(spinor) :: vpsi
complex(kind=default), intent(in) :: gv
type(vector), intent(in) :: v
type(spinor), intent(in) :: psi
complex(kind=default) :: vp, vm, v12, v12s
vp = v%t + v%x(3)
vm = v%t - v%x(3)
v12 = v%x(1) + (0,1)*v%x(2)
v12s = v%x(1) - (0,1)*v%x(2)
vpsi%a(1) = gv * ( vm * psi%a(3) - v12s * psi%a(4))
vpsi%a(2) = gv * ( - v12 * psi%a(3) + vp * psi%a(4))
vpsi%a(3) = gv * ( vp * psi%a(1) + v12s * psi%a(2))
vpsi%a(4) = gv * ( v12 * psi%a(1) + vm * psi%a(2))
end function f_vf
@
<<Implementation of spinor currents>>=
pure function f_af (ga, v, psi) result (vpsi)
type(spinor) :: vpsi
complex(kind=default), intent(in) :: ga
type(vector), intent(in) :: v
type(spinor), intent(in) :: psi
complex(kind=default) :: vp, vm, v12, v12s
vp = v%t + v%x(3)
vm = v%t - v%x(3)
v12 = v%x(1) + (0,1)*v%x(2)
v12s = v%x(1) - (0,1)*v%x(2)
vpsi%a(1) = ga * ( - vm * psi%a(3) + v12s * psi%a(4))
vpsi%a(2) = ga * ( v12 * psi%a(3) - vp * psi%a(4))
vpsi%a(3) = ga * ( vp * psi%a(1) + v12s * psi%a(2))
vpsi%a(4) = ga * ( v12 * psi%a(1) + vm * psi%a(2))
end function f_af
@
<<Implementation of spinor currents>>=
pure function f_vlf (gl, v, psi) result (vpsi)
type(spinor) :: vpsi
complex(kind=default), intent(in) :: gl
type(vector), intent(in) :: v
type(spinor), intent(in) :: psi
complex(kind=default) :: gl2
complex(kind=default) :: vp, vm, v12, v12s
gl2 = 2 * gl
vp = v%t + v%x(3)
vm = v%t - v%x(3)
v12 = v%x(1) + (0,1)*v%x(2)
v12s = v%x(1) - (0,1)*v%x(2)
vpsi%a(1) = 0
vpsi%a(2) = 0
vpsi%a(3) = gl2 * ( vp * psi%a(1) + v12s * psi%a(2))
vpsi%a(4) = gl2 * ( v12 * psi%a(1) + vm * psi%a(2))
end function f_vlf
@
<<Implementation of spinor currents>>=
pure function f_vrf (gr, v, psi) result (vpsi)
type(spinor) :: vpsi
complex(kind=default), intent(in) :: gr
type(vector), intent(in) :: v
type(spinor), intent(in) :: psi
complex(kind=default) :: gr2
complex(kind=default) :: vp, vm, v12, v12s
gr2 = 2 * gr
vp = v%t + v%x(3)
vm = v%t - v%x(3)
v12 = v%x(1) + (0,1)*v%x(2)
v12s = v%x(1) - (0,1)*v%x(2)
vpsi%a(1) = gr2 * ( vm * psi%a(3) - v12s * psi%a(4))
vpsi%a(2) = gr2 * ( - v12 * psi%a(3) + vp * psi%a(4))
vpsi%a(3) = 0
vpsi%a(4) = 0
end function f_vrf
@
<<Implementation of spinor currents>>=
pure function f_vlrf (gl, gr, v, psi) result (vpsi)
type(spinor) :: vpsi
complex(kind=default), intent(in) :: gl, gr
type(vector), intent(in) :: v
type(spinor), intent(in) :: psi
vpsi = f_vaf (gl+gr, gl-gr, v, psi)
end function f_vlrf
@
<<Declaration of spinor currents>>=
public :: f_fva, f_fv, f_fa, f_fvl, f_fvr, f_fvlr, f_fva2, &
f_ftva, f_ftlr, f_ftrl, f_ftvam, f_ftlrm, f_ftrlm, f_fva3
@
<<Implementation of spinor currents>>=
pure function f_fva (gv, ga, psibar, v) result (psibarv)
type(conjspinor) :: psibarv
complex(kind=default), intent(in) :: gv, ga
type(conjspinor), intent(in) :: psibar
type(vector), intent(in) :: v
complex(kind=default) :: gl, gr
complex(kind=default) :: vp, vm, v12, v12s
gl = gv + ga
gr = gv - ga
vp = v%t + v%x(3)
vm = v%t - v%x(3)
v12 = v%x(1) + (0,1)*v%x(2)
v12s = v%x(1) - (0,1)*v%x(2)
psibarv%a(1) = gl * ( psibar%a(3) * vp + psibar%a(4) * v12)
psibarv%a(2) = gl * ( psibar%a(3) * v12s + psibar%a(4) * vm )
psibarv%a(3) = gr * ( psibar%a(1) * vm - psibar%a(2) * v12)
psibarv%a(4) = gr * ( - psibar%a(1) * v12s + psibar%a(2) * vp )
end function f_fva
@
<<Implementation of spinor currents>>=
pure function f_fva2 (gva, psibar, v) result (psibarv)
type(conjspinor) :: psibarv
complex(kind=default), intent(in), dimension(2) :: gva
type(conjspinor), intent(in) :: psibar
type(vector), intent(in) :: v
complex(kind=default) :: gl, gr
complex(kind=default) :: vp, vm, v12, v12s
gl = gva(1) + gva(2)
gr = gva(1) - gva(2)
vp = v%t + v%x(3)
vm = v%t - v%x(3)
v12 = v%x(1) + (0,1)*v%x(2)
v12s = v%x(1) - (0,1)*v%x(2)
psibarv%a(1) = gl * ( psibar%a(3) * vp + psibar%a(4) * v12)
psibarv%a(2) = gl * ( psibar%a(3) * v12s + psibar%a(4) * vm )
psibarv%a(3) = gr * ( psibar%a(1) * vm - psibar%a(2) * v12)
psibarv%a(4) = gr * ( - psibar%a(1) * v12s + psibar%a(2) * vp )
end function f_fva2
@
<<Implementation of spinor currents>>=
pure function f_fva3 (gv, ga, psibar, v) result (psibarv)
type(conjspinor) :: psibarv
complex(kind=default), intent(in) :: gv, ga
type(conjspinor), intent(in) :: psibar
type(vector), intent(in) :: v
complex(kind=default) :: gl, gr
complex(kind=default) :: vp, vm, v12, v12s
gl = gv + ga
gr = gv - ga
vp = v%x(3) !+ v%t
vm = - v%x(3) !+ v%t
v12 = v%x(1) + (0,1)*v%x(2)
v12s = v%x(1) - (0,1)*v%x(2)
psibarv%a(1) = gl * ( psibar%a(3) * vp + psibar%a(4) * v12)
psibarv%a(2) = gl * ( psibar%a(3) * v12s + psibar%a(4) * vm )
psibarv%a(3) = gr * ( psibar%a(1) * vm - psibar%a(2) * v12)
psibarv%a(4) = gr * ( - psibar%a(1) * v12s + psibar%a(2) * vp )
end function f_fva3
@
<<Implementation of spinor currents>>=
pure function f_ftva (gv, ga, psibar, t) result (psibart)
type(conjspinor) :: psibart
complex(kind=default), intent(in) :: gv, ga
type(conjspinor), intent(in) :: psibar
type(tensor2odd), intent(in) :: t
complex(kind=default) :: gl, gr
complex(kind=default) :: e21, e21s, b12, b12s, be3, be3s
gr = gv + ga
gl = gv - ga
e21 = t%e(2) + t%e(1)*(0,1)
e21s = t%e(2) - t%e(1)*(0,1)
b12 = t%b(1) + t%b(2)*(0,1)
b12s = t%b(1) - t%b(2)*(0,1)
be3 = t%b(3) + t%e(3)*(0,1)
be3s = t%b(3) - t%e(3)*(0,1)
psibart%a(1) = 2*gl * ( psibar%a(1) * be3 + psibar%a(2) * (-e21s+b12 ))
psibart%a(2) = 2*gl * ( - psibar%a(2) * be3 + psibar%a(1) * ( e21 +b12s))
psibart%a(3) = 2*gr * ( psibar%a(3) * be3s + psibar%a(4) * ( e21s+b12 ))
psibart%a(4) = 2*gr * ( - psibar%a(4) * be3s + psibar%a(3) * (-e21 +b12s))
end function f_ftva
@
<<Implementation of spinor currents>>=
pure function f_ftlr (gl, gr, psibar, t) result (psibart)
type(conjspinor) :: psibart
complex(kind=default), intent(in) :: gl, gr
type(conjspinor), intent(in) :: psibar
type(tensor2odd), intent(in) :: t
psibart = f_ftva (gr+gl, gr-gl, psibar, t)
end function f_ftlr
@
<<Implementation of spinor currents>>=
pure function f_ftrl (gr, gl, psibar, t) result (psibart)
type(conjspinor) :: psibart
complex(kind=default), intent(in) :: gl, gr
type(conjspinor), intent(in) :: psibar
type(tensor2odd), intent(in) :: t
psibart = f_ftva (gr+gl, gr-gl, psibar, t)
end function f_ftrl
@
<<Implementation of spinor currents>>=
pure function f_ftvam (gv, ga, psibar, v, k) result (psibarv)
type(conjspinor) :: psibarv
complex(kind=default), intent(in) :: gv, ga
type(conjspinor), intent(in) :: psibar
type(vector), intent(in) :: v
type(momentum), intent(in) :: k
type(tensor2odd) :: t
t = (v.wedge.k) * (0, 0.5)
psibarv = f_ftva(gv, ga, psibar, t)
end function f_ftvam
@
<<Implementation of spinor currents>>=
pure function f_ftlrm (gl, gr, psibar, v, k) result (psibarv)
type(conjspinor) :: psibarv
complex(kind=default), intent(in) :: gl, gr
type(conjspinor), intent(in) :: psibar
type(vector), intent(in) :: v
type(momentum), intent(in) :: k
psibarv = f_ftvam (gr+gl, gr-gl, psibar, v, k)
end function f_ftlrm
@
<<Implementation of spinor currents>>=
pure function f_ftrlm (gr, gl, psibar, v, k) result (psibarv)
type(conjspinor) :: psibarv
complex(kind=default), intent(in) :: gl, gr
type(conjspinor), intent(in) :: psibar
type(vector), intent(in) :: v
type(momentum), intent(in) :: k
psibarv = f_ftvam (gr+gl, gr-gl, psibar, v, k)
end function f_ftrlm
@
<<Implementation of spinor currents>>=
pure function f_fv (gv, psibar, v) result (psibarv)
type(conjspinor) :: psibarv
complex(kind=default), intent(in) :: gv
type(conjspinor), intent(in) :: psibar
type(vector), intent(in) :: v
complex(kind=default) :: vp, vm, v12, v12s
vp = v%t + v%x(3)
vm = v%t - v%x(3)
v12 = v%x(1) + (0,1)*v%x(2)
v12s = v%x(1) - (0,1)*v%x(2)
psibarv%a(1) = gv * ( psibar%a(3) * vp + psibar%a(4) * v12)
psibarv%a(2) = gv * ( psibar%a(3) * v12s + psibar%a(4) * vm )
psibarv%a(3) = gv * ( psibar%a(1) * vm - psibar%a(2) * v12)
psibarv%a(4) = gv * ( - psibar%a(1) * v12s + psibar%a(2) * vp )
end function f_fv
@
<<Implementation of spinor currents>>=
pure function f_fa (ga, psibar, v) result (psibarv)
type(conjspinor) :: psibarv
complex(kind=default), intent(in) :: ga
type(vector), intent(in) :: v
type(conjspinor), intent(in) :: psibar
complex(kind=default) :: vp, vm, v12, v12s
vp = v%t + v%x(3)
vm = v%t - v%x(3)
v12 = v%x(1) + (0,1)*v%x(2)
v12s = v%x(1) - (0,1)*v%x(2)
psibarv%a(1) = ga * ( psibar%a(3) * vp + psibar%a(4) * v12)
psibarv%a(2) = ga * ( psibar%a(3) * v12s + psibar%a(4) * vm )
psibarv%a(3) = ga * ( - psibar%a(1) * vm + psibar%a(2) * v12)
psibarv%a(4) = ga * ( psibar%a(1) * v12s - psibar%a(2) * vp )
end function f_fa
@
<<Implementation of spinor currents>>=
pure function f_fvl (gl, psibar, v) result (psibarv)
type(conjspinor) :: psibarv
complex(kind=default), intent(in) :: gl
type(conjspinor), intent(in) :: psibar
type(vector), intent(in) :: v
complex(kind=default) :: gl2
complex(kind=default) :: vp, vm, v12, v12s
gl2 = 2 * gl
vp = v%t + v%x(3)
vm = v%t - v%x(3)
v12 = v%x(1) + (0,1)*v%x(2)
v12s = v%x(1) - (0,1)*v%x(2)
psibarv%a(1) = gl2 * ( psibar%a(3) * vp + psibar%a(4) * v12)
psibarv%a(2) = gl2 * ( psibar%a(3) * v12s + psibar%a(4) * vm )
psibarv%a(3) = 0
psibarv%a(4) = 0
end function f_fvl
@
<<Implementation of spinor currents>>=
pure function f_fvr (gr, psibar, v) result (psibarv)
type(conjspinor) :: psibarv
complex(kind=default), intent(in) :: gr
type(conjspinor), intent(in) :: psibar
type(vector), intent(in) :: v
complex(kind=default) :: gr2
complex(kind=default) :: vp, vm, v12, v12s
gr2 = 2 * gr
vp = v%t + v%x(3)
vm = v%t - v%x(3)
v12 = v%x(1) + (0,1)*v%x(2)
v12s = v%x(1) - (0,1)*v%x(2)
psibarv%a(1) = 0
psibarv%a(2) = 0
psibarv%a(3) = gr2 * ( psibar%a(1) * vm - psibar%a(2) * v12)
psibarv%a(4) = gr2 * ( - psibar%a(1) * v12s + psibar%a(2) * vp )
end function f_fvr
@
<<Implementation of spinor currents>>=
pure function f_fvlr (gl, gr, psibar, v) result (psibarv)
type(conjspinor) :: psibarv
complex(kind=default), intent(in) :: gl, gr
type(conjspinor), intent(in) :: psibar
type(vector), intent(in) :: v
psibarv = f_fva (gl+gr, gl-gr, psibar, v)
end function f_fvlr
@ \subsection{Fermionic Scalar and Pseudo Scalar Couplings}
<<Declaration of spinor currents>>=
public :: sp_ff, s_ff, p_ff, sl_ff, sr_ff, slr_ff
@
<<Implementation of spinor currents>>=
pure function sp_ff (gs, gp, psibar, psi) result (j)
complex(kind=default) :: j
complex(kind=default), intent(in) :: gs, gp
type(conjspinor), intent(in) :: psibar
type(spinor), intent(in) :: psi
j = (gs - gp) * (psibar%a(1)*psi%a(1) + psibar%a(2)*psi%a(2)) &
+ (gs + gp) * (psibar%a(3)*psi%a(3) + psibar%a(4)*psi%a(4))
end function sp_ff
@
<<Implementation of spinor currents>>=
pure function s_ff (gs, psibar, psi) result (j)
complex(kind=default) :: j
complex(kind=default), intent(in) :: gs
type(conjspinor), intent(in) :: psibar
type(spinor), intent(in) :: psi
j = gs * (psibar * psi)
end function s_ff
@
<<Implementation of spinor currents>>=
pure function p_ff (gp, psibar, psi) result (j)
complex(kind=default) :: j
complex(kind=default), intent(in) :: gp
type(conjspinor), intent(in) :: psibar
type(spinor), intent(in) :: psi
j = gp * ( psibar%a(3)*psi%a(3) + psibar%a(4)*psi%a(4) &
- psibar%a(1)*psi%a(1) - psibar%a(2)*psi%a(2))
end function p_ff
@
<<Implementation of spinor currents>>=
pure function sl_ff (gl, psibar, psi) result (j)
complex(kind=default) :: j
complex(kind=default), intent(in) :: gl
type(conjspinor), intent(in) :: psibar
type(spinor), intent(in) :: psi
j = 2 * gl * (psibar%a(1)*psi%a(1) + psibar%a(2)*psi%a(2))
end function sl_ff
@
<<Implementation of spinor currents>>=
pure function sr_ff (gr, psibar, psi) result (j)
complex(kind=default) :: j
complex(kind=default), intent(in) :: gr
type(conjspinor), intent(in) :: psibar
type(spinor), intent(in) :: psi
j = 2 * gr * (psibar%a(3)*psi%a(3) + psibar%a(4)*psi%a(4))
end function sr_ff
@
\begin{equation}
g_L(1-\gamma_5) + g_R(1+\gamma_5)
= (g_R+g_L) + (g_R-g_L)\gamma_5
= g_S + g_P\gamma_5
\end{equation}
<<Implementation of spinor currents>>=
pure function slr_ff (gl, gr, psibar, psi) result (j)
complex(kind=default) :: j
complex(kind=default), intent(in) :: gl, gr
type(conjspinor), intent(in) :: psibar
type(spinor), intent(in) :: psi
j = sp_ff (gr+gl, gr-gl, psibar, psi)
end function slr_ff
@
<<Declaration of spinor currents>>=
public :: f_spf, f_sf, f_pf, f_slf, f_srf, f_slrf
@
<<Implementation of spinor currents>>=
pure function f_spf (gs, gp, phi, psi) result (phipsi)
type(spinor) :: phipsi
complex(kind=default), intent(in) :: gs, gp
complex(kind=default), intent(in) :: phi
type(spinor), intent(in) :: psi
phipsi%a(1:2) = ((gs - gp) * phi) * psi%a(1:2)
phipsi%a(3:4) = ((gs + gp) * phi) * psi%a(3:4)
end function f_spf
@
<<Implementation of spinor currents>>=
pure function f_sf (gs, phi, psi) result (phipsi)
type(spinor) :: phipsi
complex(kind=default), intent(in) :: gs
complex(kind=default), intent(in) :: phi
type(spinor), intent(in) :: psi
phipsi%a = (gs * phi) * psi%a
end function f_sf
@
<<Implementation of spinor currents>>=
pure function f_pf (gp, phi, psi) result (phipsi)
type(spinor) :: phipsi
complex(kind=default), intent(in) :: gp
complex(kind=default), intent(in) :: phi
type(spinor), intent(in) :: psi
phipsi%a(1:2) = (- gp * phi) * psi%a(1:2)
phipsi%a(3:4) = ( gp * phi) * psi%a(3:4)
end function f_pf
@
<<Implementation of spinor currents>>=
pure function f_slf (gl, phi, psi) result (phipsi)
type(spinor) :: phipsi
complex(kind=default), intent(in) :: gl
complex(kind=default), intent(in) :: phi
type(spinor), intent(in) :: psi
phipsi%a(1:2) = (2 * gl * phi) * psi%a(1:2)
phipsi%a(3:4) = 0
end function f_slf
@
<<Implementation of spinor currents>>=
pure function f_srf (gr, phi, psi) result (phipsi)
type(spinor) :: phipsi
complex(kind=default), intent(in) :: gr
complex(kind=default), intent(in) :: phi
type(spinor), intent(in) :: psi
phipsi%a(1:2) = 0
phipsi%a(3:4) = (2 * gr * phi) * psi%a(3:4)
end function f_srf
@
<<Implementation of spinor currents>>=
pure function f_slrf (gl, gr, phi, psi) result (phipsi)
type(spinor) :: phipsi
complex(kind=default), intent(in) :: gl, gr
complex(kind=default), intent(in) :: phi
type(spinor), intent(in) :: psi
phipsi = f_spf (gr+gl, gr-gl, phi, psi)
end function f_slrf
@
<<Declaration of spinor currents>>=
public :: f_fsp, f_fs, f_fp, f_fsl, f_fsr, f_fslr
@
<<Implementation of spinor currents>>=
pure function f_fsp (gs, gp, psibar, phi) result (psibarphi)
type(conjspinor) :: psibarphi
complex(kind=default), intent(in) :: gs, gp
type(conjspinor), intent(in) :: psibar
complex(kind=default), intent(in) :: phi
psibarphi%a(1:2) = ((gs - gp) * phi) * psibar%a(1:2)
psibarphi%a(3:4) = ((gs + gp) * phi) * psibar%a(3:4)
end function f_fsp
@
<<Implementation of spinor currents>>=
pure function f_fs (gs, psibar, phi) result (psibarphi)
type(conjspinor) :: psibarphi
complex(kind=default), intent(in) :: gs
type(conjspinor), intent(in) :: psibar
complex(kind=default), intent(in) :: phi
psibarphi%a = (gs * phi) * psibar%a
end function f_fs
@
<<Implementation of spinor currents>>=
pure function f_fp (gp, psibar, phi) result (psibarphi)
type(conjspinor) :: psibarphi
complex(kind=default), intent(in) :: gp
type(conjspinor), intent(in) :: psibar
complex(kind=default), intent(in) :: phi
psibarphi%a(1:2) = (- gp * phi) * psibar%a(1:2)
psibarphi%a(3:4) = ( gp * phi) * psibar%a(3:4)
end function f_fp
@
<<Implementation of spinor currents>>=
pure function f_fsl (gl, psibar, phi) result (psibarphi)
type(conjspinor) :: psibarphi
complex(kind=default), intent(in) :: gl
type(conjspinor), intent(in) :: psibar
complex(kind=default), intent(in) :: phi
psibarphi%a(1:2) = (2 * gl * phi) * psibar%a(1:2)
psibarphi%a(3:4) = 0
end function f_fsl
@
<<Implementation of spinor currents>>=
pure function f_fsr (gr, psibar, phi) result (psibarphi)
type(conjspinor) :: psibarphi
complex(kind=default), intent(in) :: gr
type(conjspinor), intent(in) :: psibar
complex(kind=default), intent(in) :: phi
psibarphi%a(1:2) = 0
psibarphi%a(3:4) = (2 * gr * phi) * psibar%a(3:4)
end function f_fsr
@
<<Implementation of spinor currents>>=
pure function f_fslr (gl, gr, psibar, phi) result (psibarphi)
type(conjspinor) :: psibarphi
complex(kind=default), intent(in) :: gl, gr
type(conjspinor), intent(in) :: psibar
complex(kind=default), intent(in) :: phi
psibarphi = f_fsp (gr+gl, gr-gl, psibar, phi)
end function f_fslr
<<Declaration of spinor currents>>=
public :: f_gravf, f_fgrav
@
<<Implementation of spinor currents>>=
pure function f_gravf (g, m, kb, k, t, psi) result (tpsi)
type(spinor) :: tpsi
complex(kind=default), intent(in) :: g
real(kind=default), intent(in) :: m
type(spinor), intent(in) :: psi
type(tensor), intent(in) :: t
type(momentum), intent(in) :: kb, k
complex(kind=default) :: g2, g8, t_tr
type(vector) :: kkb
kkb = k + kb
g2 = g / 2.0_default
g8 = g / 8.0_default
t_tr = t%t(0,0) - t%t(1,1) - t%t(2,2) - t%t(3,3)
tpsi = (- f_sf (g2, cmplx (m,0.0, kind=default), psi) &
- f_vf ((g8*m), kkb, psi)) * t_tr - &
f_vf (g8,(t*kkb + kkb*t),psi)
end function f_gravf
@
<<Implementation of spinor currents>>=
pure function f_fgrav (g, m, kb, k, psibar, t) result (psibart)
type(conjspinor) :: psibart
complex(kind=default), intent(in) :: g
real(kind=default), intent(in) :: m
type(conjspinor), intent(in) :: psibar
type(tensor), intent(in) :: t
type(momentum), intent(in) :: kb, k
type(vector) :: kkb
complex(kind=default) :: g2, g8, t_tr
kkb = k + kb
g2 = g / 2.0_default
g8 = g / 8.0_default
t_tr = t%t(0,0) - t%t(1,1) - t%t(2,2) - t%t(3,3)
psibart = (- f_fs (g2, psibar, cmplx (m, 0.0, kind=default)) &
- f_fv ((g8 * m), psibar, kkb)) * t_tr - &
f_fv (g8,psibar,(t*kkb + kkb*t))
end function f_fgrav
@ \subsection{On Shell Wave Functions}
<<Declaration of spinor on shell wave functions>>=
public :: u, ubar, v, vbar
private :: chi_plus, chi_minus
@
\begin{subequations}
\begin{align}
\chi_+(\vec p) &=
\frac{1}{\sqrt{2|\vec p|(|\vec p|+p_3)}}
\begin{pmatrix} |\vec p|+p_3 \\ p_1 + \ii p_2 \end{pmatrix} \\
\chi_-(\vec p) &=
\frac{1}{\sqrt{2|\vec p|(|\vec p|+p_3)}}
\begin{pmatrix} - p_1 + \ii p_2 \\ |\vec p|+p_3 \end{pmatrix}
\end{align}
\end{subequations}
<<Implementation of spinor on shell wave functions>>=
pure function chi_plus (p) result (chi)
complex(kind=default), dimension(2) :: chi
type(momentum), intent(in) :: p
real(kind=default) :: pabs
pabs = sqrt (dot_product (p%x, p%x))
if (pabs + p%x(3) <= 1000 * epsilon (pabs) * pabs) then
chi = (/ cmplx ( 0.0, 0.0, kind=default), &
cmplx ( 1.0, 0.0, kind=default) /)
else
chi = 1 / sqrt (2*pabs*(pabs + p%x(3))) &
* (/ cmplx (pabs + p%x(3), kind=default), &
cmplx (p%x(1), p%x(2), kind=default) /)
end if
end function chi_plus
@
<<Implementation of spinor on shell wave functions>>=
pure function chi_minus (p) result (chi)
complex(kind=default), dimension(2) :: chi
type(momentum), intent(in) :: p
real(kind=default) :: pabs
pabs = sqrt (dot_product (p%x, p%x))
if (pabs + p%x(3) <= 1000 * epsilon (pabs) * pabs) then
chi = (/ cmplx (-1.0, 0.0, kind=default), &
cmplx ( 0.0, 0.0, kind=default) /)
else
chi = 1 / sqrt (2*pabs*(pabs + p%x(3))) &
* (/ cmplx (-p%x(1), p%x(2), kind=default), &
cmplx (pabs + p%x(3), kind=default) /)
end if
end function chi_minus
@
\begin{equation}
u_\pm(p,|m|) =
\begin{pmatrix}
\sqrt{p_0\mp|\vec p|} \cdot \chi_\pm(\vec p) \\
\sqrt{p_0\pm|\vec p|} \cdot \chi_\pm(\vec p)
\end{pmatrix}\qquad
u_\pm(p,-|m|) =
\begin{pmatrix}
- i \sqrt{p_0\mp|\vec p|} \cdot \chi_\pm(\vec p) \\
+ i \sqrt{p_0\pm|\vec p|} \cdot \chi_\pm(\vec p)
\end{pmatrix}
\end{equation}
Determining the mass from the momenta is a numerically haphazardous for
light particles. Therefore, we accept some redundancy and pass the
mass explicitely. Even if the mass is not used in the chiral
representation, we do so for symmetry with polarization vectors and to
be prepared for other representations.
<<Implementation of spinor on shell wave functions>>=
pure function u (mass, p, s) result (psi)
type(spinor) :: psi
real(kind=default), intent(in) :: mass
type(momentum), intent(in) :: p
integer, intent(in) :: s
complex(kind=default), dimension(2) :: chi
real(kind=default) :: pabs, delta, m
m = abs(mass)
pabs = sqrt (dot_product (p%x, p%x))
if (m < epsilon (m) * pabs) then
delta = 0
else
delta = sqrt (max (p%t - pabs, 0._default))
end if
select case (s)
case (1)
chi = chi_plus (p)
psi%a(1:2) = delta * chi
psi%a(3:4) = sqrt (p%t + pabs) * chi
case (-1)
chi = chi_minus (p)
psi%a(1:2) = sqrt (p%t + pabs) * chi
psi%a(3:4) = delta * chi
case default
pabs = m ! make the compiler happy and use m
psi%a = 0
end select
if (mass < 0) then
psi%a(1:2) = - imago * psi%a(1:2)
psi%a(3:4) = + imago * psi%a(3:4)
end if
end function u
@
<<Implementation of spinor on shell wave functions>>=
pure function ubar (m, p, s) result (psibar)
type(conjspinor) :: psibar
real(kind=default), intent(in) :: m
type(momentum), intent(in) :: p
integer, intent(in) :: s
type(spinor) :: psi
psi = u (m, p, s)
psibar%a(1:2) = conjg (psi%a(3:4))
psibar%a(3:4) = conjg (psi%a(1:2))
end function ubar
@
\begin{equation}
v_\pm(p) =
\begin{pmatrix}
\mp\sqrt{p_0\pm|\vec p|} \cdot \chi_\mp(\vec p) \\
\pm\sqrt{p_0\mp|\vec p|} \cdot \chi_\mp(\vec p)
\end{pmatrix}
\end{equation}
<<Implementation of spinor on shell wave functions>>=
pure function v (mass, p, s) result (psi)
type(spinor) :: psi
real(kind=default), intent(in) :: mass
type(momentum), intent(in) :: p
integer, intent(in) :: s
complex(kind=default), dimension(2) :: chi
real(kind=default) :: pabs, delta, m
m = abs(mass)
pabs = sqrt (dot_product (p%x, p%x))
if (m < epsilon (m) * pabs) then
delta = 0
else
delta = sqrt (max (p%t - pabs, 0._default))
end if
select case (s)
case (1)
chi = chi_minus (p)
psi%a(1:2) = - sqrt (p%t + pabs) * chi
psi%a(3:4) = delta * chi
case (-1)
chi = chi_plus (p)
psi%a(1:2) = delta * chi
psi%a(3:4) = - sqrt (p%t + pabs) * chi
case default
pabs = m ! make the compiler happy and use m
psi%a = 0
end select
if (mass < 0) then
psi%a(1:2) = - imago * psi%a(1:2)
psi%a(3:4) = + imago * psi%a(3:4)
end if
end function v
@
<<Implementation of spinor on shell wave functions>>=
pure function vbar (m, p, s) result (psibar)
type(conjspinor) :: psibar
real(kind=default), intent(in) :: m
type(momentum), intent(in) :: p
integer, intent(in) :: s
type(spinor) :: psi
psi = v (m, p, s)
psibar%a(1:2) = conjg (psi%a(3:4))
psibar%a(3:4) = conjg (psi%a(1:2))
end function vbar
@
\subsection{Off Shell Wave Functions}
I've just taken this over from Christian Schwinn's version.
<<Declaration of spinor off shell wave functions>>=
public :: brs_u, brs_ubar, brs_v, brs_vbar
@
The off-shell wave functions needed for gauge checking are obtained from the LSZ-formulas:
\begin{subequations}
\begin{align}
\Braket{\text{Out}|d^\dagger|\text{In}}&=i\int d^4x \bar v
e^{-ikx}(i\fmslash\partial-m)\Braket{\text{Out}|\psi|\text{In}}\\
\Braket{\text{Out}|b|\text{In}}&=-i\int d^4x \bar u
e^{ikx}(i\fmslash\partial-m)\Braket{\text{Out}|\psi|\text{In}}\\
\Braket{\text{Out}|d|\text{In}}&=
i\int d^4x \Braket{\text{Out}|\bar \psi|
\text{In}}(-i\fmslash{\overleftarrow\partial}-m)v e^{ikx}\\
\Braket{\text{Out}|b^\dagger|\text{In}}&=
-i\int d^4x \Braket{\text{Out}|\bar \psi|
\text{In}}(-i\fmslash{\overleftarrow\partial}-m)u e^{-ikx}
\end{align}
\end{subequations}
Since the relative sign between fermions and antifermions is ignored for
on-shell amplitudes we must also ignore it here, so all wavefunctions must
have a $(-i)$ factor.
In momentum space we have:
\begin{equation}
brs u(p)=(-i) (\fmslash p-m)u(p)
\end{equation}
<<Implementation of spinor off shell wave functions>>=
pure function brs_u (m, p, s) result (dpsi)
type(spinor) :: dpsi,psi
real(kind=default), intent(in) :: m
type(momentum), intent(in) :: p
integer, intent(in) :: s
type (vector)::vp
complex(kind=default), parameter :: one = (1, 0)
vp=p
psi=u(m,p,s)
dpsi=cmplx(0.0,-1.0)*(f_vf(one,vp,psi)-m*psi)
end function brs_u
@
\begin{equation}
brs v(p)=i (\fmslash p+m)v(p)
\end{equation}
<<Implementation of spinor off shell wave functions>>=
pure function brs_v (m, p, s) result (dpsi)
type(spinor) :: dpsi, psi
real(kind=default), intent(in) :: m
type(momentum), intent(in) :: p
integer, intent(in) :: s
type (vector)::vp
complex(kind=default), parameter :: one = (1, 0)
vp=p
psi=v(m,p,s)
dpsi=cmplx(0.0,1.0)*(f_vf(one,vp,psi)+m*psi)
end function brs_v
@
\begin{equation}
brs \bar{u}(p)=(-i)\bar u(p)(\fmslash p-m)
\end{equation}
<<Implementation of spinor off shell wave functions>>=
pure function brs_ubar (m, p, s)result (dpsibar)
type(conjspinor) :: dpsibar, psibar
real(kind=default), intent(in) :: m
type(momentum), intent(in) :: p
integer, intent(in) :: s
type (vector)::vp
complex(kind=default), parameter :: one = (1, 0)
vp=p
psibar=ubar(m,p,s)
dpsibar=cmplx(0.0,-1.0)*(f_fv(one,psibar,vp)-m*psibar)
end function brs_ubar
@
\begin{equation}
brs \bar{v}(p)=(i)\bar v(p)(\fmslash p+m)
\end{equation}
<<Implementation of spinor off shell wave functions>>=
pure function brs_vbar (m, p, s) result (dpsibar)
type(conjspinor) :: dpsibar,psibar
real(kind=default), intent(in) :: m
type(momentum), intent(in) :: p
integer, intent(in) :: s
type(vector)::vp
complex(kind=default), parameter :: one = (1, 0)
vp=p
psibar=vbar(m,p,s)
dpsibar=cmplx(0.0,1.0)*(f_fv(one,psibar,vp)+m*psibar)
end function brs_vbar
@
NB: The remarks on momentum flow in the propagators don't apply
here since the incoming momenta are flipped for the wave functions.
@ \subsection{Propagators}
NB: the common factor of~$\ii$ is extracted:
<<Declaration of spinor propagators>>=
public :: pr_psi, pr_psibar
public :: pj_psi, pj_psibar
public :: pg_psi, pg_psibar
@
\begin{equation}
\frac{i(-\fmslash{p}+m)}{p^2-m^2+\ii m\Gamma}\psi
\end{equation}
NB: the sign of the momentum comes about because all momenta are
treated as \emph{outgoing} and the particle charge flow is therefore
opposite to the momentum.
<<Implementation of spinor propagators>>=
pure function pr_psi (p, m, w, cms, psi) result (ppsi)
type(spinor) :: ppsi
type(momentum), intent(in) :: p
real(kind=default), intent(in) :: m, w
type(spinor), intent(in) :: psi
logical, intent(in) :: cms
type(vector) :: vp
complex(kind=default), parameter :: one = (1, 0)
complex(kind=default) :: num_mass
vp = p
if (cms) then
num_mass = sqrt(cmplx(m**2, -m*w, kind=default))
else
num_mass = cmplx (m, 0, kind=default)
end if
ppsi = (1 / cmplx (p*p - m**2, m*w, kind=default)) &
* (- f_vf (one, vp, psi) + num_mass * psi)
end function pr_psi
@
\begin{equation}
\sqrt{\frac{\pi}{M\Gamma}}
(-\fmslash{p}+m)\psi
\end{equation}
<<Implementation of spinor propagators>>=
pure function pj_psi (p, m, w, psi) result (ppsi)
type(spinor) :: ppsi
type(momentum), intent(in) :: p
real(kind=default), intent(in) :: m, w
type(spinor), intent(in) :: psi
type(vector) :: vp
complex(kind=default), parameter :: one = (1, 0)
vp = p
ppsi = (0, -1) * sqrt (PI / m / w) * (- f_vf (one, vp, psi) + m * psi)
end function pj_psi
@
<<Implementation of spinor propagators>>=
pure function pg_psi (p, m, w, psi) result (ppsi)
type(spinor) :: ppsi
type(momentum), intent(in) :: p
real(kind=default), intent(in) :: m, w
type(spinor), intent(in) :: psi
type(vector) :: vp
complex(kind=default), parameter :: one = (1, 0)
vp = p
ppsi = gauss(p*p, m, w) * (- f_vf (one, vp, psi) + m * psi)
end function pg_psi
@
\begin{equation}
\bar\psi \frac{i(\fmslash{p}+m)}{p^2-m^2+\ii m\Gamma}
\end{equation}
NB: the sign of the momentum comes about because all momenta are
treated as \emph{outgoing} and the antiparticle charge flow is
therefore parallel to the momentum.
<<Implementation of spinor propagators>>=
pure function pr_psibar (p, m, w, cms, psibar) result (ppsibar)
type(conjspinor) :: ppsibar
type(momentum), intent(in) :: p
real(kind=default), intent(in) :: m, w
type(conjspinor), intent(in) :: psibar
logical, intent(in) :: cms
type(vector) :: vp
complex(kind=default), parameter :: one = (1, 0)
complex(kind=default) :: num_mass
vp = p
if (cms) then
num_mass = sqrt(cmplx(m**2, -m*w, kind=default))
else
num_mass = cmplx (m, 0, kind=default)
end if
ppsibar = (1 / cmplx (p*p - m**2, m*w, kind=default)) &
* (f_fv (one, psibar, vp) + num_mass * psibar)
end function pr_psibar
@
\begin{equation}
\sqrt{\frac{\pi}{M\Gamma}}
\bar\psi (\fmslash{p}+m)
\end{equation}
NB: the sign of the momentum comes about because all momenta are
treated as \emph{outgoing} and the antiparticle charge flow is
therefore parallel to the momentum.
<<Implementation of spinor propagators>>=
pure function pj_psibar (p, m, w, psibar) result (ppsibar)
type(conjspinor) :: ppsibar
type(momentum), intent(in) :: p
real(kind=default), intent(in) :: m, w
type(conjspinor), intent(in) :: psibar
type(vector) :: vp
complex(kind=default), parameter :: one = (1, 0)
vp = p
ppsibar = (0, -1) * sqrt (PI / m / w) * (f_fv (one, psibar, vp) + m * psibar)
end function pj_psibar
@
<<Implementation of spinor propagators>>=
pure function pg_psibar (p, m, w, psibar) result (ppsibar)
type(conjspinor) :: ppsibar
type(momentum), intent(in) :: p
real(kind=default), intent(in) :: m, w
type(conjspinor), intent(in) :: psibar
type(vector) :: vp
complex(kind=default), parameter :: one = (1, 0)
vp = p
ppsibar = gauss (p*p, m, w) * (f_fv (one, psibar, vp) + m * psibar)
end function pg_psibar
@
\begin{equation}
\frac{i(-\fmslash{p}+m)}{p^2-m^2+\ii m\Gamma} \sum_n \psi_n\otimes\bar\psi_n
\end{equation}
NB: the temporary variables [[psi(1:4)]] are not nice, but the compilers
should be able to optimize the unnecessary copies away. In any case, even
if the copies are performed, they are (probably) negligible compared to the
floating point multiplications anyway \ldots
<<(Not used yet) Declaration of operations for spinors>>=
type, public :: spinordyad
! private (omegalib needs access, but DON'T TOUCH IT!)
complex(kind=default), dimension(4,4) :: a
end type spinordyad
@
<<(Not used yet) Implementation of spinor propagators>>=
pure function pr_dyadleft (p, m, w, psipsibar) result (psipsibarp)
type(spinordyad) :: psipsibarp
type(momentum), intent(in) :: p
real(kind=default), intent(in) :: m, w
type(spinordyad), intent(in) :: psipsibar
integer :: i
type(vector) :: vp
type(spinor), dimension(4) :: psi
complex(kind=default) :: pole
complex(kind=default), parameter :: one = (1, 0)
vp = p
pole = 1 / cmplx (p*p - m**2, m*w, kind=default)
do i = 1, 4
psi(i)%a = psipsibar%a(:,i)
psi(i) = pole * (- f_vf (one, vp, psi(i)) + m * psi(i))
psipsibarp%a(:,i) = psi(i)%a
end do
end function pr_dyadleft
@
\begin{equation}
\sum_n \psi_n\otimes\bar\psi_n \frac{i(\fmslash{p}+m)}{p^2-m^2+\ii m\Gamma}
\end{equation}
<<(Not used yet) Implementation of spinor propagators>>=
pure function pr_dyadright (p, m, w, psipsibar) result (psipsibarp)
type(spinordyad) :: psipsibarp
type(momentum), intent(in) :: p
real(kind=default), intent(in) :: m, w
type(spinordyad), intent(in) :: psipsibar
integer :: i
type(vector) :: vp
type(conjspinor), dimension(4) :: psibar
complex(kind=default) :: pole
complex(kind=default), parameter :: one = (1, 0)
vp = p
pole = 1 / cmplx (p*p - m**2, m*w, kind=default)
do i = 1, 4
psibar(i)%a = psipsibar%a(i,:)
psibar(i) = pole * (f_fv (one, psibar(i), vp) + m * psibar(i))
psipsibarp%a(i,:) = psibar(i)%a
end do
end function pr_dyadright
@
\section{Spinor Couplings Revisited}
<<[[omega_bispinor_couplings.f90]]>>=
<<Copyleft>>
module omega_bispinor_couplings
use kinds
use constants
use omega_bispinors
use omega_vectorspinors
use omega_vectors
use omega_couplings
implicit none
private
<<Declaration of bispinor on shell wave functions>>
<<Declaration of bispinor off shell wave functions>>
<<Declaration of bispinor currents>>
<<Declaration of bispinor propagators>>
integer, parameter, public :: omega_bispinor_cpls_2010_01_A = 0
contains
<<Implementation of bispinor on shell wave functions>>
<<Implementation of bispinor off shell wave functions>>
<<Implementation of bispinor currents>>
<<Implementation of bispinor propagators>>
end module omega_bispinor_couplings
@
See table~\ref{tab:fermionic-currents} for the names of Fortran
functions. We could have used long names instead, but this would
increase the chance of running past continuation line limits without
adding much to the legibility.
@
\subsection{Fermionic Vector and Axial Couplings}
\label{sec:dirac-matrices-jrr}
There's more than one chiral representation. This one is compatible
with HELAS~\cite{HELAS}.
\begin{subequations}
\begin{align}
& \gamma^0 = \begin{pmatrix} 0 & \mathbf{1} \\ \mathbf{1} & 0
\end{pmatrix},\;
\gamma^i = \begin{pmatrix} 0 & \sigma^i \\ -\sigma^i & 0 \end{pmatrix},\;
\gamma_5 = i\gamma^0\gamma^1\gamma^2\gamma^3
= \begin{pmatrix} -\mathbf{1} & 0 \\ 0 & \mathbf{1}
\end{pmatrix}, \\ &
C = \begin{pmatrix} \epsilon & 0 \\ 0 & - \epsilon \end{pmatrix}
\; , \qquad \epsilon = \begin{pmatrix} 0 & 1 \\ -1 & 0 \end{pmatrix} .
\end{align}
\end{subequations}
Therefore
\begin{subequations}
\begin{align}
g_S + g_P\gamma_5 &=
\begin{pmatrix}
g_S - g_P & 0 & 0 & 0 \\
0 & g_S - g_P & 0 & 0 \\
0 & 0 & g_S + g_P & 0 \\
0 & 0 & 0 & g_S + g_P
\end{pmatrix} \\
g_V\gamma^0 - g_A\gamma^0\gamma_5 &=
\begin{pmatrix}
0 & 0 & g_V - g_A & 0 \\
0 & 0 & 0 & g_V - g_A \\
g_V + g_A & 0 & 0 & 0 \\
0 & g_V + g_A & 0 & 0
\end{pmatrix} \\
g_V\gamma^1 - g_A\gamma^1\gamma_5 &=
\begin{pmatrix}
0 & 0 & 0 & g_V - g_A \\
0 & 0 & g_V - g_A & 0 \\
0 & - g_V - g_A & 0 & 0 \\
- g_V - g_A & 0 & 0 & 0
\end{pmatrix} \\
g_V\gamma^2 - g_A\gamma^2\gamma_5 &=
\begin{pmatrix}
0 & 0 & 0 & -\ii(g_V - g_A) \\
0 & 0 & \ii(g_V - g_A) & 0 \\
0 & \ii(g_V + g_A) & 0 & 0 \\
-\ii(g_V + g_A) & 0 & 0 & 0
\end{pmatrix} \\
g_V\gamma^3 - g_A\gamma^3\gamma_5 &=
\begin{pmatrix}
0 & 0 & g_V - g_A & 0 \\
0 & 0 & 0 & - g_V + g_A \\
- g_V - g_A & 0 & 0 & 0 \\
0 & g_V + g_A & 0 & 0
\end{pmatrix}
\end{align}
\end{subequations}
and
\begin{subequations}
\begin{align}
C(g_S + g_P\gamma_5) &=
\begin{pmatrix}
0 & g_S - g_P & 0 & 0 \\
- g_S + g_P & 0 & 0 & 0 \\
0 & 0 & 0 & - g_S - g_P \\
0 & 0 & g_S + g_P & 0
\end{pmatrix} \\
C(g_V\gamma^0 - g_A\gamma^0\gamma_5) &=
\begin{pmatrix}
0 & 0 & 0 & g_V - g_A \\
0 & 0 & - g_V + g_A & 0 \\
0 & - g_V - g_A & 0 & 0 \\
g_V + g_A & 0 & 0 & 0
\end{pmatrix} \\
C(g_V\gamma^1 - g_A\gamma^1\gamma_5) &=
\begin{pmatrix}
0 & 0 & g_V - g_A & 0 \\
0 & 0 & 0 & - g_V + g_A \\
g_V + g_A & 0 & 0 & 0 \\
0 & - g_V - g_A & 0 & 0
\end{pmatrix} \\
C(g_V\gamma^2 - g_A\gamma^2\gamma_5) &=
\begin{pmatrix}
0 & 0 & \ii(g_V - g_A) & 0 \\
0 & 0 & 0 & \ii(g_V - g_A) \\
\ii(g_V + g_A) & 0 & 0 & 0 \\
0 & \ii(g_V + g_A) & 0 & 0
\end{pmatrix} \\
C(g_V\gamma^3 - g_A\gamma^3\gamma_5) &=
\begin{pmatrix}
0 & 0 & 0 & - g_V + g_A \\
0 & 0 & - g_V + g_A & 0 \\
0 & - g_V - g_A & 0 & 0 \\
- g_V - g_A & 0 & 0 & 0
\end{pmatrix}
\end{align}
\end{subequations}
<<Declaration of bispinor currents>>=
public :: va_ff, v_ff, a_ff, vl_ff, vr_ff, vlr_ff, va2_ff, tva_ff, tvam_ff, &
tlr_ff, tlrm_ff
@
<<Implementation of bispinor currents>>=
pure function va_ff (gv, ga, psil, psir) result (j)
type(vector) :: j
complex(kind=default), intent(in) :: gv, ga
type(bispinor), intent(in) :: psil, psir
complex(kind=default) :: gl, gr
complex(kind=default) :: g13, g14, g23, g24, g31, g32, g41, g42
gl = gv + ga
gr = gv - ga
g13 = psil%a(1)*psir%a(3)
g14 = psil%a(1)*psir%a(4)
g23 = psil%a(2)*psir%a(3)
g24 = psil%a(2)*psir%a(4)
g31 = psil%a(3)*psir%a(1)
g32 = psil%a(3)*psir%a(2)
g41 = psil%a(4)*psir%a(1)
g42 = psil%a(4)*psir%a(2)
j%t = gr * ( g14 - g23) + gl * ( - g32 + g41)
j%x(1) = gr * ( g13 - g24) + gl * ( g31 - g42)
j%x(2) = (gr * ( g13 + g24) + gl * ( g31 + g42)) * (0, 1)
j%x(3) = gr * ( - g14 - g23) + gl * ( - g32 - g41)
end function va_ff
@
<<Implementation of bispinor currents>>=
pure function va2_ff (gva, psil, psir) result (j)
type(vector) :: j
complex(kind=default), intent(in), dimension(2) :: gva
type(bispinor), intent(in) :: psil, psir
complex(kind=default) :: gl, gr
complex(kind=default) :: g13, g14, g23, g24, g31, g32, g41, g42
gl = gva(1) + gva(2)
gr = gva(1) - gva(2)
g13 = psil%a(1)*psir%a(3)
g14 = psil%a(1)*psir%a(4)
g23 = psil%a(2)*psir%a(3)
g24 = psil%a(2)*psir%a(4)
g31 = psil%a(3)*psir%a(1)
g32 = psil%a(3)*psir%a(2)
g41 = psil%a(4)*psir%a(1)
g42 = psil%a(4)*psir%a(2)
j%t = gr * ( g14 - g23) + gl * ( - g32 + g41)
j%x(1) = gr * ( g13 - g24) + gl * ( g31 - g42)
j%x(2) = (gr * ( g13 + g24) + gl * ( g31 + g42)) * (0, 1)
j%x(3) = gr * ( - g14 - g23) + gl * ( - g32 - g41)
end function va2_ff
@
<<Implementation of bispinor currents>>=
pure function v_ff (gv, psil, psir) result (j)
type(vector) :: j
complex(kind=default), intent(in) :: gv
type(bispinor), intent(in) :: psil, psir
complex(kind=default) :: g13, g14, g23, g24, g31, g32, g41, g42
g13 = psil%a(1)*psir%a(3)
g14 = psil%a(1)*psir%a(4)
g23 = psil%a(2)*psir%a(3)
g24 = psil%a(2)*psir%a(4)
g31 = psil%a(3)*psir%a(1)
g32 = psil%a(3)*psir%a(2)
g41 = psil%a(4)*psir%a(1)
g42 = psil%a(4)*psir%a(2)
j%t = gv * ( g14 - g23 - g32 + g41)
j%x(1) = gv * ( g13 - g24 + g31 - g42)
j%x(2) = gv * ( g13 + g24 + g31 + g42) * (0, 1)
j%x(3) = gv * ( - g14 - g23 - g32 - g41)
end function v_ff
@
<<Implementation of bispinor currents>>=
pure function a_ff (ga, psil, psir) result (j)
type(vector) :: j
complex(kind=default), intent(in) :: ga
type(bispinor), intent(in) :: psil, psir
complex(kind=default) :: g13, g14, g23, g24, g31, g32, g41, g42
g13 = psil%a(1)*psir%a(3)
g14 = psil%a(1)*psir%a(4)
g23 = psil%a(2)*psir%a(3)
g24 = psil%a(2)*psir%a(4)
g31 = psil%a(3)*psir%a(1)
g32 = psil%a(3)*psir%a(2)
g41 = psil%a(4)*psir%a(1)
g42 = psil%a(4)*psir%a(2)
j%t = -ga * ( g14 - g23 + g32 - g41)
j%x(1) = -ga * ( g13 - g24 - g31 + g42)
j%x(2) = -ga * ( g13 + g24 - g31 - g42) * (0, 1)
j%x(3) = -ga * ( - g14 - g23 + g32 + g41)
end function a_ff
@
<<Implementation of bispinor currents>>=
pure function vl_ff (gl, psil, psir) result (j)
type(vector) :: j
complex(kind=default), intent(in) :: gl
type(bispinor), intent(in) :: psil, psir
complex(kind=default) :: gl2
complex(kind=default) :: g31, g32, g41, g42
gl2 = 2 * gl
g31 = psil%a(3)*psir%a(1)
g32 = psil%a(3)*psir%a(2)
g41 = psil%a(4)*psir%a(1)
g42 = psil%a(4)*psir%a(2)
j%t = gl2 * ( - g32 + g41)
j%x(1) = gl2 * ( g31 - g42)
j%x(2) = gl2 * ( g31 + g42) * (0, 1)
j%x(3) = gl2 * ( - g32 - g41)
end function vl_ff
@
<<Implementation of bispinor currents>>=
pure function vr_ff (gr, psil, psir) result (j)
type(vector) :: j
complex(kind=default), intent(in) :: gr
type(bispinor), intent(in) :: psil, psir
complex(kind=default) :: gr2
complex(kind=default) :: g13, g14, g23, g24
gr2 = 2 * gr
g13 = psil%a(1)*psir%a(3)
g14 = psil%a(1)*psir%a(4)
g23 = psil%a(2)*psir%a(3)
g24 = psil%a(2)*psir%a(4)
j%t = gr2 * ( g14 - g23)
j%x(1) = gr2 * ( g13 - g24)
j%x(2) = gr2 * ( g13 + g24) * (0, 1)
j%x(3) = gr2 * ( - g14 - g23)
end function vr_ff
@
<<Implementation of bispinor currents>>=
pure function vlr_ff (gl, gr, psibar, psi) result (j)
type(vector) :: j
complex(kind=default), intent(in) :: gl, gr
type(bispinor), intent(in) :: psibar
type(bispinor), intent(in) :: psi
j = va_ff (gl+gr, gl-gr, psibar, psi)
end function vlr_ff
@
<<Implementation of bispinor currents>>=
pure function tva_ff (gv, ga, psibar, psi) result (t)
type(tensor2odd) :: t
complex(kind=default), intent(in) :: gv, ga
type(bispinor), intent(in) :: psibar
type(bispinor), intent(in) :: psi
complex(kind=default) :: gl, gr
complex(kind=default) :: g11, g22, g33, g44, g1p2, g3p4
gr = gv + ga
gl = gv - ga
g11 = psibar%a(1)*psi%a(1)
g22 = psibar%a(2)*psi%a(2)
g1p2 = psibar%a(1)*psi%a(2) + psibar%a(2)*psi%a(1)
g3p4 = psibar%a(3)*psi%a(4) + psibar%a(4)*psi%a(3)
g33 = psibar%a(3)*psi%a(3)
g44 = psibar%a(4)*psi%a(4)
t%e(1) = (gl * ( - g11 + g22) + gr * ( - g33 + g44)) * (0, 1)
t%e(2) = gl * ( g11 + g22) + gr * ( g33 + g44)
t%e(3) = (gl * ( g1p2 ) + gr * ( g3p4 )) * (0, 1)
t%b(1) = gl * ( g11 - g22) + gr * ( - g33 + g44)
t%b(2) = (gl * ( g11 + g22) + gr * ( - g33 - g44)) * (0, 1)
t%b(3) = gl * ( - g1p2 ) + gr * ( g3p4 )
end function tva_ff
@
<<Implementation of bispinor currents>>=
pure function tlr_ff (gl, gr, psibar, psi) result (t)
type(tensor2odd) :: t
complex(kind=default), intent(in) :: gl, gr
type(bispinor), intent(in) :: psibar
type(bispinor), intent(in) :: psi
t = tva_ff (gr+gl, gr-gl, psibar, psi)
end function tlr_ff
@
<<Implementation of bispinor currents>>=
pure function tvam_ff (gv, ga, psibar, psi, p) result (j)
type(vector) :: j
complex(kind=default), intent(in) :: gv, ga
type(bispinor), intent(in) :: psibar
type(bispinor), intent(in) :: psi
type(momentum), intent(in) :: p
j = (tva_ff(gv, ga, psibar, psi) * p) * (0,1)
end function tvam_ff
@
<<Implementation of bispinor currents>>=
pure function tlrm_ff (gl, gr, psibar, psi, p) result (j)
type(vector) :: j
complex(kind=default), intent(in) :: gl, gr
type(bispinor), intent(in) :: psibar
type(bispinor), intent(in) :: psi
type(momentum), intent(in) :: p
j = tvam_ff (gr+gl, gr-gl, psibar, psi, p)
end function tlrm_ff
@
and
\begin{equation}
\fmslash{v} - \fmslash{a}\gamma_5 =
\begin{pmatrix}
0 & 0 & v_- - a_- & - v^* + a^* \\
0 & 0 & - v + a & v_+ - a_+ \\
v_+ + a_+ & v^* + a^* & 0 & 0 \\
v + a & v_- + a_- & 0 & 0
\end{pmatrix}
\end{equation}
with $v_\pm=v_0\pm v_3$, $a_\pm=a_0\pm a_3$, $v=v_1+\ii v_2$,
$v^*=v_1-\ii v_2$, $a=a_1+\ii a_2$, and $a^*=a_1-\ii a_2$. But note
that~$\cdot^*$ is \emph{not} complex conjugation for complex~$v_\mu$
or~$a_\mu$.
<<Declaration of bispinor currents>>=
public :: f_vaf, f_vf, f_af, f_vlf, f_vrf, f_vlrf, f_va2f, &
f_tvaf, f_tlrf, f_tvamf, f_tlrmf
@
<<Implementation of bispinor currents>>=
pure function f_vaf (gv, ga, v, psi) result (vpsi)
type(bispinor) :: vpsi
complex(kind=default), intent(in) :: gv, ga
type(vector), intent(in) :: v
type(bispinor), intent(in) :: psi
complex(kind=default) :: gl, gr
complex(kind=default) :: vp, vm, v12, v12s
gl = gv + ga
gr = gv - ga
vp = v%t + v%x(3)
vm = v%t - v%x(3)
v12 = v%x(1) + (0,1)*v%x(2)
v12s = v%x(1) - (0,1)*v%x(2)
vpsi%a(1) = gr * ( vm * psi%a(3) - v12s * psi%a(4))
vpsi%a(2) = gr * ( - v12 * psi%a(3) + vp * psi%a(4))
vpsi%a(3) = gl * ( vp * psi%a(1) + v12s * psi%a(2))
vpsi%a(4) = gl * ( v12 * psi%a(1) + vm * psi%a(2))
end function f_vaf
@
<<Implementation of bispinor currents>>=
pure function f_va2f (gva, v, psi) result (vpsi)
type(bispinor) :: vpsi
complex(kind=default), intent(in), dimension(2) :: gva
type(vector), intent(in) :: v
type(bispinor), intent(in) :: psi
complex(kind=default) :: gl, gr
complex(kind=default) :: vp, vm, v12, v12s
gl = gva(1) + gva(2)
gr = gva(1) - gva(2)
vp = v%t + v%x(3)
vm = v%t - v%x(3)
v12 = v%x(1) + (0,1)*v%x(2)
v12s = v%x(1) - (0,1)*v%x(2)
vpsi%a(1) = gr * ( vm * psi%a(3) - v12s * psi%a(4))
vpsi%a(2) = gr * ( - v12 * psi%a(3) + vp * psi%a(4))
vpsi%a(3) = gl * ( vp * psi%a(1) + v12s * psi%a(2))
vpsi%a(4) = gl * ( v12 * psi%a(1) + vm * psi%a(2))
end function f_va2f
@
<<Implementation of bispinor currents>>=
pure function f_vf (gv, v, psi) result (vpsi)
type(bispinor) :: vpsi
complex(kind=default), intent(in) :: gv
type(vector), intent(in) :: v
type(bispinor), intent(in) :: psi
complex(kind=default) :: vp, vm, v12, v12s
vp = v%t + v%x(3)
vm = v%t - v%x(3)
v12 = v%x(1) + (0,1)*v%x(2)
v12s = v%x(1) - (0,1)*v%x(2)
vpsi%a(1) = gv * ( vm * psi%a(3) - v12s * psi%a(4))
vpsi%a(2) = gv * ( - v12 * psi%a(3) + vp * psi%a(4))
vpsi%a(3) = gv * ( vp * psi%a(1) + v12s * psi%a(2))
vpsi%a(4) = gv * ( v12 * psi%a(1) + vm * psi%a(2))
end function f_vf
@
<<Implementation of bispinor currents>>=
pure function f_af (ga, v, psi) result (vpsi)
type(bispinor) :: vpsi
complex(kind=default), intent(in) :: ga
type(vector), intent(in) :: v
type(bispinor), intent(in) :: psi
complex(kind=default) :: vp, vm, v12, v12s
vp = v%t + v%x(3)
vm = v%t - v%x(3)
v12 = v%x(1) + (0,1)*v%x(2)
v12s = v%x(1) - (0,1)*v%x(2)
vpsi%a(1) = ga * ( - vm * psi%a(3) + v12s * psi%a(4))
vpsi%a(2) = ga * ( v12 * psi%a(3) - vp * psi%a(4))
vpsi%a(3) = ga * ( vp * psi%a(1) + v12s * psi%a(2))
vpsi%a(4) = ga * ( v12 * psi%a(1) + vm * psi%a(2))
end function f_af
@
<<Implementation of bispinor currents>>=
pure function f_vlf (gl, v, psi) result (vpsi)
type(bispinor) :: vpsi
complex(kind=default), intent(in) :: gl
type(vector), intent(in) :: v
type(bispinor), intent(in) :: psi
complex(kind=default) :: gl2
complex(kind=default) :: vp, vm, v12, v12s
gl2 = 2 * gl
vp = v%t + v%x(3)
vm = v%t - v%x(3)
v12 = v%x(1) + (0,1)*v%x(2)
v12s = v%x(1) - (0,1)*v%x(2)
vpsi%a(1) = 0
vpsi%a(2) = 0
vpsi%a(3) = gl2 * ( vp * psi%a(1) + v12s * psi%a(2))
vpsi%a(4) = gl2 * ( v12 * psi%a(1) + vm * psi%a(2))
end function f_vlf
@
<<Implementation of bispinor currents>>=
pure function f_vrf (gr, v, psi) result (vpsi)
type(bispinor) :: vpsi
complex(kind=default), intent(in) :: gr
type(vector), intent(in) :: v
type(bispinor), intent(in) :: psi
complex(kind=default) :: gr2
complex(kind=default) :: vp, vm, v12, v12s
gr2 = 2 * gr
vp = v%t + v%x(3)
vm = v%t - v%x(3)
v12 = v%x(1) + (0,1)*v%x(2)
v12s = v%x(1) - (0,1)*v%x(2)
vpsi%a(1) = gr2 * ( vm * psi%a(3) - v12s * psi%a(4))
vpsi%a(2) = gr2 * ( - v12 * psi%a(3) + vp * psi%a(4))
vpsi%a(3) = 0
vpsi%a(4) = 0
end function f_vrf
@
<<Implementation of bispinor currents>>=
pure function f_vlrf (gl, gr, v, psi) result (vpsi)
type(bispinor) :: vpsi
complex(kind=default), intent(in) :: gl, gr
type(vector), intent(in) :: v
type(bispinor), intent(in) :: psi
vpsi = f_vaf (gl+gr, gl-gr, v, psi)
end function f_vlrf
@
<<Implementation of bispinor currents>>=
pure function f_tvaf (gv, ga, t, psi) result (tpsi)
type(bispinor) :: tpsi
complex(kind=default), intent(in) :: gv, ga
type(tensor2odd), intent(in) :: t
type(bispinor), intent(in) :: psi
complex(kind=default) :: gl, gr
complex(kind=default) :: e21, e21s, b12, b12s, be3, be3s
gr = gv + ga
gl = gv - ga
e21 = t%e(2) + t%e(1)*(0,1)
e21s = t%e(2) - t%e(1)*(0,1)
b12 = t%b(1) + t%b(2)*(0,1)
b12s = t%b(1) - t%b(2)*(0,1)
be3 = t%b(3) + t%e(3)*(0,1)
be3s = t%b(3) - t%e(3)*(0,1)
tpsi%a(1) = 2*gl * ( psi%a(1) * be3 + psi%a(2) * ( e21 +b12s))
tpsi%a(2) = 2*gl * ( - psi%a(2) * be3 + psi%a(1) * (-e21s+b12 ))
tpsi%a(3) = 2*gr * ( psi%a(3) * be3s + psi%a(4) * (-e21 +b12s))
tpsi%a(4) = 2*gr * ( - psi%a(4) * be3s + psi%a(3) * ( e21s+b12 ))
end function f_tvaf
@
<<Implementation of bispinor currents>>=
pure function f_tlrf (gl, gr, t, psi) result (tpsi)
type(bispinor) :: tpsi
complex(kind=default), intent(in) :: gl, gr
type(tensor2odd), intent(in) :: t
type(bispinor), intent(in) :: psi
tpsi = f_tvaf (gr+gl, gr-gl, t, psi)
end function f_tlrf
@
<<Implementation of bispinor currents>>=
pure function f_tvamf (gv, ga, v, psi, k) result (vpsi)
type(bispinor) :: vpsi
complex(kind=default), intent(in) :: gv, ga
type(vector), intent(in) :: v
type(bispinor), intent(in) :: psi
type(momentum), intent(in) :: k
type(tensor2odd) :: t
t = (v.wedge.k) * (0, 0.5)
vpsi = f_tvaf(gv, ga, t, psi)
end function f_tvamf
@
<<Implementation of bispinor currents>>=
pure function f_tlrmf (gl, gr, v, psi, k) result (vpsi)
type(bispinor) :: vpsi
complex(kind=default), intent(in) :: gl, gr
type(vector), intent(in) :: v
type(bispinor), intent(in) :: psi
type(momentum), intent(in) :: k
vpsi = f_tvamf (gr+gl, gr-gl, v, psi, k)
end function f_tlrmf
@ \subsection{Fermionic Scalar and Pseudo Scalar Couplings}
<<Declaration of bispinor currents>>=
public :: sp_ff, s_ff, p_ff, sl_ff, sr_ff, slr_ff
@
<<Implementation of bispinor currents>>=
pure function sp_ff (gs, gp, psil, psir) result (j)
complex(kind=default) :: j
complex(kind=default), intent(in) :: gs, gp
type(bispinor), intent(in) :: psil, psir
j = (gs - gp) * (psil%a(1)*psir%a(2) - psil%a(2)*psir%a(1)) &
+ (gs + gp) * (- psil%a(3)*psir%a(4) + psil%a(4)*psir%a(3))
end function sp_ff
@
<<Implementation of bispinor currents>>=
pure function s_ff (gs, psil, psir) result (j)
complex(kind=default) :: j
complex(kind=default), intent(in) :: gs
type(bispinor), intent(in) :: psil, psir
j = gs * (psil * psir)
end function s_ff
@
<<Implementation of bispinor currents>>=
pure function p_ff (gp, psil, psir) result (j)
complex(kind=default) :: j
complex(kind=default), intent(in) :: gp
type(bispinor), intent(in) :: psil, psir
j = gp * (- psil%a(1)*psir%a(2) + psil%a(2)*psir%a(1) &
- psil%a(3)*psir%a(4) + psil%a(4)*psir%a(3))
end function p_ff
@
<<Implementation of bispinor currents>>=
pure function sl_ff (gl, psil, psir) result (j)
complex(kind=default) :: j
complex(kind=default), intent(in) :: gl
type(bispinor), intent(in) :: psil, psir
j = 2 * gl * (psil%a(1)*psir%a(2) - psil%a(2)*psir%a(1))
end function sl_ff
@
<<Implementation of bispinor currents>>=
pure function sr_ff (gr, psil, psir) result (j)
complex(kind=default) :: j
complex(kind=default), intent(in) :: gr
type(bispinor), intent(in) :: psil, psir
j = 2 * gr * (- psil%a(3)*psir%a(4) + psil%a(4)*psir%a(3))
end function sr_ff
@
<<Implementation of bispinor currents>>=
pure function slr_ff (gl, gr, psibar, psi) result (j)
complex(kind=default) :: j
complex(kind=default), intent(in) :: gl, gr
type(bispinor), intent(in) :: psibar
type(bispinor), intent(in) :: psi
j = sp_ff (gr+gl, gr-gl, psibar, psi)
end function slr_ff
@
<<Declaration of bispinor currents>>=
public :: f_spf, f_sf, f_pf, f_slf, f_srf, f_slrf
@
<<Implementation of bispinor currents>>=
pure function f_spf (gs, gp, phi, psi) result (phipsi)
type(bispinor) :: phipsi
complex(kind=default), intent(in) :: gs, gp
complex(kind=default), intent(in) :: phi
type(bispinor), intent(in) :: psi
phipsi%a(1:2) = ((gs - gp) * phi) * psi%a(1:2)
phipsi%a(3:4) = ((gs + gp) * phi) * psi%a(3:4)
end function f_spf
@
<<Implementation of bispinor currents>>=
pure function f_sf (gs, phi, psi) result (phipsi)
type(bispinor) :: phipsi
complex(kind=default), intent(in) :: gs
complex(kind=default), intent(in) :: phi
type(bispinor), intent(in) :: psi
phipsi%a = (gs * phi) * psi%a
end function f_sf
@
<<Implementation of bispinor currents>>=
pure function f_pf (gp, phi, psi) result (phipsi)
type(bispinor) :: phipsi
complex(kind=default), intent(in) :: gp
complex(kind=default), intent(in) :: phi
type(bispinor), intent(in) :: psi
phipsi%a(1:2) = (- gp * phi) * psi%a(1:2)
phipsi%a(3:4) = ( gp * phi) * psi%a(3:4)
end function f_pf
@
<<Implementation of bispinor currents>>=
pure function f_slf (gl, phi, psi) result (phipsi)
type(bispinor) :: phipsi
complex(kind=default), intent(in) :: gl
complex(kind=default), intent(in) :: phi
type(bispinor), intent(in) :: psi
phipsi%a(1:2) = (2 * gl * phi) * psi%a(1:2)
phipsi%a(3:4) = 0
end function f_slf
@
<<Implementation of bispinor currents>>=
pure function f_srf (gr, phi, psi) result (phipsi)
type(bispinor) :: phipsi
complex(kind=default), intent(in) :: gr
complex(kind=default), intent(in) :: phi
type(bispinor), intent(in) :: psi
phipsi%a(1:2) = 0
phipsi%a(3:4) = (2 * gr * phi) * psi%a(3:4)
end function f_srf
@
<<Implementation of bispinor currents>>=
pure function f_slrf (gl, gr, phi, psi) result (phipsi)
type(bispinor) :: phipsi
complex(kind=default), intent(in) :: gl, gr
complex(kind=default), intent(in) :: phi
type(bispinor), intent(in) :: psi
phipsi = f_spf (gr+gl, gr-gl, phi, psi)
end function f_slrf
@ \subsection{Couplings for BRST Transformations}
\subsubsection{3-Couplings}
The lists of needed gamma matrices can be found in the next subsection with
the gravitino couplings.
<<Declaration of bispinor currents>>=
private :: vv_ff, f_vvf
@
<<Declaration of bispinor currents>>=
public :: vmom_ff, mom_ff, mom5_ff, moml_ff, momr_ff, lmom_ff, rmom_ff
@
<<Implementation of bispinor currents>>=
pure function vv_ff (psibar, psi, k) result (psibarpsi)
type(vector) :: psibarpsi
type(bispinor), intent(in) :: psibar, psi
type(vector), intent(in) :: k
complex(kind=default) :: kp, km, k12, k12s
type(bispinor) :: kgpsi1, kgpsi2, kgpsi3, kgpsi4
kp = k%t + k%x(3)
km = k%t - k%x(3)
k12 = k%x(1) + (0,1)*k%x(2)
k12s = k%x(1) - (0,1)*k%x(2)
kgpsi1%a(1) = -k%x(3) * psi%a(1) - k12s * psi%a(2)
kgpsi1%a(2) = -k12 * psi%a(1) + k%x(3) * psi%a(2)
kgpsi1%a(3) = k%x(3) * psi%a(3) + k12s * psi%a(4)
kgpsi1%a(4) = k12 * psi%a(3) - k%x(3) * psi%a(4)
kgpsi2%a(1) = ((0,-1) * k%x(2)) * psi%a(1) - km * psi%a(2)
kgpsi2%a(2) = - kp * psi%a(1) + ((0,1) * k%x(2)) * psi%a(2)
kgpsi2%a(3) = ((0,-1) * k%x(2)) * psi%a(3) + kp * psi%a(4)
kgpsi2%a(4) = km * psi%a(3) + ((0,1) * k%x(2)) * psi%a(4)
kgpsi3%a(1) = (0,1) * (k%x(1) * psi%a(1) + km * psi%a(2))
kgpsi3%a(2) = (0,-1) * (kp * psi%a(1) + k%x(1) * psi%a(2))
kgpsi3%a(3) = (0,1) * (k%x(1) * psi%a(3) - kp * psi%a(4))
kgpsi3%a(4) = (0,1) * (km * psi%a(3) - k%x(1) * psi%a(4))
kgpsi4%a(1) = -k%t * psi%a(1) - k12s * psi%a(2)
kgpsi4%a(2) = k12 * psi%a(1) + k%t * psi%a(2)
kgpsi4%a(3) = k%t * psi%a(3) - k12s * psi%a(4)
kgpsi4%a(4) = k12 * psi%a(3) - k%t * psi%a(4)
psibarpsi%t = 2 * (psibar * kgpsi1)
psibarpsi%x(1) = 2 * (psibar * kgpsi2)
psibarpsi%x(2) = 2 * (psibar * kgpsi3)
psibarpsi%x(3) = 2 * (psibar * kgpsi4)
end function vv_ff
@
<<Implementation of bispinor currents>>=
pure function f_vvf (v, psi, k) result (kvpsi)
type(bispinor) :: kvpsi
type(bispinor), intent(in) :: psi
type(vector), intent(in) :: k, v
complex(kind=default) :: kv30, kv21, kv01, kv31, kv02, kv32
complex(kind=default) :: ap, am, bp, bm, bps, bms
kv30 = k%x(3) * v%t - k%t * v%x(3)
kv21 = (0,1) * (k%x(2) * v%x(1) - k%x(1) * v%x(2))
kv01 = k%t * v%x(1) - k%x(1) * v%t
kv31 = k%x(3) * v%x(1) - k%x(1) * v%x(3)
kv02 = (0,1) * (k%t * v%x(2) - k%x(2) * v%t)
kv32 = (0,1) * (k%x(3) * v%x(2) - k%x(2) * v%x(3))
ap = 2 * (kv30 + kv21)
am = 2 * (-kv30 + kv21)
bp = 2 * (kv01 + kv31 + kv02 + kv32)
bm = 2 * (kv01 - kv31 + kv02 - kv32)
bps = 2 * (kv01 + kv31 - kv02 - kv32)
bms = 2 * (kv01 - kv31 - kv02 + kv32)
kvpsi%a(1) = am * psi%a(1) + bms * psi%a(2)
kvpsi%a(2) = bp * psi%a(1) - am * psi%a(2)
kvpsi%a(3) = ap * psi%a(3) - bps * psi%a(4)
kvpsi%a(4) = -bm * psi%a(3) - ap * psi%a(4)
end function f_vvf
@
<<Implementation of bispinor currents>>=
pure function vmom_ff (g, psibar, psi, k) result (psibarpsi)
type(vector) :: psibarpsi
complex(kind=default), intent(in) :: g
type(bispinor), intent(in) :: psibar, psi
type(momentum), intent(in) :: k
type(vector) :: vk
vk = k
psibarpsi = g * vv_ff (psibar, psi, vk)
end function vmom_ff
@
<<Implementation of bispinor currents>>=
pure function mom_ff (g, m, psibar, psi, k) result (psibarpsi)
complex(kind=default) :: psibarpsi
type(bispinor), intent(in) :: psibar, psi
type(momentum), intent(in) :: k
complex(kind=default), intent(in) :: g, m
type(bispinor) :: kmpsi
complex(kind=default) :: kp, km, k12, k12s
kp = k%t + k%x(3)
km = k%t - k%x(3)
k12 = k%x(1) + (0,1)*k%x(2)
k12s = k%x(1) - (0,1)*k%x(2)
kmpsi%a(1) = km * psi%a(3) - k12s * psi%a(4)
kmpsi%a(2) = kp * psi%a(4) - k12 * psi%a(3)
kmpsi%a(3) = kp * psi%a(1) + k12s * psi%a(2)
kmpsi%a(4) = k12 * psi%a(1) + km * psi%a(2)
psibarpsi = g * (psibar * kmpsi) + s_ff (m, psibar, psi)
end function mom_ff
@
<<Implementation of bispinor currents>>=
pure function mom5_ff (g, m, psibar, psi, k) result (psibarpsi)
complex(kind=default) :: psibarpsi
type(bispinor), intent(in) :: psibar, psi
type(momentum), intent(in) :: k
complex(kind=default), intent(in) :: g, m
type(bispinor) :: g5psi
g5psi%a(1:2) = - psi%a(1:2)
g5psi%a(3:4) = psi%a(3:4)
psibarpsi = mom_ff (g, m, psibar, g5psi, k)
end function mom5_ff
@
<<Implementation of bispinor currents>>=
pure function moml_ff (g, m, psibar, psi, k) result (psibarpsi)
complex(kind=default) :: psibarpsi
type(bispinor), intent(in) :: psibar, psi
type(momentum), intent(in) :: k
complex(kind=default), intent(in) :: g, m
type(bispinor) :: leftpsi
leftpsi%a(1:2) = 2 * psi%a(1:2)
leftpsi%a(3:4) = 0
psibarpsi = mom_ff (g, m, psibar, leftpsi, k)
end function moml_ff
@
<<Implementation of bispinor currents>>=
pure function momr_ff (g, m, psibar, psi, k) result (psibarpsi)
complex(kind=default) :: psibarpsi
type(bispinor), intent(in) :: psibar, psi
type(momentum), intent(in) :: k
complex(kind=default), intent(in) :: g, m
type(bispinor) :: rightpsi
rightpsi%a(1:2) = 0
rightpsi%a(3:4) = 2 * psi%a(3:4)
psibarpsi = mom_ff (g, m, psibar, rightpsi, k)
end function momr_ff
@
<<Implementation of bispinor currents>>=
pure function lmom_ff (g, m, psibar, psi, k) result (psibarpsi)
complex(kind=default) :: psibarpsi
type(bispinor), intent(in) :: psibar, psi
type(momentum), intent(in) :: k
complex(kind=default), intent(in) :: g, m
psibarpsi = mom_ff (g, m, psibar, psi, k) + &
mom5_ff (g,-m, psibar, psi, k)
end function lmom_ff
@
<<Implementation of bispinor currents>>=
pure function rmom_ff (g, m, psibar, psi, k) result (psibarpsi)
complex(kind=default) :: psibarpsi
type(bispinor), intent(in) :: psibar, psi
type(momentum), intent(in) :: k
complex(kind=default), intent(in) :: g, m
psibarpsi = mom_ff (g, m, psibar, psi, k) - &
mom5_ff (g,-m, psibar, psi, k)
end function rmom_ff
@
<<Declaration of bispinor currents>>=
public :: f_vmomf, f_momf, f_mom5f, f_momlf, f_momrf, f_lmomf, f_rmomf
@
<<Implementation of bispinor currents>>=
pure function f_vmomf (g, v, psi, k) result (kvpsi)
type(bispinor) :: kvpsi
type(bispinor), intent(in) :: psi
complex(kind=default), intent(in) :: g
type(momentum), intent(in) :: k
type(vector), intent(in) :: v
type(vector) :: vk
vk = k
kvpsi = g * f_vvf (v, psi, vk)
end function f_vmomf
@
<<Implementation of bispinor currents>>=
pure function f_momf (g, m, phi, psi, k) result (kmpsi)
type(bispinor) :: kmpsi
type(bispinor), intent(in) :: psi
complex(kind=default), intent(in) :: phi, g, m
type(momentum), intent(in) :: k
complex(kind=default) :: kp, km, k12, k12s
kp = k%t + k%x(3)
km = k%t - k%x(3)
k12 = k%x(1) + (0,1)*k%x(2)
k12s = k%x(1) - (0,1)*k%x(2)
kmpsi%a(1) = km * psi%a(3) - k12s * psi%a(4)
kmpsi%a(2) = -k12 * psi%a(3) + kp * psi%a(4)
kmpsi%a(3) = kp * psi%a(1) + k12s * psi%a(2)
kmpsi%a(4) = k12 * psi%a(1) + km * psi%a(2)
kmpsi = g * (phi * kmpsi) + f_sf (m, phi, psi)
end function f_momf
@
<<Implementation of bispinor currents>>=
pure function f_mom5f (g, m, phi, psi, k) result (kmpsi)
type(bispinor) :: kmpsi
type(bispinor), intent(in) :: psi
complex(kind=default), intent(in) :: phi, g, m
type(momentum), intent(in) :: k
type(bispinor) :: g5psi
g5psi%a(1:2) = - psi%a(1:2)
g5psi%a(3:4) = psi%a(3:4)
kmpsi = f_momf (g, m, phi, g5psi, k)
end function f_mom5f
@
<<Implementation of bispinor currents>>=
pure function f_momlf (g, m, phi, psi, k) result (kmpsi)
type(bispinor) :: kmpsi
type(bispinor), intent(in) :: psi
complex(kind=default), intent(in) :: phi, g, m
type(momentum), intent(in) :: k
type(bispinor) :: leftpsi
leftpsi%a(1:2) = 2 * psi%a(1:2)
leftpsi%a(3:4) = 0
kmpsi = f_momf (g, m, phi, leftpsi, k)
end function f_momlf
@
<<Implementation of bispinor currents>>=
pure function f_momrf (g, m, phi, psi, k) result (kmpsi)
type(bispinor) :: kmpsi
type(bispinor), intent(in) :: psi
complex(kind=default), intent(in) :: phi, g, m
type(momentum), intent(in) :: k
type(bispinor) :: rightpsi
rightpsi%a(1:2) = 0
rightpsi%a(3:4) = 2 * psi%a(3:4)
kmpsi = f_momf (g, m, phi, rightpsi, k)
end function f_momrf
@
<<Implementation of bispinor currents>>=
pure function f_lmomf (g, m, phi, psi, k) result (kmpsi)
type(bispinor) :: kmpsi
type(bispinor), intent(in) :: psi
complex(kind=default), intent(in) :: phi, g, m
type(momentum), intent(in) :: k
kmpsi = f_momf (g, m, phi, psi, k) + &
f_mom5f (g,-m, phi, psi, k)
end function f_lmomf
@
<<Implementation of bispinor currents>>=
pure function f_rmomf (g, m, phi, psi, k) result (kmpsi)
type(bispinor) :: kmpsi
type(bispinor), intent(in) :: psi
complex(kind=default), intent(in) :: phi, g, m
type(momentum), intent(in) :: k
kmpsi = f_momf (g, m, phi, psi, k) - &
f_mom5f (g,-m, phi, psi, k)
end function f_rmomf
@
\subsubsection{4-Couplings}
<<Declaration of bispinor currents>>=
public :: v2_ff, sv1_ff, sv2_ff, pv1_ff, pv2_ff, svl1_ff, svl2_ff, &
svr1_ff, svr2_ff, svlr1_ff, svlr2_ff
@
<<Implementation of bispinor currents>>=
pure function v2_ff (g, psibar, v, psi) result (v2)
type(vector) :: v2
complex (kind=default), intent(in) :: g
type(bispinor), intent(in) :: psibar, psi
type(vector), intent(in) :: v
v2 = (-g) * vv_ff (psibar, psi, v)
end function v2_ff
@
<<Implementation of bispinor currents>>=
pure function sv1_ff (g, psibar, v, psi) result (phi)
complex(kind=default) :: phi
type(bispinor), intent(in) :: psibar, psi
type(vector), intent(in) :: v
complex(kind=default), intent(in) :: g
phi = psibar * f_vf (g, v, psi)
end function sv1_ff
@
<<Implementation of bispinor currents>>=
pure function sv2_ff (g, psibar, phi, psi) result (v)
type(vector) :: v
complex(kind=default), intent(in) :: phi, g
type(bispinor), intent(in) :: psibar, psi
v = phi * v_ff (g, psibar, psi)
end function sv2_ff
@
<<Implementation of bispinor currents>>=
pure function pv1_ff (g, psibar, v, psi) result (phi)
complex(kind=default) :: phi
type(bispinor), intent(in) :: psibar, psi
type(vector), intent(in) :: v
complex(kind=default), intent(in) :: g
phi = - (psibar * f_af (g, v, psi))
end function pv1_ff
@
<<Implementation of bispinor currents>>=
pure function pv2_ff (g, psibar, phi, psi) result (v)
type(vector) :: v
complex(kind=default), intent(in) :: phi, g
type(bispinor), intent(in) :: psibar, psi
v = -(phi * a_ff (g, psibar, psi))
end function pv2_ff
@
<<Implementation of bispinor currents>>=
pure function svl1_ff (g, psibar, v, psi) result (phi)
complex(kind=default) :: phi
type(bispinor), intent(in) :: psibar, psi
type(vector), intent(in) :: v
complex(kind=default), intent(in) :: g
phi = psibar * f_vlf (g, v, psi)
end function svl1_ff
@
<<Implementation of bispinor currents>>=
pure function svl2_ff (g, psibar, phi, psi) result (v)
type(vector) :: v
complex(kind=default), intent(in) :: phi, g
type(bispinor), intent(in) :: psibar, psi
v = phi * vl_ff (g, psibar, psi)
end function svl2_ff
@
<<Implementation of bispinor currents>>=
pure function svr1_ff (g, psibar, v, psi) result (phi)
complex(kind=default) :: phi
type(bispinor), intent(in) :: psibar, psi
type(vector), intent(in) :: v
complex(kind=default), intent(in) :: g
phi = psibar * f_vrf (g, v, psi)
end function svr1_ff
@
<<Implementation of bispinor currents>>=
pure function svr2_ff (g, psibar, phi, psi) result (v)
type(vector) :: v
complex(kind=default), intent(in) :: phi, g
type(bispinor), intent(in) :: psibar, psi
v = phi * vr_ff (g, psibar, psi)
end function svr2_ff
@
<<Implementation of bispinor currents>>=
pure function svlr1_ff (gl, gr, psibar, v, psi) result (phi)
complex(kind=default) :: phi
type(bispinor), intent(in) :: psibar, psi
type(vector), intent(in) :: v
complex(kind=default), intent(in) :: gl, gr
phi = psibar * f_vlrf (gl, gr, v, psi)
end function svlr1_ff
@
<<Implementation of bispinor currents>>=
pure function svlr2_ff (gl, gr, psibar, phi, psi) result (v)
type(vector) :: v
complex(kind=default), intent(in) :: phi, gl, gr
type(bispinor), intent(in) :: psibar, psi
v = phi * vlr_ff (gl, gr, psibar, psi)
end function svlr2_ff
@
<<Declaration of bispinor currents>>=
public :: f_v2f, f_svf, f_pvf, f_svlf, f_svrf, f_svlrf
@
<<Implementation of bispinor currents>>=
pure function f_v2f (g, v1, v2, psi) result (vpsi)
type(bispinor) :: vpsi
complex(kind=default), intent(in) :: g
type(bispinor), intent(in) :: psi
type(vector), intent(in) :: v1, v2
vpsi = g * f_vvf (v2, psi, v1)
end function f_v2f
@
<<Implementation of bispinor currents>>=
pure function f_svf (g, phi, v, psi) result (pvpsi)
type(bispinor) :: pvpsi
complex(kind=default), intent(in) :: g, phi
type(bispinor), intent(in) :: psi
type(vector), intent(in) :: v
pvpsi = phi * f_vf (g, v, psi)
end function f_svf
@
<<Implementation of bispinor currents>>=
pure function f_pvf (g, phi, v, psi) result (pvpsi)
type(bispinor) :: pvpsi
complex(kind=default), intent(in) :: g, phi
type(bispinor), intent(in) :: psi
type(vector), intent(in) :: v
pvpsi = -(phi * f_af (g, v, psi))
end function f_pvf
@
<<Implementation of bispinor currents>>=
pure function f_svlf (g, phi, v, psi) result (pvpsi)
type(bispinor) :: pvpsi
complex(kind=default), intent(in) :: g, phi
type(bispinor), intent(in) :: psi
type(vector), intent(in) :: v
pvpsi = phi * f_vlf (g, v, psi)
end function f_svlf
@
<<Implementation of bispinor currents>>=
pure function f_svrf (g, phi, v, psi) result (pvpsi)
type(bispinor) :: pvpsi
complex(kind=default), intent(in) :: g, phi
type(bispinor), intent(in) :: psi
type(vector), intent(in) :: v
pvpsi = phi * f_vrf (g, v, psi)
end function f_svrf
@
<<Implementation of bispinor currents>>=
pure function f_svlrf (gl, gr, phi, v, psi) result (pvpsi)
type(bispinor) :: pvpsi
complex(kind=default), intent(in) :: gl, gr, phi
type(bispinor), intent(in) :: psi
type(vector), intent(in) :: v
pvpsi = phi * f_vlrf (gl, gr, v, psi)
end function f_svlrf
@ \subsection{Gravitino Couplings}
<<Declaration of bispinor currents>>=
public :: pot_grf, pot_fgr, s_grf, s_fgr, p_grf, p_fgr, &
sl_grf, sl_fgr, sr_grf, sr_fgr, slr_grf, slr_fgr
@
<<Declaration of bispinor currents>>=
private :: fgvgr, fgvg5gr, fggvvgr, grkgf, grkggf, grkkggf, &
fgkgr, fg5gkgr, grvgf, grg5vgf, grkgggf, fggkggr
@
<<Implementation of bispinor currents>>=
pure function pot_grf (g, gravbar, psi) result (j)
complex(kind=default) :: j
complex(kind=default), intent(in) :: g
type(vectorspinor), intent(in) :: gravbar
type(bispinor), intent(in) :: psi
type(vectorspinor) :: gamma_psi
gamma_psi%psi(1)%a(1) = psi%a(3)
gamma_psi%psi(1)%a(2) = psi%a(4)
gamma_psi%psi(1)%a(3) = psi%a(1)
gamma_psi%psi(1)%a(4) = psi%a(2)
gamma_psi%psi(2)%a(1) = psi%a(4)
gamma_psi%psi(2)%a(2) = psi%a(3)
gamma_psi%psi(2)%a(3) = - psi%a(2)
gamma_psi%psi(2)%a(4) = - psi%a(1)
gamma_psi%psi(3)%a(1) = (0,-1) * psi%a(4)
gamma_psi%psi(3)%a(2) = (0,1) * psi%a(3)
gamma_psi%psi(3)%a(3) = (0,1) * psi%a(2)
gamma_psi%psi(3)%a(4) = (0,-1) * psi%a(1)
gamma_psi%psi(4)%a(1) = psi%a(3)
gamma_psi%psi(4)%a(2) = - psi%a(4)
gamma_psi%psi(4)%a(3) = - psi%a(1)
gamma_psi%psi(4)%a(4) = psi%a(2)
j = g * (gravbar * gamma_psi)
end function pot_grf
@
<<Implementation of bispinor currents>>=
pure function pot_fgr (g, psibar, grav) result (j)
complex(kind=default) :: j
complex(kind=default), intent(in) :: g
type(bispinor), intent(in) :: psibar
type(vectorspinor), intent(in) :: grav
type(bispinor) :: gamma_grav
gamma_grav%a(1) = grav%psi(1)%a(3) - grav%psi(2)%a(4) + &
((0,1)*grav%psi(3)%a(4)) - grav%psi(4)%a(3)
gamma_grav%a(2) = grav%psi(1)%a(4) - grav%psi(2)%a(3) - &
((0,1)*grav%psi(3)%a(3)) + grav%psi(4)%a(4)
gamma_grav%a(3) = grav%psi(1)%a(1) + grav%psi(2)%a(2) - &
((0,1)*grav%psi(3)%a(2)) + grav%psi(4)%a(1)
gamma_grav%a(4) = grav%psi(1)%a(2) + grav%psi(2)%a(1) + &
((0,1)*grav%psi(3)%a(1)) - grav%psi(4)%a(2)
j = g * (psibar * gamma_grav)
end function pot_fgr
@
<<Implementation of bispinor currents>>=
pure function grvgf (gravbar, psi, k) result (j)
complex(kind=default) :: j
complex(kind=default) :: kp, km, k12, k12s
type(vectorspinor), intent(in) :: gravbar
type(bispinor), intent(in) :: psi
type(vector), intent(in) :: k
type(vectorspinor) :: kg_psi
kp = k%t + k%x(3)
km = k%t - k%x(3)
k12 = k%x(1) + (0,1)*k%x(2)
k12s = k%x(1) - (0,1)*k%x(2)
!!! Since we are taking the spinor product here, NO explicit
!!! charge conjugation matrix is needed!
kg_psi%psi(1)%a(1) = km * psi%a(1) - k12s * psi%a(2)
kg_psi%psi(1)%a(2) = (-k12) * psi%a(1) + kp * psi%a(2)
kg_psi%psi(1)%a(3) = kp * psi%a(3) + k12s * psi%a(4)
kg_psi%psi(1)%a(4) = k12 * psi%a(3) + km * psi%a(4)
kg_psi%psi(2)%a(1) = k12s * psi%a(1) - km * psi%a(2)
kg_psi%psi(2)%a(2) = (-kp) * psi%a(1) + k12 * psi%a(2)
kg_psi%psi(2)%a(3) = k12s * psi%a(3) + kp * psi%a(4)
kg_psi%psi(2)%a(4) = km * psi%a(3) + k12 * psi%a(4)
kg_psi%psi(3)%a(1) = (0,1) * (k12s * psi%a(1) + km * psi%a(2))
kg_psi%psi(3)%a(2) = (0,1) * (- kp * psi%a(1) - k12 * psi%a(2))
kg_psi%psi(3)%a(3) = (0,1) * (k12s * psi%a(3) - kp * psi%a(4))
kg_psi%psi(3)%a(4) = (0,1) * (km * psi%a(3) - k12 * psi%a(4))
kg_psi%psi(4)%a(1) = (-km) * psi%a(1) - k12s * psi%a(2)
kg_psi%psi(4)%a(2) = k12 * psi%a(1) + kp * psi%a(2)
kg_psi%psi(4)%a(3) = kp * psi%a(3) - k12s * psi%a(4)
kg_psi%psi(4)%a(4) = k12 * psi%a(3) - km * psi%a(4)
j = gravbar * kg_psi
end function grvgf
@
<<Implementation of bispinor currents>>=
pure function grg5vgf (gravbar, psi, k) result (j)
complex(kind=default) :: j
type(vectorspinor), intent(in) :: gravbar
type(bispinor), intent(in) :: psi
type(vector), intent(in) :: k
type(bispinor) :: g5_psi
g5_psi%a(1:2) = - psi%a(1:2)
g5_psi%a(3:4) = psi%a(3:4)
j = grvgf (gravbar, g5_psi, k)
end function grg5vgf
@
<<Implementation of bispinor currents>>=
pure function s_grf (g, gravbar, psi, k) result (j)
complex(kind=default) :: j
complex(kind=default), intent(in) :: g
type(vectorspinor), intent(in) :: gravbar
type(bispinor), intent(in) :: psi
type(momentum), intent(in) :: k
type(vector) :: vk
vk = k
j = g * grvgf (gravbar, psi, vk)
end function s_grf
@
<<Implementation of bispinor currents>>=
pure function sl_grf (gl, gravbar, psi, k) result (j)
complex(kind=default) :: j
complex(kind=default), intent(in) :: gl
type(vectorspinor), intent(in) :: gravbar
type(bispinor), intent(in) :: psi
type(bispinor) :: psi_l
type(momentum), intent(in) :: k
psi_l%a(1:2) = psi%a(1:2)
psi_l%a(3:4) = 0
j = s_grf (gl, gravbar, psi_l, k)
end function sl_grf
@
<<Implementation of bispinor currents>>=
pure function sr_grf (gr, gravbar, psi, k) result (j)
complex(kind=default) :: j
complex(kind=default), intent(in) :: gr
type(vectorspinor), intent(in) :: gravbar
type(bispinor), intent(in) :: psi
type(bispinor) :: psi_r
type(momentum), intent(in) :: k
psi_r%a(1:2) = 0
psi_r%a(3:4) = psi%a(3:4)
j = s_grf (gr, gravbar, psi_r, k)
end function sr_grf
@
<<Implementation of bispinor currents>>=
pure function slr_grf (gl, gr, gravbar, psi, k) result (j)
complex(kind=default) :: j
complex(kind=default), intent(in) :: gl, gr
type(vectorspinor), intent(in) :: gravbar
type(bispinor), intent(in) :: psi
type(momentum), intent(in) :: k
j = sl_grf (gl, gravbar, psi, k) + sr_grf (gr, gravbar, psi, k)
end function slr_grf
@
<<Implementation of bispinor currents>>=
pure function fgkgr (psibar, grav, k) result (j)
complex(kind=default) :: j
complex(kind=default) :: kp, km, k12, k12s
type(bispinor), intent(in) :: psibar
type(vectorspinor), intent(in) :: grav
type(vector), intent(in) :: k
type(bispinor) :: gk_grav
kp = k%t + k%x(3)
km = k%t - k%x(3)
k12 = k%x(1) + (0,1)*k%x(2)
k12s = k%x(1) - (0,1)*k%x(2)
!!! Since we are taking the spinor product here, NO explicit
!!! charge conjugation matrix is needed!
gk_grav%a(1) = kp * grav%psi(1)%a(1) + k12s * grav%psi(1)%a(2) &
- k12 * grav%psi(2)%a(1) - km * grav%psi(2)%a(2) &
+ (0,1) * k12 * grav%psi(3)%a(1) &
+ (0,1) * km * grav%psi(3)%a(2) &
- kp * grav%psi(4)%a(1) - k12s * grav%psi(4)%a(2)
gk_grav%a(2) = k12 * grav%psi(1)%a(1) + km * grav%psi(1)%a(2) &
- kp * grav%psi(2)%a(1) - k12s * grav%psi(2)%a(2) &
- (0,1) * kp * grav%psi(3)%a(1) &
- (0,1) * k12s * grav%psi(3)%a(2) &
+ k12 * grav%psi(4)%a(1) + km * grav%psi(4)%a(2)
gk_grav%a(3) = km * grav%psi(1)%a(3) - k12s * grav%psi(1)%a(4) &
- k12 * grav%psi(2)%a(3) + kp * grav%psi(2)%a(4) &
+ (0,1) * k12 * grav%psi(3)%a(3) &
- (0,1) * kp * grav%psi(3)%a(4) &
+ km * grav%psi(4)%a(3) - k12s * grav%psi(4)%a(4)
gk_grav%a(4) = - k12 * grav%psi(1)%a(3) + kp * grav%psi(1)%a(4) &
+ km * grav%psi(2)%a(3) - k12s * grav%psi(2)%a(4) &
+ (0,1) * km * grav%psi(3)%a(3) &
- (0,1) * k12s * grav%psi(3)%a(4) &
+ k12 * grav%psi(4)%a(3) - kp * grav%psi(4)%a(4)
j = psibar * gk_grav
end function fgkgr
@
<<Implementation of bispinor currents>>=
pure function fg5gkgr (psibar, grav, k) result (j)
complex(kind=default) :: j
type(bispinor), intent(in) :: psibar
type(vectorspinor), intent(in) :: grav
type(vector), intent(in) :: k
type(bispinor) :: psibar_g5
psibar_g5%a(1:2) = - psibar%a(1:2)
psibar_g5%a(3:4) = psibar%a(3:4)
j = fgkgr (psibar_g5, grav, k)
end function fg5gkgr
@
<<Implementation of bispinor currents>>=
pure function s_fgr (g, psibar, grav, k) result (j)
complex(kind=default) :: j
complex(kind=default), intent(in) :: g
type(bispinor), intent(in) :: psibar
type(vectorspinor), intent(in) :: grav
type(momentum), intent(in) :: k
type(vector) :: vk
vk = k
j = g * fgkgr (psibar, grav, vk)
end function s_fgr
@
<<Implementation of bispinor currents>>=
pure function sl_fgr (gl, psibar, grav, k) result (j)
complex(kind=default) :: j
complex(kind=default), intent(in) :: gl
type(bispinor), intent(in) :: psibar
type(bispinor) :: psibar_l
type(vectorspinor), intent(in) :: grav
type(momentum), intent(in) :: k
psibar_l%a(1:2) = psibar%a(1:2)
psibar_l%a(3:4) = 0
j = s_fgr (gl, psibar_l, grav, k)
end function sl_fgr
@
<<Implementation of bispinor currents>>=
pure function sr_fgr (gr, psibar, grav, k) result (j)
complex(kind=default) :: j
complex(kind=default), intent(in) :: gr
type(bispinor), intent(in) :: psibar
type(bispinor) :: psibar_r
type(vectorspinor), intent(in) :: grav
type(momentum), intent(in) :: k
psibar_r%a(1:2) = 0
psibar_r%a(3:4) = psibar%a(3:4)
j = s_fgr (gr, psibar_r, grav, k)
end function sr_fgr
@
@
<<Implementation of bispinor currents>>=
pure function slr_fgr (gl, gr, psibar, grav, k) result (j)
complex(kind=default) :: j
complex(kind=default), intent(in) :: gl, gr
type(bispinor), intent(in) :: psibar
type(vectorspinor), intent(in) :: grav
type(momentum), intent(in) :: k
j = sl_fgr (gl, psibar, grav, k) + sr_fgr (gr, psibar, grav, k)
end function slr_fgr
@
<<Implementation of bispinor currents>>=
pure function p_grf (g, gravbar, psi, k) result (j)
complex(kind=default) :: j
complex(kind=default), intent(in) :: g
type(vectorspinor), intent(in) :: gravbar
type(bispinor), intent(in) :: psi
type(momentum), intent(in) :: k
type(vector) :: vk
vk = k
j = g * grg5vgf (gravbar, psi, vk)
end function p_grf
@
<<Implementation of bispinor currents>>=
pure function p_fgr (g, psibar, grav, k) result (j)
complex(kind=default) :: j
complex(kind=default), intent(in) :: g
type(bispinor), intent(in) :: psibar
type(vectorspinor), intent(in) :: grav
type(momentum), intent(in) :: k
type(vector) :: vk
vk = k
j = g * fg5gkgr (psibar, grav, vk)
end function p_fgr
@
<<Declaration of bispinor currents>>=
public :: f_potgr, f_sgr, f_pgr, f_vgr, f_vlrgr, f_slgr, f_srgr, f_slrgr
@
<<Implementation of bispinor currents>>=
pure function f_potgr (g, phi, psi) result (phipsi)
type(bispinor) :: phipsi
complex(kind=default), intent(in) :: g
complex(kind=default), intent(in) :: phi
type(vectorspinor), intent(in) :: psi
phipsi%a(1) = (g * phi) * (psi%psi(1)%a(3) - psi%psi(2)%a(4) + &
((0,1)*psi%psi(3)%a(4)) - psi%psi(4)%a(3))
phipsi%a(2) = (g * phi) * (psi%psi(1)%a(4) - psi%psi(2)%a(3) - &
((0,1)*psi%psi(3)%a(3)) + psi%psi(4)%a(4))
phipsi%a(3) = (g * phi) * (psi%psi(1)%a(1) + psi%psi(2)%a(2) - &
((0,1)*psi%psi(3)%a(2)) + psi%psi(4)%a(1))
phipsi%a(4) = (g * phi) * (psi%psi(1)%a(2) + psi%psi(2)%a(1) + &
((0,1)*psi%psi(3)%a(1)) - psi%psi(4)%a(2))
end function f_potgr
@
The slashed notation:
\begin{equation}
\fmslash{k} =
\begin{pmatrix}
0 & 0 & k_- & - k^* \\
0 & 0 & - k & k_+ \\
k_+ & k^* & 0 & 0 \\
k & k_- & 0 & 0
\end{pmatrix} , \qquad
\fmslash{k}\gamma_5 =
\begin{pmatrix}
0 & 0 & k_- & - k^* \\
0 & 0 & - k & k_+ \\
- k_+ & - k^* & 0 & 0 \\
- k & - k_- & 0 & 0 \end{pmatrix}
\end{equation}
with $k_\pm=k_0\pm k_3$, $k=k_1+\ii k_2$,
$k^*=k_1-\ii k_2$. But note that~$\cdot^*$ is \emph{not} complex
conjugation for complex~$k_\mu$.
\begin{subequations}
\begin{alignat}{2}
\gamma^0 \fmslash{k} &=
\begin{pmatrix}
k_+ & k^* & 0 & 0 \\
k & k_- & 0 & 0 \\
0 & 0 & k_- & - k^* \\
0 & 0 & - k & k_+
\end{pmatrix} , & \qquad
\gamma^0 \fmslash{k} \gamma^5 & =
\begin{pmatrix}
- k_+ & - k^* & 0 & 0 \\
- k & - k_- & 0 & 0 \\
0 & 0 & k_- & - k^* \\
0 & 0 & - k & k_+
\end{pmatrix} \\
\gamma^1 \fmslash{k} &=
\begin{pmatrix}
k & k_- & 0 & 0 \\
k_+ & k^* & 0 & 0 \\
0 & 0 & k & - k_+ \\
0 & 0 & - k_- & k^*
\end{pmatrix}, & \qquad
\gamma^1 \fmslash{k} \gamma^5 & =
\begin{pmatrix}
- k & - k_- & 0 & 0 \\
- k_+ & - k^* & 0 & 0 \\
0 & 0 & k & - k_+ \\
0 & 0 & - k_- & k^*
\end{pmatrix} \\
\gamma^2 \fmslash{k} &=
\begin{pmatrix}
- \ii k & - \ii k_- & 0 & 0 \\
\ii k_+ & \ii k^* & 0 & 0 \\
0 & 0 & - \ii k & \ii k_+ \\
0 & 0 & - \ii k_- & \ii k^*
\end{pmatrix}, & \qquad
\gamma^2 \fmslash{k} \gamma^5 & =
\begin{pmatrix}
\ii k & \ii k_- & 0 & 0 \\
- \ii k_+ & - \ii k^* & 0 & 0 \\
0 & 0 & - \ii k & \ii k_+ \\
0 & 0 & - \ii k_- & \ii k^*
\end{pmatrix} \\
\gamma^3 \fmslash{k} &=
\begin{pmatrix}
k_+ & k^* & 0 & 0 \\
- k & - k_- & 0 & 0 \\
0 & 0 & - k_- & k^* \\
0 & 0 & - k & k_+
\end{pmatrix}, & \qquad
\gamma^3 \fmslash{k} \gamma^5 & =
\begin{pmatrix}
- k_+ & - k^* & 0 & 0 \\
k & k_- & 0 & 0 \\
0 & 0 & - k_- & k^* \\
0 & 0 & - k & k_+
\end{pmatrix}
\end{alignat}
\end{subequations}
and
\begin{subequations}
\begin{alignat}{2}
\fmslash{k} \gamma^0&=
\begin{pmatrix}
k_- & - k^* & 0 & 0 \\
- k & k_+ & 0 & 0 \\
0 & 0 & k_+ & k^* \\
0 & 0 & k & k_-
\end{pmatrix} , & \qquad
\fmslash{k} \gamma^0 \gamma^5 & =
\begin{pmatrix}
- k_- & k^* & 0 & 0 \\
k & - k_+ & 0 & 0 \\
0 & 0 & k_+ & k^* \\
0 & 0 & k & k_-
\end{pmatrix} \\
\fmslash{k} \gamma^1 &=
\begin{pmatrix}
k^* & - k_- & 0 & 0 \\
- k_+ & k & 0 & 0 \\
0 & 0 & k^* & k_+ \\
0 & 0 & k_- & k
\end{pmatrix}, & \qquad
\fmslash{k} \gamma^1 \gamma^5 & =
\begin{pmatrix}
- k^* & k_- & 0 & 0 \\
k_+ & - k & 0 & 0 \\
0 & 0 & k^* & k_+ \\
0 & 0 & k_- & k
\end{pmatrix} \\
\fmslash{k} \gamma^2 &=
\begin{pmatrix}
\ii k^* & \ii k_- & 0 & 0 \\
- \ii k_+ & - \ii k & 0 & 0 \\
0 & 0 & \ii k^* & - \ii k_+ \\
0 & 0 & \ii k_- & - \ii k
\end{pmatrix}, & \qquad
\fmslash{k} \gamma^2 \gamma^5 & =
\begin{pmatrix}
- \ii k^* & - \ii k_- & 0 & 0 \\
\ii k_+ & \ii k & 0 & 0 \\
0 & 0 & \ii k^* & - \ii k_+ \\
0 & 0 & \ii k_- & - \ii k
\end{pmatrix} \\
\fmslash{k} \gamma^3 &=
\begin{pmatrix}
- k_- & - k^* & 0 & 0 \\
k & k_+ & 0 & 0 \\
0 & 0 & k_+ & - k^* \\
0 & 0 & k & - k_-
\end{pmatrix}, & \qquad
\fmslash{k} \gamma^3 \gamma^5 & =
\begin{pmatrix}
k_- & k^* & 0 & 0 \\
- k & - k_+ & 0 & 0 \\
0 & 0 & k_+ & - k^* \\
0 & 0 & k & - k_-
\end{pmatrix}
\end{alignat}
\end{subequations}
and
\begin{subequations}
\begin{alignat}{2}
C \gamma^0 \fmslash{k} &=
\begin{pmatrix}
k & k_- & 0 & 0 \\
- k_+ & - k^* & 0 & 0 \\
0 & 0 & k & - k_+ \\
0 & 0 & k_- & - k^*
\end{pmatrix} , & \qquad
C \gamma^0 \fmslash{k} \gamma^5 & =
\begin{pmatrix}
- k & - k_- & 0 & 0 \\
k_+ & k^* & 0 & 0 \\
0 & 0 & k & - k_+ \\
0 & 0 & k_- & - k^*
\end{pmatrix} \\
C \gamma^1 \fmslash{k} &=
\begin{pmatrix}
k_+ & k^* & 0 & 0 \\
- k & - k_- & 0 & 0 \\
0 & 0 & k_- & - k^* \\
0 & 0 & k & - k_+
\end{pmatrix}, & \qquad
C \gamma^1 \fmslash{k} \gamma^5 & =
\begin{pmatrix}
- k_+ & - k^* & 0 & 0 \\
k & k_- & 0 & 0 \\
0 & 0 & k_- & - k^* \\
0 & 0 & k & - k_+
\end{pmatrix} \\
C \gamma^2 \fmslash{k} &=
\begin{pmatrix}
\ii k_+ & \ii k^* & 0 & 0 \\
\ii k & \ii k_- & 0 & 0 \\
0 & 0 & \ii k_- & - \ii k^* \\
0 & 0 & - \ii k & \ii k_+
\end{pmatrix}, & \qquad
C \gamma^2 \fmslash{k} \gamma^5 & =
\begin{pmatrix}
- \ii k_+ & - \ii k^* & 0 & 0 \\
- \ii k & - \ii k_- & 0 & 0 \\
0 & 0 & \ii k_- & - \ii k^* \\
0 & 0 & - \ii k & \ii k_+
\end{pmatrix} \\
C \gamma^3 \fmslash{k} &=
\begin{pmatrix}
- k & - k_- & 0 & 0 \\
- k_+ & - k^* & 0 & 0 \\
0 & 0 & k & - k_+ \\
0 & 0 & - k_- & k^*
\end{pmatrix}, & \qquad
C \gamma^3 \fmslash{k} \gamma^5 & =
\begin{pmatrix}
k & k_- & 0 & 0 \\
k_+ & k^* & 0 & 0 \\
0 & 0 & k & - k_+ \\
0 & 0 & - k_- & k^*
\end{pmatrix}
\end{alignat}
\end{subequations}
and
\begin{subequations}
\begin{alignat}{2}
C \fmslash{k} \gamma^0&=
\begin{pmatrix}
- k & k^+ & 0 & 0 \\
- k_- & k^* & 0 & 0 \\
0 & 0 & - k & - k_- \\
0 & 0 & k_+ & k^*
\end{pmatrix} , & \qquad
C \fmslash{k} \gamma^0 \gamma^5 & =
\begin{pmatrix}
k & - k_+ & 0 & 0 \\
k_- & - k^* & 0 & 0 \\
0 & 0 & - k & - k_- \\
0 & 0 & k_+ & k^*
\end{pmatrix} \\
C \fmslash{k} \gamma^1 &=
\begin{pmatrix}
- k_+ & k & 0 & 0 \\
- k^* & k_- & 0 & 0 \\
0 & 0 & - k_- & - k \\
0 & 0 & k^* & k_+
\end{pmatrix}, & \qquad
C \fmslash{k} \gamma^1 \gamma^5 & =
\begin{pmatrix}
k_+ & - k & 0 & 0 \\
k^* & - k_- & 0 & 0 \\
0 & 0 & - k_- & - k \\
0 & 0 & k^* & k_+
\end{pmatrix} \\
C \fmslash{k} \gamma^2 &=
\begin{pmatrix}
- \ii k_+ & - \ii k & 0 & 0 \\
- \ii k^* & - \ii k_- & 0 & 0 \\
0 & 0 & - \ii k_- & \ii k \\
0 & 0 & \ii k^* & - \ii k_+
\end{pmatrix}, & \qquad
C \fmslash{k} \gamma^2 \gamma^5 & =
\begin{pmatrix}
\ii k_+ & \ii k & 0 & 0 \\
\ii k^* & \ii k_- & 0 & 0 \\
0 & 0 & - \ii k_- & \ii k \\
0 & 0 & \ii k^* & - \ii k_+
\end{pmatrix} \\
C \fmslash{k} \gamma^3 &=
\begin{pmatrix}
k & k_+ & 0 & 0 \\
k_- & k^* & 0 & 0 \\
0 & 0 & - k & k_- \\
0 & 0 & k_+ & - k^*
\end{pmatrix}, & \qquad
C \fmslash{k} \gamma^3 \gamma^5 & =
\begin{pmatrix}
- k & - k_+ & 0 & 0 \\
- k_- & - k^* & 0 & 0 \\
0 & 0 & - k & k_- \\
0 & 0 & k_+ & - k^*
\end{pmatrix}
\end{alignat}
\end{subequations}
<<Implementation of bispinor currents>>=
pure function fgvgr (psi, k) result (kpsi)
type(bispinor) :: kpsi
complex(kind=default) :: kp, km, k12, k12s
type(vector), intent(in) :: k
type(vectorspinor), intent(in) :: psi
kp = k%t + k%x(3)
km = k%t - k%x(3)
k12 = k%x(1) + (0,1)*k%x(2)
k12s = k%x(1) - (0,1)*k%x(2)
kpsi%a(1) = kp * psi%psi(1)%a(1) + k12s * psi%psi(1)%a(2) &
- k12 * psi%psi(2)%a(1) - km * psi%psi(2)%a(2) &
+ (0,1) * k12 * psi%psi(3)%a(1) + (0,1) * km * psi%psi(3)%a(2) &
- kp * psi%psi(4)%a(1) - k12s * psi%psi(4)%a(2)
kpsi%a(2) = k12 * psi%psi(1)%a(1) + km * psi%psi(1)%a(2) &
- kp * psi%psi(2)%a(1) - k12s * psi%psi(2)%a(2) &
- (0,1) * kp * psi%psi(3)%a(1) - (0,1) * k12s * psi%psi(3)%a(2) &
+ k12 * psi%psi(4)%a(1) + km * psi%psi(4)%a(2)
kpsi%a(3) = km * psi%psi(1)%a(3) - k12s * psi%psi(1)%a(4) &
- k12 * psi%psi(2)%a(3) + kp * psi%psi(2)%a(4) &
+ (0,1) * k12 * psi%psi(3)%a(3) - (0,1) * kp * psi%psi(3)%a(4) &
+ km * psi%psi(4)%a(3) - k12s * psi%psi(4)%a(4)
kpsi%a(4) = - k12 * psi%psi(1)%a(3) + kp * psi%psi(1)%a(4) &
+ km * psi%psi(2)%a(3) - k12s * psi%psi(2)%a(4) &
+ (0,1) * km * psi%psi(3)%a(3) - (0,1) * k12s * psi%psi(3)%a(4) &
+ k12 * psi%psi(4)%a(3) - kp * psi%psi(4)%a(4)
end function fgvgr
@
<<Implementation of bispinor currents>>=
pure function f_sgr (g, phi, psi, k) result (phipsi)
type(bispinor) :: phipsi
complex(kind=default), intent(in) :: g
complex(kind=default), intent(in) :: phi
type(momentum), intent(in) :: k
type(vectorspinor), intent(in) :: psi
type(vector) :: vk
vk = k
phipsi = (g * phi) * fgvgr (psi, vk)
end function f_sgr
@
<<Implementation of bispinor currents>>=
pure function f_slgr (gl, phi, psi, k) result (phipsi)
type(bispinor) :: phipsi
complex(kind=default), intent(in) :: gl
complex(kind=default), intent(in) :: phi
type(momentum), intent(in) :: k
type(vectorspinor), intent(in) :: psi
phipsi = f_sgr (gl, phi, psi, k)
phipsi%a(3:4) = 0
end function f_slgr
@
<<Implementation of bispinor currents>>=
pure function f_srgr (gr, phi, psi, k) result (phipsi)
type(bispinor) :: phipsi
complex(kind=default), intent(in) :: gr
complex(kind=default), intent(in) :: phi
type(momentum), intent(in) :: k
type(vectorspinor), intent(in) :: psi
phipsi = f_sgr (gr, phi, psi, k)
phipsi%a(1:2) = 0
end function f_srgr
@
<<Implementation of bispinor currents>>=
pure function f_slrgr (gl, gr, phi, psi, k) result (phipsi)
type(bispinor) :: phipsi, phipsi_l, phipsi_r
complex(kind=default), intent(in) :: gl, gr
complex(kind=default), intent(in) :: phi
type(momentum), intent(in) :: k
type(vectorspinor), intent(in) :: psi
phipsi_l = f_slgr (gl, phi, psi, k)
phipsi_r = f_srgr (gr, phi, psi, k)
phipsi%a(1:2) = phipsi_l%a(1:2)
phipsi%a(3:4) = phipsi_r%a(3:4)
end function f_slrgr
@
<<Implementation of bispinor currents>>=
pure function fgvg5gr (psi, k) result (kpsi)
type(bispinor) :: kpsi
type(vector), intent(in) :: k
type(vectorspinor), intent(in) :: psi
type(bispinor) :: kpsi_dum
kpsi_dum = fgvgr (psi, k)
kpsi%a(1:2) = - kpsi_dum%a(1:2)
kpsi%a(3:4) = kpsi_dum%a(3:4)
end function fgvg5gr
@
<<Implementation of bispinor currents>>=
pure function f_pgr (g, phi, psi, k) result (phipsi)
type(bispinor) :: phipsi
complex(kind=default), intent(in) :: g
complex(kind=default), intent(in) :: phi
type(momentum), intent(in) :: k
type(vectorspinor), intent(in) :: psi
type(vector) :: vk
vk = k
phipsi = (g * phi) * fgvg5gr (psi, vk)
end function f_pgr
@
The needed construction of gamma matrices involving the commutator
of two gamma matrices. For the slashed terms we use as usual the
abbreviations $k_\pm=k_0\pm k_3$, $k=k_1+\ii k_2$, $k^*=k_1-\ii k_2$
and analogous expressions for the vector $v^\mu$. We remind you
that~$\cdot^*$ is \emph{not} complex conjugation for complex~$k_\mu$.
Furthermore we introduce (in what follows the brackets around the vector
indices have the usual meaning of antisymmetrizing with respect to the
indices inside the brackets, here without a factor two in the denominator)
\begin{subequations}
\begin{alignat}{2}
a_+ &= \; k_+ v_- + k v^* - k_- v_+ - k^* v & \; = &
\; 2 (k_{[3} v_{0]} + \ii k_{[2} v_{1]}) \\
a_- &= \; k_- v_+ + k v^* - k_+ v_- - k^* v & \; = &
\; 2 (-k_{[3} v_{0]} + \ii k_{[2} v_{1]}) \\
b_+ &= \; 2 (k_+ v - k v_+) & \; = &
\; 2 (k_{[0} v_{1]} + k_{[3} v_{1]} + \ii k_{[0} v_{2]} + \ii
k_{[3} v_{2]}) \\
b_- &= \; 2 (k_- v - k v_-) & \; = &
\; 2 (k_{[0} v_{1]} - k_{[3} v_{1]} + \ii k_{[0} v_{2]} - \ii
k_{[3} v_{2]}) \\
b_{+*} &= \; 2 (k_+ v^* - k^* v_+) & \; = &
\; 2 (k_{[0} v_{1]} + k_{[3} v_{1]} - \ii k_{[0} v_{2]} - \ii
k_{[3} v_{2]}) \\
b_{-*} &= \; 2 (k_- v^* - k^* v_-) & \; = &
\; 2 (k_{[0} v_{1]} - k_{[3} v_{1]} - \ii k_{[0} v_{2]} + \ii
k_{[3} v_{2]})
\end{alignat}
\end{subequations}
Of course, one could introduce a more advanced notation, but we don't want to
become confused.
\begin{subequations}
\begin{align}
\lbrack \fmslash{k} , \gamma^0 \rbrack &=
\begin{pmatrix}
-2k_3 & -2 k^* & 0 & 0 \\
-2k & 2k_3 & 0 & 0 \\
0 & 0 & 2k_3 & 2k^* \\
0 & 0 & 2k & -2k_3
\end{pmatrix} \\
\lbrack \fmslash{k} , \gamma^1 \rbrack &=
\begin{pmatrix}
-2\ii k_2 & -2k_- & 0 & 0 \\
-2k_+ & 2\ii k_2 & 0 & 0 \\
0 & 0 & -2\ii k_2 & 2k_+ \\
0 & 0 & 2k_- & 2\ii k_2
\end{pmatrix} \\
\lbrack \fmslash{k} , \gamma^2 \rbrack &=
\begin{pmatrix}
2\ii k_1 & 2\ii k_- & 0 & 0 \\
-2\ii k_+ & -2\ii k_1 & 0 & 0 \\
0 & 0 & 2\ii k_1 & -2\ii k_+ \\
0 & 0 & 2\ii k_- & -2\ii k_1
\end{pmatrix} \\
\lbrack \fmslash{k} , \gamma^3 \rbrack &=
\begin{pmatrix}
-2k_0 & -2k^* & 0 & 0 \\
2k & 2k_0 & 0 & 0 \\
0 & 0 & 2k_0 & -2k^* \\
0 & 0 & 2k & -2k_0
\end{pmatrix} \\
\lbrack \fmslash{k} , \fmslash{V} \rbrack &=
\begin{pmatrix}
a_- & b_{-*} & 0 & 0 \\
b_+ & -a_- & 0 & 0 \\
0 & 0 & a_+ & -b_{+*} \\
0 & 0 & -b_- & -a_+
\end{pmatrix} \\
\gamma^5\gamma^0 \lbrack \fmslash{k} , \fmslash{V} \rbrack &=
\begin{pmatrix}
0 & 0 & - a_+ & b_{+*} \\
0 & 0 & b_- & a_+ \\
a_- & b_{-*} & 0 & 0 \\
b_+ & - a_- & 0 & 0
\end{pmatrix} \\
\gamma^5\gamma^1 \lbrack \fmslash{k} , \fmslash{V} \rbrack &=
\begin{pmatrix}
0 & 0 & b_- & a_+ \\
0 & 0 & -a_+ & b_{+*} \\
-b_+ & a_- & 0 & 0 & \\
-a_- & -b_{-*} & 0 & 0
\end{pmatrix} \\
\gamma^5\gamma^2 \lbrack \fmslash{k} , \fmslash{V} \rbrack &=
\begin{pmatrix}
0 & 0 & -\ii b_- & -\ii a_+ \\
0 & 0 & -\ii a_+ & \ii b_{+*} \\
\ii b_+ & -\ii a_- & 0 & 0 \\
-\ii a_- & -\ii b_{-*} & 0 & 0
\end{pmatrix} \\
\gamma^5\gamma^3 \lbrack \fmslash{k} , \fmslash{V} \rbrack &=
\begin{pmatrix}
0 & 0 & -a_+ & b_{+*} \\
0 & 0 & -b_- & -a_+ \\
-a_- & -b_{-*} & 0 & 0 \\
b_+ & -a_- & 0 & 0
\end{pmatrix}
\end{align}
\end{subequations}
and
\begin{subequations}
\begin{align}
\lbrack \fmslash{k} , \fmslash{V} \rbrack \gamma^0 \gamma^5 &=
\begin{pmatrix}
0 & 0 & a_- & b_{-*} \\
0 & 0 & b_+ & -a_- \\
-a_+ & b_{+*} & 0 & 0 \\
b_- & a_+ & 0 & 0
\end{pmatrix} \\
\lbrack \fmslash{k} , \fmslash{V} \rbrack \gamma^1 \gamma^5 &=
\begin{pmatrix}
0 & 0 & b_{-*} & a_- \\
0 & 0 & -a_- & b_+ \\
-b_{+*} & a_+ & 0 & 0 \\
-a_+ & -b_- & 0 & 0
\end{pmatrix} \\
\lbrack \fmslash{k} , \fmslash{V} \rbrack \gamma^2 \gamma^5 &=
\begin{pmatrix}
0 & 0 & \ii b_{-*} & -\ii a_- \\
0 & 0 & -\ii a_- & -\ii b_+ \\
-\ii b_{+*} & -\ii a_+ & 0 & 0 \\
-\ii a_+ & \ii b_- & 0 & 0
\end{pmatrix} \\
\lbrack \fmslash{k} , \fmslash{V} \rbrack \gamma^3 \gamma^5 &=
\begin{pmatrix}
0 & 0 & a_- & - b_{-*} \\
0 & 0 & b_+ & a_- \\
a_+ & b_{+*} & 0 & 0 \\
-b_- & a_+ & 0 & 0
\end{pmatrix}
\end{align}
\end{subequations}
In what follows $l$ always means twice the value of $k$, e.g. $l_+$ =
$2 k_+$. We use the abbreviation $C^{\mu\nu} \equiv C \lbrack
\fmslash{k}, \gamma^\mu \rbrack \gamma^\nu \gamma^5$.
\begin{subequations}
\begin{alignat}{2}
C^{00} &= \begin{pmatrix}
0 & 0 & -l & -l_3 \\ 0 & 0 & l_3 & l^* \\
l & -l_3 & 0 & 0 \\ -l_3 & -l^* & 0 & 0 \end{pmatrix} , & \qquad
C^{20} &= \begin{pmatrix}
0 & 0 & -\ii l_+ & -\ii l_1 \\ 0 & 0 & -\ii l_1 & -\ii l_- \\
\ii l_- & -\ii l_1 & 0 & 0 \\ -\ii l_1 & \ii l_+ & 0 & 0
\end{pmatrix} \\
C^{01} &= \begin{pmatrix}
0 & 0 & l_3 & -l \\ 0 & 0 & l^* & l_3 \\
l_3 & -l & 0 & 0 \\ l^* & l_3 & 0 & 0 \end{pmatrix} , & \qquad
C^{21} &= \begin{pmatrix}
0 & 0 & -\ii l_1 & -\ii l_+ \\ 0 & 0 & -\ii l_- & -\ii l_1 \\
\ii l_1 & -\ii l_- & 0 & 0 \\ -\ii l_+ & \ii l_1 & 0 & 0
\end{pmatrix} \\
C^{02} &= \begin{pmatrix}
0 & 0 & \ii l_3 & \ii l \\ 0 & 0 & \ii l^* & -\ii l_3 \\
\ii l_3 & \ii l & 0 & 0 \\ \ii l^* & -\ii l_3 & 0 & 0 \end{pmatrix}
, & \qquad
C^{22} &= \begin{pmatrix}
0 & 0 & l_1 & -l_+ \\ 0 & 0 & l_- & -l_1 \\
-l_1 & -l_- & 0 & 0 \\ l_+ & l_1 & 0 & 0
\end{pmatrix} \\
C^{03} &= \begin{pmatrix}
0 & 0 & -l & -l_3 \\ 0 & 0 & l_3 & -l^* \\
-l & -l_3 & 0 & 0 \\ l_3 & -l^* & 0 & 0 \end{pmatrix} , & \qquad
C^{23} &= \begin{pmatrix}
0 & 0 & -\ii l_+ & \ii l_1 \\ 0 & 0 & -\ii l_1 & \ii l_- \\
-\ii l_- & -\ii l_1 & 0 & 0 \\ \ii l_1 & \ii l_+ & 0 & 0
\end{pmatrix} \\
C^{10} &= \begin{pmatrix}
0 & 0 & -l_+ & \ii l_2 \\ 0 & 0 & \ii l_2 & l_- \\
l_- & \ii l_2 & 0 & 0 \\ \ii l_2 & -l_+ & 0 & 0 \end{pmatrix} , &
\qquad
C^{30} &= \begin{pmatrix}
0 & 0 & l & l_0 \\ 0 & 0 & l_0 & l^* \\
l & -l_0 & 0 & 0 \\ -l_0 & l^* & 0 & 0
\end{pmatrix} \\
C^{11} &= \begin{pmatrix}
0 & 0 & \ii l_2 & -l_+ \\ 0 & 0 & l_- & \ii l_2 \\
-\ii l_2 & -l_- & 0 & 0 \\ l_+ & -\ii l_2 & 0 & 0 \end{pmatrix} , &
\qquad
C^{31} &= \begin{pmatrix}
0 & 0 & l_0 & l \\ 0 & 0 & l^* & l_0 \\
l_0 & -l & 0 & 0 \\ -l^* & l_0 & 0 & 0
\end{pmatrix} \\
C^{12} &= \begin{pmatrix}
0 & 0 & -l_2 & \ii l_+ \\ 0 & 0 & \ii l_- & l_2 \\
l_2 & \ii l_- & 0 & 0 \\ \ii l_+ & -l_2 & 0 & 0 \end{pmatrix} , &
\qquad
C^{32} &= \begin{pmatrix}
0 & 0 & \ii l_0 & -\ii l \\ 0 & 0 & \ii l^* & -\ii l_0 \\
\ii l_0 & \ii l & 0 & 0 \\ -\ii l^* & -\ii l_0 & 0 & 0
\end{pmatrix} \\
C^{13} &= \begin{pmatrix}
0 & 0 & -l_+ & -\ii l_2 \\ 0 & 0 & \ii l_2 & - l_- \\
-l_- & \ii l_2 & 0 & 0 \\ -\ii l_2 & -l_+ & 0 & 0 \end{pmatrix} , &
\qquad
C^{33} &= \begin{pmatrix}
0 & 0 & l & -l_0 \\ 0 & 0 & l_0 & -l^* \\
-l & -l_0 & 0 & 0 \\ l_0 & l^* & 0 & 0
\end{pmatrix}
\end{alignat}
\end{subequations}
and, with the abbreviation $\tilde{C}^{\mu\nu} \equiv C \gamma^5
\gamma^\nu \lbrack \fmslash{k} , \gamma^\mu \rbrack$ (note the
reversed order of the indices!)
\begin{subequations}
\begin{alignat}{2}
\tilde{C}^{00} &= \begin{pmatrix}
0 & 0 & -l & l_3 \\ 0 & 0 & l_3 & l^* \\
l & -l_3 & 0 & 0 \\ -l_3 & -l^* & 0 & 0 \end{pmatrix} , & \qquad
\tilde{C}^{20} &= \begin{pmatrix}
0 & 0 & -\ii l_- & \ii l_1 \\ 0 & 0 & \ii l_1 & -\ii l_+ \\
\ii l_+ & \ii l_1 & 0 & 0 \\ \ii l_1 & \ii l_- & 0 & 0
\end{pmatrix} \\
\tilde{C}^{01} &= \begin{pmatrix}
0 & 0 & -l_3 & -l^* \\ 0 & 0 & l & -l_3 \\
-l_3 & -l^* & 0 & 0 \\ l & -l_3 & 0 & 0 \end{pmatrix} , & \qquad
\tilde{C}^{21} &= \begin{pmatrix}
0 & 0 & -\ii l_1 & \ii l_+ \\ 0 & 0 & \ii l_- & -\ii l_1 \\
\ii l_1 & \ii l_- & 0 & 0 \\ \ii l_+ & \ii l_1 & 0 & 0
\end{pmatrix} \\
\tilde{C}^{02} &= \begin{pmatrix}
0 & 0 & -\ii l_3 & -\ii l^* \\ 0 & 0 & -\ii l & \ii l_3 \\
-\ii l_3 & -\ii l^* & 0 & 0 \\ -\ii l & \ii l_3 & 0 & 0
\end{pmatrix} , & \qquad
\tilde{C}^{22} &= \begin{pmatrix}
0 & 0 & l_1 & -l_+ \\ 0 & 0 & l_- & -l_1 \\
-l_1 & -l_- & 0 & 0 \\ l_+ & l_1 & 0 & 0
\end{pmatrix} \\
\tilde{C}^{03} &= \begin{pmatrix}
0 & 0 & l & -l_3 \\ 0 & 0 & l_3 & l^* \\
l & -l_3 & 0 & 0 \\ l_3 & l^* & 0 & 0 \end{pmatrix} , & \qquad
\tilde{C}^{23} &= \begin{pmatrix}
0 & 0 & \ii l_- & -\ii l_1 \\ 0 & 0 & \ii l_1 & -\ii l_+ \\
\ii l_+ & \ii l_1 & 0 & 0 \\ -\ii l_1 & -\ii l_- & 0 & 0
\end{pmatrix} \\
\tilde{C}^{10} &= \begin{pmatrix}
0 & 0 & -l_- & -\ii l_2 \\ 0 & 0 & -\ii l_2 & l_+ \\
l_+ & -\ii l_2 & 0 & 0 \\ -\ii l_2 & -l_- & 0 & 0 \end{pmatrix} , &
\qquad
\tilde{C}^{30} &= \begin{pmatrix}
0 & 0 & -l & l_0 \\ 0 & 0 & l_0 & -l^* \\
-l & -l_0 & 0 & 0 \\ -l_0 & -l^* & 0 & 0
\end{pmatrix} \\
\tilde{C}^{11} &= \begin{pmatrix}
0 & 0 & \ii l_2 & -l_+ \\ 0 & 0 & l_- & \ii l_2 \\
-\ii l_2 & -l_- & 0 & 0 \\ l_+ & -\ii l_2 & 0 & 0 \end{pmatrix} , &
\qquad
\tilde{C}^{31} &= \begin{pmatrix}
0 & 0 & -l_0 & l^* \\ 0 & 0 & l & -l_0 \\
-l_0 & -l^* & 0 & 0 \\ -l & -l_0 & 0 & 0
\end{pmatrix} \\
\tilde{C}^{12} &= \begin{pmatrix}
0 & 0 & -l_2 & -\ii l_+ \\ 0 & 0 & -\ii l_- & l_2 \\
l_2 & -\ii l_- & 0 & 0 \\ -\ii l_+ & -l_2 & 0 & 0 \end{pmatrix} , &
\qquad
\tilde{C}^{32} &= \begin{pmatrix}
0 & 0 & -\ii l_0 & \ii l^* \\ 0 & 0 & -\ii l & \ii l_0 \\
-\ii l_0 & -\ii l^* & 0 & 0 \\ \ii l & \ii l_0 & 0 & 0
\end{pmatrix} \\
\tilde{C}^{13} &= \begin{pmatrix}
0 & 0 & l_- & \ii l_2 \\ 0 & 0 & -\ii l_2 & l_+ \\
l_+ & -\ii l_2 & 0 & 0 \\ \ii l_2 & l_- & 0 & 0 \end{pmatrix} , &
\qquad
\tilde{C}^{33} &= \begin{pmatrix}
0 & 0 & l & -l_0 \\ 0 & 0 & l_0 & -l^* \\
-l & -l_0 & 0 & 0 \\ l_0 & l^* & 0 & 0
\end{pmatrix}
\end{alignat}
\end{subequations}
<<Implementation of bispinor currents>>=
pure function fggvvgr (v, psi, k) result (psikv)
type(bispinor) :: psikv
type(vectorspinor), intent(in) :: psi
type(vector), intent(in) :: v, k
complex(kind=default) :: kv30, kv21, kv01, kv31, kv02, kv32
complex(kind=default) :: ap, am, bp, bm, bps, bms
kv30 = k%x(3) * v%t - k%t * v%x(3)
kv21 = (0,1) * (k%x(2) * v%x(1) - k%x(1) * v%x(2))
kv01 = k%t * v%x(1) - k%x(1) * v%t
kv31 = k%x(3) * v%x(1) - k%x(1) * v%x(3)
kv02 = (0,1) * (k%t * v%x(2) - k%x(2) * v%t)
kv32 = (0,1) * (k%x(3) * v%x(2) - k%x(2) * v%x(3))
ap = 2 * (kv30 + kv21)
am = 2 * (-kv30 + kv21)
bp = 2 * (kv01 + kv31 + kv02 + kv32)
bm = 2 * (kv01 - kv31 + kv02 - kv32)
bps = 2 * (kv01 + kv31 - kv02 - kv32)
bms = 2 * (kv01 - kv31 - kv02 + kv32)
psikv%a(1) = (-ap) * psi%psi(1)%a(3) + bps * psi%psi(1)%a(4) &
+ (-bm) * psi%psi(2)%a(3) + (-ap) * psi%psi(2)%a(4) &
+ (0,1) * (bm * psi%psi(3)%a(3) + ap * psi%psi(3)%a(4)) &
+ ap * psi%psi(4)%a(3) + (-bps) * psi%psi(4)%a(4)
psikv%a(2) = bm * psi%psi(1)%a(3) + ap * psi%psi(1)%a(4) &
+ ap * psi%psi(2)%a(3) + (-bps) * psi%psi(2)%a(4) &
+ (0,1) * (ap * psi%psi(3)%a(3) - bps * psi%psi(3)%a(4)) &
+ bm * psi%psi(4)%a(3) + ap * psi%psi(4)%a(4)
psikv%a(3) = am * psi%psi(1)%a(1) + bms * psi%psi(1)%a(2) &
+ bp * psi%psi(2)%a(1) + (-am) * psi%psi(2)%a(2) &
+ (0,-1) * (bp * psi%psi(3)%a(1) + (-am) * psi%psi(3)%a(2)) &
+ am * psi%psi(4)%a(1) + bms * psi%psi(4)%a(2)
psikv%a(4) = bp * psi%psi(1)%a(1) + (-am) * psi%psi(1)%a(2) &
+ am * psi%psi(2)%a(1) + bms * psi%psi(2)%a(2) &
+ (0,1) * (am * psi%psi(3)%a(1) + bms * psi%psi(3)%a(2)) &
+ (-bp) * psi%psi(4)%a(1) + am * psi%psi(4)%a(2)
end function fggvvgr
@
<<Implementation of bispinor currents>>=
pure function f_vgr (g, v, psi, k) result (psikkkv)
type(bispinor) :: psikkkv
type(vectorspinor), intent(in) :: psi
type(vector), intent(in) :: v
type(momentum), intent(in) :: k
complex(kind=default), intent(in) :: g
type(vector) :: vk
vk = k
psikkkv = g * (fggvvgr (v, psi, vk))
end function f_vgr
@
<<Implementation of bispinor currents>>=
pure function f_vlrgr (gl, gr, v, psi, k) result (psikv)
type(bispinor) :: psikv
type(vectorspinor), intent(in) :: psi
type(vector), intent(in) :: v
type(momentum), intent(in) :: k
complex(kind=default), intent(in) :: gl, gr
type(vector) :: vk
vk = k
psikv = fggvvgr (v, psi, vk)
psikv%a(1:2) = gl * psikv%a(1:2)
psikv%a(3:4) = gr * psikv%a(3:4)
end function f_vlrgr
@
<<Declaration of bispinor currents>>=
public :: gr_potf, gr_sf, gr_pf, gr_vf, gr_vlrf, gr_slf, gr_srf, gr_slrf
@
<<Implementation of bispinor currents>>=
pure function gr_potf (g, phi, psi) result (phipsi)
type(vectorspinor) :: phipsi
complex(kind=default), intent(in) :: g
complex(kind=default), intent(in) :: phi
type(bispinor), intent(in) :: psi
phipsi%psi(1)%a(1) = (g * phi) * psi%a(3)
phipsi%psi(1)%a(2) = (g * phi) * psi%a(4)
phipsi%psi(1)%a(3) = (g * phi) * psi%a(1)
phipsi%psi(1)%a(4) = (g * phi) * psi%a(2)
phipsi%psi(2)%a(1) = (g * phi) * psi%a(4)
phipsi%psi(2)%a(2) = (g * phi) * psi%a(3)
phipsi%psi(2)%a(3) = ((-g) * phi) * psi%a(2)
phipsi%psi(2)%a(4) = ((-g) * phi) * psi%a(1)
phipsi%psi(3)%a(1) = ((0,-1) * g * phi) * psi%a(4)
phipsi%psi(3)%a(2) = ((0,1) * g * phi) * psi%a(3)
phipsi%psi(3)%a(3) = ((0,1) * g * phi) * psi%a(2)
phipsi%psi(3)%a(4) = ((0,-1) * g * phi) * psi%a(1)
phipsi%psi(4)%a(1) = (g * phi) * psi%a(3)
phipsi%psi(4)%a(2) = ((-g) * phi) * psi%a(4)
phipsi%psi(4)%a(3) = ((-g) * phi) * psi%a(1)
phipsi%psi(4)%a(4) = (g * phi) * psi%a(2)
end function gr_potf
@
<<Implementation of bispinor currents>>=
pure function grkgf (psi, k) result (kpsi)
type(vectorspinor) :: kpsi
complex(kind=default) :: kp, km, k12, k12s
type(bispinor), intent(in) :: psi
type(vector), intent(in) :: k
kp = k%t + k%x(3)
km = k%t - k%x(3)
k12 = k%x(1) + (0,1)*k%x(2)
k12s = k%x(1) - (0,1)*k%x(2)
kpsi%psi(1)%a(1) = km * psi%a(1) - k12s * psi%a(2)
kpsi%psi(1)%a(2) = (-k12) * psi%a(1) + kp * psi%a(2)
kpsi%psi(1)%a(3) = kp * psi%a(3) + k12s * psi%a(4)
kpsi%psi(1)%a(4) = k12 * psi%a(3) + km * psi%a(4)
kpsi%psi(2)%a(1) = k12s * psi%a(1) - km * psi%a(2)
kpsi%psi(2)%a(2) = (-kp) * psi%a(1) + k12 * psi%a(2)
kpsi%psi(2)%a(3) = k12s * psi%a(3) + kp * psi%a(4)
kpsi%psi(2)%a(4) = km * psi%a(3) + k12 * psi%a(4)
kpsi%psi(3)%a(1) = (0,1) * (k12s * psi%a(1) + km * psi%a(2))
kpsi%psi(3)%a(2) = (0,-1) * (kp * psi%a(1) + k12 * psi%a(2))
kpsi%psi(3)%a(3) = (0,1) * (k12s * psi%a(3) - kp * psi%a(4))
kpsi%psi(3)%a(4) = (0,1) * (km * psi%a(3) - k12 * psi%a(4))
kpsi%psi(4)%a(1) = -(km * psi%a(1) + k12s * psi%a(2))
kpsi%psi(4)%a(2) = k12 * psi%a(1) + kp * psi%a(2)
kpsi%psi(4)%a(3) = kp * psi%a(3) - k12s * psi%a(4)
kpsi%psi(4)%a(4) = k12 * psi%a(3) - km * psi%a(4)
end function grkgf
@
<<Implementation of bispinor currents>>=
pure function gr_sf (g, phi, psi, k) result (phipsi)
type(vectorspinor) :: phipsi
complex(kind=default), intent(in) :: g
complex(kind=default), intent(in) :: phi
type(bispinor), intent(in) :: psi
type(momentum), intent(in) :: k
type(vector) :: vk
vk = k
phipsi = (g * phi) * grkgf (psi, vk)
end function gr_sf
@
<<Implementation of bispinor currents>>=
pure function gr_slf (gl, phi, psi, k) result (phipsi)
type(vectorspinor) :: phipsi
complex(kind=default), intent(in) :: gl
complex(kind=default), intent(in) :: phi
type(bispinor), intent(in) :: psi
type(bispinor) :: psi_l
type(momentum), intent(in) :: k
psi_l%a(1:2) = psi%a(1:2)
psi_l%a(3:4) = 0
phipsi = gr_sf (gl, phi, psi_l, k)
end function gr_slf
@
<<Implementation of bispinor currents>>=
pure function gr_srf (gr, phi, psi, k) result (phipsi)
type(vectorspinor) :: phipsi
complex(kind=default), intent(in) :: gr
complex(kind=default), intent(in) :: phi
type(bispinor), intent(in) :: psi
type(bispinor) :: psi_r
type(momentum), intent(in) :: k
psi_r%a(1:2) = 0
psi_r%a(3:4) = psi%a(3:4)
phipsi = gr_sf (gr, phi, psi_r, k)
end function gr_srf
@
<<Implementation of bispinor currents>>=
pure function gr_slrf (gl, gr, phi, psi, k) result (phipsi)
type(vectorspinor) :: phipsi
complex(kind=default), intent(in) :: gl, gr
complex(kind=default), intent(in) :: phi
type(bispinor), intent(in) :: psi
type(momentum), intent(in) :: k
phipsi = gr_slf (gl, phi, psi, k) + gr_srf (gr, phi, psi, k)
end function gr_slrf
@
<<Implementation of bispinor currents>>=
pure function grkggf (psi, k) result (kpsi)
type(vectorspinor) :: kpsi
complex(kind=default) :: kp, km, k12, k12s
type(bispinor), intent(in) :: psi
type(vector), intent(in) :: k
kp = k%t + k%x(3)
km = k%t - k%x(3)
k12 = k%x(1) + (0,1)*k%x(2)
k12s = k%x(1) - (0,1)*k%x(2)
kpsi%psi(1)%a(1) = (-km) * psi%a(1) + k12s * psi%a(2)
kpsi%psi(1)%a(2) = k12 * psi%a(1) - kp * psi%a(2)
kpsi%psi(1)%a(3) = kp * psi%a(3) + k12s * psi%a(4)
kpsi%psi(1)%a(4) = k12 * psi%a(3) + km * psi%a(4)
kpsi%psi(2)%a(1) = (-k12s) * psi%a(1) + km * psi%a(2)
kpsi%psi(2)%a(2) = kp * psi%a(1) - k12 * psi%a(2)
kpsi%psi(2)%a(3) = k12s * psi%a(3) + kp * psi%a(4)
kpsi%psi(2)%a(4) = km * psi%a(3) + k12 * psi%a(4)
kpsi%psi(3)%a(1) = (0,-1) * (k12s * psi%a(1) + km * psi%a(2))
kpsi%psi(3)%a(2) = (0,1) * (kp * psi%a(1) + k12 * psi%a(2))
kpsi%psi(3)%a(3) = (0,1) * (k12s * psi%a(3) - kp * psi%a(4))
kpsi%psi(3)%a(4) = (0,1) * (km * psi%a(3) - k12 * psi%a(4))
kpsi%psi(4)%a(1) = km * psi%a(1) + k12s * psi%a(2)
kpsi%psi(4)%a(2) = -(k12 * psi%a(1) + kp * psi%a(2))
kpsi%psi(4)%a(3) = kp * psi%a(3) - k12s * psi%a(4)
kpsi%psi(4)%a(4) = k12 * psi%a(3) - km * psi%a(4)
end function grkggf
@
<<Implementation of bispinor currents>>=
pure function gr_pf (g, phi, psi, k) result (phipsi)
type(vectorspinor) :: phipsi
complex(kind=default), intent(in) :: g
complex(kind=default), intent(in) :: phi
type(bispinor), intent(in) :: psi
type(momentum), intent(in) :: k
type(vector) :: vk
vk = k
phipsi = (g * phi) * grkggf (psi, vk)
end function gr_pf
@
<<Implementation of bispinor currents>>=
pure function grkkggf (v, psi, k) result (psikv)
type(vectorspinor) :: psikv
type(bispinor), intent(in) :: psi
type(vector), intent(in) :: v, k
complex(kind=default) :: kv30, kv21, kv01, kv31, kv02, kv32
complex(kind=default) :: ap, am, bp, bm, bps, bms, imago
imago = (0.0_default,1.0_default)
kv30 = k%x(3) * v%t - k%t * v%x(3)
kv21 = imago * (k%x(2) * v%x(1) - k%x(1) * v%x(2))
kv01 = k%t * v%x(1) - k%x(1) * v%t
kv31 = k%x(3) * v%x(1) - k%x(1) * v%x(3)
kv02 = imago * (k%t * v%x(2) - k%x(2) * v%t)
kv32 = imago * (k%x(3) * v%x(2) - k%x(2) * v%x(3))
ap = 2 * (kv30 + kv21)
am = 2 * ((-kv30) + kv21)
bp = 2 * (kv01 + kv31 + kv02 + kv32)
bm = 2 * (kv01 - kv31 + kv02 - kv32)
bps = 2 * (kv01 + kv31 - kv02 - kv32)
bms = 2 * (kv01 - kv31 - kv02 + kv32)
psikv%psi(1)%a(1) = am * psi%a(3) + bms * psi%a(4)
psikv%psi(1)%a(2) = bp * psi%a(3) + (-am) * psi%a(4)
psikv%psi(1)%a(3) = (-ap) * psi%a(1) + bps * psi%a(2)
psikv%psi(1)%a(4) = bm * psi%a(1) + ap * psi%a(2)
psikv%psi(2)%a(1) = bms * psi%a(3) + am * psi%a(4)
psikv%psi(2)%a(2) = (-am) * psi%a(3) + bp * psi%a(4)
psikv%psi(2)%a(3) = (-bps) * psi%a(1) + ap * psi%a(2)
psikv%psi(2)%a(4) = (-ap) * psi%a(1) + (-bm) * psi%a(2)
psikv%psi(3)%a(1) = imago * (bms * psi%a(3) - am * psi%a(4))
psikv%psi(3)%a(2) = (-imago) * (am * psi%a(3) + bp * psi%a(4))
psikv%psi(3)%a(3) = (-imago) * (bps * psi%a(1) + ap * psi%a(2))
psikv%psi(3)%a(4) = imago * ((-ap) * psi%a(1) + bm * psi%a(2))
psikv%psi(4)%a(1) = am * psi%a(3) + (-bms) * psi%a(4)
psikv%psi(4)%a(2) = bp * psi%a(3) + am * psi%a(4)
psikv%psi(4)%a(3) = ap * psi%a(1) + bps * psi%a(2)
psikv%psi(4)%a(4) = (-bm) * psi%a(1) + ap * psi%a(2)
end function grkkggf
@
<<Implementation of bispinor currents>>=
pure function gr_vf (g, v, psi, k) result (psikv)
type(vectorspinor) :: psikv
type(bispinor), intent(in) :: psi
type(vector), intent(in) :: v
type(momentum), intent(in) :: k
complex(kind=default), intent(in) :: g
type(vector) :: vk
vk = k
psikv = g * (grkkggf (v, psi, vk))
end function gr_vf
@
<<Implementation of bispinor currents>>=
pure function gr_vlrf (gl, gr, v, psi, k) result (psikv)
type(vectorspinor) :: psikv
type(bispinor), intent(in) :: psi
type(bispinor) :: psi_l, psi_r
type(vector), intent(in) :: v
type(momentum), intent(in) :: k
complex(kind=default), intent(in) :: gl, gr
type(vector) :: vk
vk = k
psi_l%a(1:2) = psi%a(1:2)
psi_l%a(3:4) = 0
psi_r%a(1:2) = 0
psi_r%a(3:4) = psi%a(3:4)
psikv = gl * grkkggf (v, psi_l, vk) + gr * grkkggf (v, psi_r, vk)
end function gr_vlrf
@
<<Declaration of bispinor currents>>=
public :: v_grf, v_fgr
@
<<Declaration of bispinor currents>>=
public :: vlr_grf, vlr_fgr
@
$V^\mu = \psi_\rho^T C^{\mu\rho} \psi$
<<Implementation of bispinor currents>>=
pure function grkgggf (psil, psir, k) result (j)
type(vector) :: j
type(vectorspinor), intent(in) :: psil
type(bispinor), intent(in) :: psir
type(vector), intent(in) :: k
type(vectorspinor) :: c_psir0, c_psir1, c_psir2, c_psir3
complex(kind=default) :: kp, km, k12, k12s, ik2
kp = k%t + k%x(3)
km = k%t - k%x(3)
k12 = (k%x(1) + (0,1)*k%x(2))
k12s = (k%x(1) - (0,1)*k%x(2))
ik2 = (0,1) * k%x(2)
!!! New version:
c_psir0%psi(1)%a(1) = (-k%x(3)) * psir%a(3) + (-k12s) * psir%a(4)
c_psir0%psi(1)%a(2) = (-k12) * psir%a(3) + k%x(3) * psir%a(4)
c_psir0%psi(1)%a(3) = (-k%x(3)) * psir%a(1) + (-k12s) * psir%a(2)
c_psir0%psi(1)%a(4) = (-k12) * psir%a(1) + k%x(3) * psir%a(2)
c_psir0%psi(2)%a(1) = (-k12s) * psir%a(3) + (-k%x(3)) * psir%a(4)
c_psir0%psi(2)%a(2) = k%x(3) * psir%a(3) + (-k12) * psir%a(4)
c_psir0%psi(2)%a(3) = k12s * psir%a(1) + k%x(3) * psir%a(2)
c_psir0%psi(2)%a(4) = (-k%x(3)) * psir%a(1) + k12 * psir%a(2)
c_psir0%psi(3)%a(1) = (0,1) * ((-k12s) * psir%a(3) + k%x(3) * psir%a(4))
c_psir0%psi(3)%a(2) = (0,1) * (k%x(3) * psir%a(3) + k12 * psir%a(4))
c_psir0%psi(3)%a(3) = (0,1) * (k12s * psir%a(1) + (-k%x(3)) * psir%a(2))
c_psir0%psi(3)%a(4) = (0,1) * ((-k%x(3)) * psir%a(1) + (-k12) * psir%a(2))
c_psir0%psi(4)%a(1) = (-k%x(3)) * psir%a(3) + k12s * psir%a(4)
c_psir0%psi(4)%a(2) = (-k12) * psir%a(3) + (-k%x(3)) * psir%a(4)
c_psir0%psi(4)%a(3) = k%x(3) * psir%a(1) + (-k12s) * psir%a(2)
c_psir0%psi(4)%a(4) = k12 * psir%a(1) + k%x(3) * psir%a(2)
!!!
c_psir1%psi(1)%a(1) = (-ik2) * psir%a(3) + (-km) * psir%a(4)
c_psir1%psi(1)%a(2) = (-kp) * psir%a(3) + ik2 * psir%a(4)
c_psir1%psi(1)%a(3) = ik2 * psir%a(1) + (-kp) * psir%a(2)
c_psir1%psi(1)%a(4) = (-km) * psir%a(1) + (-ik2) * psir%a(2)
c_psir1%psi(2)%a(1) = (-km) * psir%a(3) + (-ik2) * psir%a(4)
c_psir1%psi(2)%a(2) = ik2 * psir%a(3) + (-kp) * psir%a(4)
c_psir1%psi(2)%a(3) = kp * psir%a(1) + (-ik2) * psir%a(2)
c_psir1%psi(2)%a(4) = ik2 * psir%a(1) + km * psir%a(2)
c_psir1%psi(3)%a(1) = ((0,-1) * km) * psir%a(3) + (-k%x(2)) * psir%a(4)
c_psir1%psi(3)%a(2) = (-k%x(2)) * psir%a(3) + ((0,1) * kp) * psir%a(4)
c_psir1%psi(3)%a(3) = ((0,1) * kp) * psir%a(1) + (-k%x(2)) * psir%a(2)
c_psir1%psi(3)%a(4) = (-k%x(2)) * psir%a(1) + ((0,-1) * km) * psir%a(2)
c_psir1%psi(4)%a(1) = (-ik2) * psir%a(3) + km * psir%a(4)
c_psir1%psi(4)%a(2) = (-kp) * psir%a(3) + (-ik2) * psir%a(4)
c_psir1%psi(4)%a(3) = (-ik2) * psir%a(1) + (-kp) * psir%a(2)
c_psir1%psi(4)%a(4) = km * psir%a(1) + (-ik2) * psir%a(2)
!!!
c_psir2%psi(1)%a(1) = (0,1) * (k%x(1) * psir%a(3) + km * psir%a(4))
c_psir2%psi(1)%a(2) = (0,-1) * (kp * psir%a(3) + k%x(1) * psir%a(4))
c_psir2%psi(1)%a(3) = (0,1) * ((-k%x(1)) * psir%a(1) + kp * psir%a(2))
c_psir2%psi(1)%a(4) = (0,1) * ((-km) * psir%a(1) + k%x(1) * psir%a(2))
c_psir2%psi(2)%a(1) = (0,1) * (km * psir%a(3) + k%x(1) * psir%a(4))
c_psir2%psi(2)%a(2) = (0,-1) * (k%x(1) * psir%a(3) + kp * psir%a(4))
c_psir2%psi(2)%a(3) = (0,-1) * (kp * psir%a(1) + (-k%x(1)) * psir%a(2))
c_psir2%psi(2)%a(4) = (0,-1) * (k%x(1) * psir%a(1) + (-km) * psir%a(2))
c_psir2%psi(3)%a(1) = (-km) * psir%a(3) + k%x(1) * psir%a(4)
c_psir2%psi(3)%a(2) = k%x(1) * psir%a(3) + (-kp) * psir%a(4)
c_psir2%psi(3)%a(3) = kp * psir%a(1) + k%x(1) * psir%a(2)
c_psir2%psi(3)%a(4) = k%x(1) * psir%a(1) + km * psir%a(2)
c_psir2%psi(4)%a(1) = (0,1) * (k%x(1) * psir%a(3) + (-km) * psir%a(4))
c_psir2%psi(4)%a(2) = (0,1) * ((-kp) * psir%a(3) + k%x(1) * psir%a(4))
c_psir2%psi(4)%a(3) = (0,1) * (k%x(1) * psir%a(1) + kp * psir%a(2))
c_psir2%psi(4)%a(4) = (0,1) * (km * psir%a(1) + k%x(1) * psir%a(2))
!!!
c_psir3%psi(1)%a(1) = (-k%t) * psir%a(3) - k12s * psir%a(4)
c_psir3%psi(1)%a(2) = k12 * psir%a(3) + k%t * psir%a(4)
c_psir3%psi(1)%a(3) = (-k%t) * psir%a(1) + k12s * psir%a(2)
c_psir3%psi(1)%a(4) = (-k12) * psir%a(1) + k%t * psir%a(2)
c_psir3%psi(2)%a(1) = (-k12s) * psir%a(3) + (-k%t) * psir%a(4)
c_psir3%psi(2)%a(2) = k%t * psir%a(3) + k12 * psir%a(4)
c_psir3%psi(2)%a(3) = (-k12s) * psir%a(1) + k%t * psir%a(2)
c_psir3%psi(2)%a(4) = (-k%t) * psir%a(1) + k12 * psir%a(2)
c_psir3%psi(3)%a(1) = (0,-1) * (k12s * psir%a(3) + (-k%t) * psir%a(4))
c_psir3%psi(3)%a(2) = (0,1) * (k%t * psir%a(3) + (-k12) * psir%a(4))
c_psir3%psi(3)%a(3) = (0,-1) * (k12s * psir%a(1) + k%t * psir%a(2))
c_psir3%psi(3)%a(4) = (0,-1) * (k%t * psir%a(1) + k12 * psir%a(2))
c_psir3%psi(4)%a(1) = (-k%t) * psir%a(3) + k12s * psir%a(4)
c_psir3%psi(4)%a(2) = k12 * psir%a(3) + (-k%t) * psir%a(4)
c_psir3%psi(4)%a(3) = k%t * psir%a(1) + k12s * psir%a(2)
c_psir3%psi(4)%a(4) = k12 * psir%a(1) + k%t * psir%a(2)
j%t = 2 * (psil * c_psir0)
j%x(1) = 2 * (psil * c_psir1)
j%x(2) = 2 * (psil * c_psir2)
j%x(3) = 2 * (psil * c_psir3)
end function grkgggf
@
<<Implementation of bispinor currents>>=
pure function v_grf (g, psil, psir, k) result (j)
type(vector) :: j
complex(kind=default), intent(in) :: g
type(vectorspinor), intent(in) :: psil
type(bispinor), intent(in) :: psir
type(momentum), intent(in) :: k
type(vector) :: vk
vk = k
j = g * grkgggf (psil, psir, vk)
end function v_grf
@
<<Implementation of bispinor currents>>=
pure function vlr_grf (gl, gr, psil, psir, k) result (j)
type(vector) :: j
complex(kind=default), intent(in) :: gl, gr
type(vectorspinor), intent(in) :: psil
type(bispinor), intent(in) :: psir
type(bispinor) :: psir_l, psir_r
type(momentum), intent(in) :: k
type(vector) :: vk
vk = k
psir_l%a(1:2) = psir%a(1:2)
psir_l%a(3:4) = 0
psir_r%a(1:2) = 0
psir_r%a(3:4) = psir%a(3:4)
j = gl * grkgggf (psil, psir_l, vk) + gr * grkgggf (psil, psir_r, vk)
end function vlr_grf
@
$V^\mu = \psi^T \tilde{C}^{\mu\rho} \psi_\rho$; remember the reversed
index order in $\tilde{C}$.
<<Implementation of bispinor currents>>=
pure function fggkggr (psil, psir, k) result (j)
type(vector) :: j
type(vectorspinor), intent(in) :: psir
type(bispinor), intent(in) :: psil
type(vector), intent(in) :: k
type(bispinor) :: c_psir0, c_psir1, c_psir2, c_psir3
complex(kind=default) :: kp, km, k12, k12s, ik1, ik2
kp = k%t + k%x(3)
km = k%t - k%x(3)
k12 = k%x(1) + (0,1)*k%x(2)
k12s = k%x(1) - (0,1)*k%x(2)
ik1 = (0,1) * k%x(1)
ik2 = (0,1) * k%x(2)
c_psir0%a(1) = k%x(3) * (psir%psi(1)%a(4) + psir%psi(4)%a(4) &
+ psir%psi(2)%a(3) + (0,1) * psir%psi(3)%a(3)) &
- k12 * (psir%psi(1)%a(3) + psir%psi(4)%a(3)) &
+ k12s * (psir%psi(2)%a(4) + (0,1) * psir%psi(3)%a(4))
c_psir0%a(2) = k%x(3) * (psir%psi(1)%a(3) - psir%psi(4)%a(3) + &
psir%psi(2)%a(4) - (0,1) * psir%psi(3)%a(4)) + &
k12s * (psir%psi(1)%a(4) - psir%psi(4)%a(4)) - &
k12 * (psir%psi(2)%a(3) - (0,1) * psir%psi(3)%a(3))
c_psir0%a(3) = k%x(3) * (-psir%psi(1)%a(2) + psir%psi(4)%a(2) + &
psir%psi(2)%a(1) + (0,1) * psir%psi(3)%a(1)) + &
k12 * (psir%psi(1)%a(1) - psir%psi(4)%a(1)) + &
k12s * (psir%psi(2)%a(2) + (0,1) * psir%psi(3)%a(2))
c_psir0%a(4) = k%x(3) * (-psir%psi(1)%a(1) - psir%psi(4)%a(1) + &
psir%psi(2)%a(2) - (0,1) * psir%psi(3)%a(2)) - &
k12s * (psir%psi(1)%a(2) + psir%psi(4)%a(2)) - &
k12 * (psir%psi(2)%a(1) - (0,1) * psir%psi(3)%a(1))
!!!
c_psir1%a(1) = ik2 * (-psir%psi(1)%a(4) - psir%psi(4)%a(4) - &
psir%psi(2)%a(3) - (0,1) * psir%psi(3)%a(3)) - &
km * (psir%psi(1)%a(3) + psir%psi(4)%a(3)) + &
kp * (psir%psi(2)%a(4) + (0,1) * psir%psi(3)%a(4))
c_psir1%a(2) = ik2 * (-psir%psi(1)%a(3) - psir%psi(2)%a(4) + &
psir%psi(4)%a(3) + (0,1) * psir%psi(3)%a(4)) + &
kp * (psir%psi(1)%a(4) - psir%psi(4)%a(4)) - &
km * (psir%psi(2)%a(3) - (0,1) * psir%psi(3)%a(3))
c_psir1%a(3) = ik2 * (-psir%psi(1)%a(2) + psir%psi(2)%a(1) + &
psir%psi(4)%a(2) + (0,1) * psir%psi(3)%a(1)) + &
kp * (psir%psi(1)%a(1) - psir%psi(4)%a(1)) + &
km * (psir%psi(2)%a(2) + (0,1) * psir%psi(3)%a(2))
c_psir1%a(4) = ik2 * (-psir%psi(1)%a(1) + psir%psi(2)%a(2) - &
psir%psi(4)%a(1) - (0,1) * psir%psi(3)%a(2)) - &
km * (psir%psi(1)%a(2) + psir%psi(4)%a(2)) - &
kp * (psir%psi(2)%a(1) - (0,1) * psir%psi(3)%a(1))
!!!
c_psir2%a(1) = ik1 * (psir%psi(2)%a(3) + psir%psi(1)%a(4) &
+ psir%psi(4)%a(4) + (0,1) * psir%psi(3)%a(3)) - &
((0,1)*km) * (psir%psi(1)%a(3) + psir%psi(4)%a(3)) &
+ kp * (psir%psi(3)%a(4) - (0,1) * psir%psi(2)%a(4))
c_psir2%a(2) = ik1 * (psir%psi(1)%a(3) + psir%psi(2)%a(4) - &
psir%psi(4)%a(3) - (0,1) * psir%psi(3)%a(4)) - &
((0,1)*kp) * (psir%psi(1)%a(4) - psir%psi(4)%a(4)) &
- km * (psir%psi(3)%a(3) + (0,1) * psir%psi(2)%a(3))
c_psir2%a(3) = ik1 * (psir%psi(1)%a(2) - psir%psi(2)%a(1) - &
psir%psi(4)%a(2) - (0,1) * psir%psi(3)%a(1)) + &
((0,1)*kp) * (psir%psi(1)%a(1) - psir%psi(4)%a(1)) &
+ km * (psir%psi(3)%a(2) - (0,1) * psir%psi(2)%a(2))
c_psir2%a(4) = ik1 * (psir%psi(1)%a(1) - psir%psi(2)%a(2) + &
psir%psi(4)%a(1) + (0,1) * psir%psi(3)%a(2)) + &
((0,1)*km) * (psir%psi(1)%a(2) + psir%psi(4)%a(2)) - &
kp * (psir%psi(3)%a(1) + (0,1) * psir%psi(2)%a(1))
!!!
c_psir3%a(1) = k%t * (psir%psi(1)%a(4) + psir%psi(4)%a(4) + &
psir%psi(2)%a(3) + (0,1) * psir%psi(3)%a(3)) - &
k12 * (psir%psi(1)%a(3) + psir%psi(4)%a(3)) - &
k12s * (psir%psi(2)%a(4) + (0,1) * psir%psi(3)%a(4))
c_psir3%a(2) = k%t * (psir%psi(1)%a(3) - psir%psi(4)%a(3) + &
psir%psi(2)%a(4) - (0,1) * psir%psi(3)%a(4)) - &
k12s * (psir%psi(1)%a(4) - psir%psi(4)%a(4)) - &
k12 * (psir%psi(2)%a(3) - (0,1) * psir%psi(3)%a(3))
c_psir3%a(3) = k%t * (-psir%psi(1)%a(2) + psir%psi(2)%a(1) + &
psir%psi(4)%a(2) + (0,1) * psir%psi(3)%a(1)) - &
k12 * (psir%psi(1)%a(1) - psir%psi(4)%a(1)) + &
k12s * (psir%psi(2)%a(2) + (0,1) * psir%psi(3)%a(2))
c_psir3%a(4) = k%t * (-psir%psi(1)%a(1) + psir%psi(2)%a(2) - &
psir%psi(4)%a(1) - (0,1) * psir%psi(3)%a(2)) - &
k12s * (psir%psi(1)%a(2) + psir%psi(4)%a(2)) + &
k12 * (psir%psi(2)%a(1) - (0,1) * psir%psi(3)%a(1))
!!! Because we explicitly multiplied the charge conjugation matrix
!!! we have to omit it from the spinor product and take the
!!! ordinary product!
j%t = 2 * dot_product (conjg (psil%a), c_psir0%a)
j%x(1) = 2 * dot_product (conjg (psil%a), c_psir1%a)
j%x(2) = 2 * dot_product (conjg (psil%a), c_psir2%a)
j%x(3) = 2 * dot_product (conjg (psil%a), c_psir3%a)
end function fggkggr
@
<<Implementation of bispinor currents>>=
pure function v_fgr (g, psil, psir, k) result (j)
type(vector) :: j
complex(kind=default), intent(in) :: g
type(vectorspinor), intent(in) :: psir
type(bispinor), intent(in) :: psil
type(momentum), intent(in) :: k
type(vector) :: vk
vk = k
j = g * fggkggr (psil, psir, vk)
end function v_fgr
@
<<Implementation of bispinor currents>>=
pure function vlr_fgr (gl, gr, psil, psir, k) result (j)
type(vector) :: j
complex(kind=default), intent(in) :: gl, gr
type(vectorspinor), intent(in) :: psir
type(bispinor), intent(in) :: psil
type(bispinor) :: psil_l
type(bispinor) :: psil_r
type(momentum), intent(in) :: k
type(vector) :: vk
vk = k
psil_l%a(1:2) = psil%a(1:2)
psil_l%a(3:4) = 0
psil_r%a(1:2) = 0
psil_r%a(3:4) = psil%a(3:4)
j = gl * fggkggr (psil_l, psir, vk) + gr * fggkggr (psil_r, psir, vk)
end function vlr_fgr
@ \subsection{Gravitino 4-Couplings}
<<Declaration of bispinor currents>>=
public :: f_s2gr, f_svgr, f_slvgr, f_srvgr, f_slrvgr, f_pvgr, f_v2gr, f_v2lrgr
@
<<Implementation of bispinor currents>>=
pure function f_s2gr (g, phi1, phi2, psi) result (phipsi)
type(bispinor) :: phipsi
type(vectorspinor), intent(in) :: psi
complex(kind=default), intent(in) :: g
complex(kind=default), intent(in) :: phi1, phi2
phipsi = phi2 * f_potgr (g, phi1, psi)
end function f_s2gr
@
<<Implementation of bispinor currents>>=
pure function f_svgr (g, phi, v, grav) result (phigrav)
type(bispinor) :: phigrav
type(vectorspinor), intent(in) :: grav
type(vector), intent(in) :: v
complex(kind=default), intent(in) :: g, phi
phigrav = (g * phi) * fgvg5gr (grav, v)
end function f_svgr
@
<<Implementation of bispinor currents>>=
pure function f_slvgr (gl, phi, v, grav) result (phigrav)
type(bispinor) :: phigrav, phidum
type(vectorspinor), intent(in) :: grav
type(vector), intent(in) :: v
complex(kind=default), intent(in) :: gl, phi
phidum = (gl * phi) * fgvg5gr (grav, v)
phigrav%a(1:2) = phidum%a(1:2)
phigrav%a(3:4) = 0
end function f_slvgr
@
<<Implementation of bispinor currents>>=
pure function f_srvgr (gr, phi, v, grav) result (phigrav)
type(bispinor) :: phigrav, phidum
type(vectorspinor), intent(in) :: grav
type(vector), intent(in) :: v
complex(kind=default), intent(in) :: gr, phi
phidum = (gr * phi) * fgvg5gr (grav, v)
phigrav%a(1:2) = 0
phigrav%a(3:4) = phidum%a(3:4)
end function f_srvgr
@
<<Implementation of bispinor currents>>=
pure function f_slrvgr (gl, gr, phi, v, grav) result (phigrav)
type(bispinor) :: phigrav
type(vectorspinor), intent(in) :: grav
type(vector), intent(in) :: v
complex(kind=default), intent(in) :: gl, gr, phi
phigrav = f_slvgr (gl, phi, v, grav) + f_srvgr (gr, phi, v, grav)
end function f_slrvgr
@
<<Implementation of bispinor currents>>=
pure function f_pvgr (g, phi, v, grav) result (phigrav)
type(bispinor) :: phigrav
type(vectorspinor), intent(in) :: grav
type(vector), intent(in) :: v
complex(kind=default), intent(in) :: g, phi
phigrav = (g * phi) * fgvgr (grav, v)
end function f_pvgr
@
<<Implementation of bispinor currents>>=
pure function f_v2gr (g, v1, v2, grav) result (psi)
type(bispinor) :: psi
complex(kind=default), intent(in) :: g
type(vectorspinor), intent(in) :: grav
type(vector), intent(in) :: v1, v2
psi = g * fggvvgr (v2, grav, v1)
end function f_v2gr
@
<<Implementation of bispinor currents>>=
pure function f_v2lrgr (gl, gr, v1, v2, grav) result (psi)
type(bispinor) :: psi
complex(kind=default), intent(in) :: gl, gr
type(vectorspinor), intent(in) :: grav
type(vector), intent(in) :: v1, v2
psi = fggvvgr (v2, grav, v1)
psi%a(1:2) = gl * psi%a(1:2)
psi%a(3:4) = gr * psi%a(3:4)
end function f_v2lrgr
@
<<Declaration of bispinor currents>>=
public :: gr_s2f, gr_svf, gr_pvf, gr_slvf, gr_srvf, gr_slrvf, gr_v2f, gr_v2lrf
@
<<Implementation of bispinor currents>>=
pure function gr_s2f (g, phi1, phi2, psi) result (phipsi)
type(vectorspinor) :: phipsi
type(bispinor), intent(in) :: psi
complex(kind=default), intent(in) :: g
complex(kind=default), intent(in) :: phi1, phi2
phipsi = phi2 * gr_potf (g, phi1, psi)
end function gr_s2f
@
<<Implementation of bispinor currents>>=
pure function gr_svf (g, phi, v, psi) result (phipsi)
type(vectorspinor) :: phipsi
type(bispinor), intent(in) :: psi
type(vector), intent(in) :: v
complex(kind=default), intent(in) :: g, phi
phipsi = (g * phi) * grkggf (psi, v)
end function gr_svf
@
<<Implementation of bispinor currents>>=
pure function gr_slvf (gl, phi, v, psi) result (phipsi)
type(vectorspinor) :: phipsi
type(bispinor), intent(in) :: psi
type(bispinor) :: psi_l
type(vector), intent(in) :: v
complex(kind=default), intent(in) :: gl, phi
psi_l%a(1:2) = psi%a(1:2)
psi_l%a(3:4) = 0
phipsi = (gl * phi) * grkggf (psi_l, v)
end function gr_slvf
@
<<Implementation of bispinor currents>>=
pure function gr_srvf (gr, phi, v, psi) result (phipsi)
type(vectorspinor) :: phipsi
type(bispinor), intent(in) :: psi
type(bispinor) :: psi_r
type(vector), intent(in) :: v
complex(kind=default), intent(in) :: gr, phi
psi_r%a(1:2) = 0
psi_r%a(3:4) = psi%a(3:4)
phipsi = (gr * phi) * grkggf (psi_r, v)
end function gr_srvf
@
<<Implementation of bispinor currents>>=
pure function gr_slrvf (gl, gr, phi, v, psi) result (phipsi)
type(vectorspinor) :: phipsi
type(bispinor), intent(in) :: psi
type(vector), intent(in) :: v
complex(kind=default), intent(in) :: gl, gr, phi
phipsi = gr_slvf (gl, phi, v, psi) + gr_srvf (gr, phi, v, psi)
end function gr_slrvf
@
<<Implementation of bispinor currents>>=
pure function gr_pvf (g, phi, v, psi) result (phipsi)
type(vectorspinor) :: phipsi
type(bispinor), intent(in) :: psi
type(vector), intent(in) :: v
complex(kind=default), intent(in) :: g, phi
phipsi = (g * phi) * grkgf (psi, v)
end function gr_pvf
@
<<Implementation of bispinor currents>>=
pure function gr_v2f (g, v1, v2, psi) result (vvpsi)
type(vectorspinor) :: vvpsi
complex(kind=default), intent(in) :: g
type(bispinor), intent(in) :: psi
type(vector), intent(in) :: v1, v2
vvpsi = g * grkkggf (v2, psi, v1)
end function gr_v2f
@
<<Implementation of bispinor currents>>=
pure function gr_v2lrf (gl, gr, v1, v2, psi) result (vvpsi)
type(vectorspinor) :: vvpsi
complex(kind=default), intent(in) :: gl, gr
type(bispinor), intent(in) :: psi
type(bispinor) :: psi_l, psi_r
type(vector), intent(in) :: v1, v2
psi_l%a(1:2) = psi%a(1:2)
psi_l%a(3:4) = 0
psi_r%a(1:2) = 0
psi_r%a(3:4) = psi%a(3:4)
vvpsi = gl * grkkggf (v2, psi_l, v1) + gr * grkkggf (v2, psi_r, v1)
end function gr_v2lrf
@
<<Declaration of bispinor currents>>=
public :: s2_grf, s2_fgr, sv1_grf, sv2_grf, sv1_fgr, sv2_fgr, &
slv1_grf, slv2_grf, slv1_fgr, slv2_fgr, &
srv1_grf, srv2_grf, srv1_fgr, srv2_fgr, &
slrv1_grf, slrv2_grf, slrv1_fgr, slrv2_fgr, &
pv1_grf, pv2_grf, pv1_fgr, pv2_fgr, v2_grf, v2_fgr, &
v2lr_grf, v2lr_fgr
@
<<Implementation of bispinor currents>>=
pure function s2_grf (g, gravbar, phi, psi) result (j)
complex(kind=default) :: j
complex(kind=default), intent(in) :: g, phi
type(vectorspinor), intent(in) :: gravbar
type(bispinor), intent(in) :: psi
j = phi * pot_grf (g, gravbar, psi)
end function s2_grf
@
<<Implementation of bispinor currents>>=
pure function s2_fgr (g, psibar, phi, grav) result (j)
complex(kind=default) :: j
complex(kind=default), intent(in) :: g, phi
type(bispinor), intent(in) :: psibar
type(vectorspinor), intent(in) :: grav
j = phi * pot_fgr (g, psibar, grav)
end function s2_fgr
@
<<Implementation of bispinor currents>>=
pure function sv1_grf (g, gravbar, v, psi) result (j)
complex(kind=default) :: j
complex(kind=default), intent(in) :: g
type(vectorspinor), intent(in) :: gravbar
type(bispinor), intent(in) :: psi
type(vector), intent(in) :: v
j = g * grg5vgf (gravbar, psi, v)
end function sv1_grf
@
<<Implementation of bispinor currents>>=
pure function slv1_grf (gl, gravbar, v, psi) result (j)
complex(kind=default) :: j
complex(kind=default), intent(in) :: gl
type(vectorspinor), intent(in) :: gravbar
type(bispinor), intent(in) :: psi
type(bispinor) :: psi_l
type(vector), intent(in) :: v
psi_l%a(1:2) = psi%a(1:2)
psi_l%a(3:4) = 0
j = gl * grg5vgf (gravbar, psi_l, v)
end function slv1_grf
@
<<Implementation of bispinor currents>>=
pure function srv1_grf (gr, gravbar, v, psi) result (j)
complex(kind=default) :: j
complex(kind=default), intent(in) :: gr
type(vectorspinor), intent(in) :: gravbar
type(bispinor), intent(in) :: psi
type(bispinor) :: psi_r
type(vector), intent(in) :: v
psi_r%a(1:2) = 0
psi_r%a(3:4) = psi%a(3:4)
j = gr * grg5vgf (gravbar, psi_r, v)
end function srv1_grf
@
<<Implementation of bispinor currents>>=
pure function slrv1_grf (gl, gr, gravbar, v, psi) result (j)
complex(kind=default) :: j
complex(kind=default), intent(in) :: gl, gr
type(vectorspinor), intent(in) :: gravbar
type(bispinor), intent(in) :: psi
type(bispinor) :: psi_l, psi_r
type(vector), intent(in) :: v
psi_l%a(1:2) = psi%a(1:2)
psi_l%a(3:4) = 0
psi_r%a(1:2) = 0
psi_r%a(3:4) = psi%a(3:4)
j = gl * grg5vgf (gravbar, psi_l, v) + gr * grg5vgf (gravbar, psi_r, v)
end function slrv1_grf
@
\begin{subequations}
\begin{align}
C \gamma^0 \gamma^0 = - C \gamma^1 \gamma^1 = - C \gamma^2 \gamma^2
= C \gamma^3 \gamma^3 = C &= \begin{pmatrix}
0 & 1 & 0 & 0 \\ -1 & 0 & 0 & 0 \\ 0 & 0 & 0 & -1 \\ 0 & 0 & 1 & 0
\end{pmatrix} \\
C \gamma^0 \gamma^1 = - C \gamma^1 \gamma^0 &= \begin{pmatrix}
-1 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 \\ 0 & 0 & -1 & 0 \\ 0 & 0 & 0 & 1
\end{pmatrix} \\
C \gamma^0 \gamma^2 = - C \gamma^2 \gamma^0 &= \begin{pmatrix}
-\ii & 0 & 0 & 0 \\ 0 & -\ii & 0 & 0 \\ 0 & 0 & -\ii & 0 \\ 0 & 0 &
0 & -\ii \end{pmatrix} \\
C \gamma^0 \gamma^3 = - C \gamma^3 \gamma^0 &= \begin{pmatrix}
0 & 1 & 0 & 0 \\ 1 & 0 & 0 & 0 \\ 0 & 0 & 0 & 1 \\ 0 & 0 & 1 & 0
\end{pmatrix} \\
C \gamma^1 \gamma^2 = - C \gamma^2 \gamma^1 &= \begin{pmatrix}
0 & \ii & 0 & 0 \\ \ii & 0 & 0 & 0 \\ 0 & 0 & 0 & -\ii \\ 0 & 0 &
-\ii & 0 \end{pmatrix} \\
C \gamma^1 \gamma^3 = - C \gamma^3 \gamma^1 &= \begin{pmatrix}
-1 & 0 & 0 & 0 \\ 0 & -1 & 0 & 0 \\ 0 & 0 & 1 & 0 \\ 0 & 0 & 0 & 1
\end{pmatrix} \\
C \gamma^2 \gamma^3 = - C \gamma^3 \gamma^2 &= \begin{pmatrix}
-\ii & 0 & 0 & 0 \\ 0 & \ii & 0 & 0 \\ 0 & 0 & \ii & 0 \\ 0 & 0 & 0
& -\ii \end{pmatrix}
\end{align}
\end{subequations}
@
<<Implementation of bispinor currents>>=
pure function sv2_grf (g, gravbar, phi, psi) result (j)
type(vector) :: j
complex(kind=default), intent(in) :: g, phi
type(vectorspinor), intent(in) :: gravbar
type(bispinor), intent(in) :: psi
type(vectorspinor) :: g0_psi, g1_psi, g2_psi, g3_psi
g0_psi%psi(1)%a(1:2) = - psi%a(1:2)
g0_psi%psi(1)%a(3:4) = psi%a(3:4)
g0_psi%psi(2)%a(1) = psi%a(2)
g0_psi%psi(2)%a(2) = psi%a(1)
g0_psi%psi(2)%a(3) = psi%a(4)
g0_psi%psi(2)%a(4) = psi%a(3)
g0_psi%psi(3)%a(1) = (0,-1) * psi%a(2)
g0_psi%psi(3)%a(2) = (0,1) * psi%a(1)
g0_psi%psi(3)%a(3) = (0,-1) * psi%a(4)
g0_psi%psi(3)%a(4) = (0,1) * psi%a(3)
g0_psi%psi(4)%a(1) = psi%a(1)
g0_psi%psi(4)%a(2) = - psi%a(2)
g0_psi%psi(4)%a(3) = psi%a(3)
g0_psi%psi(4)%a(4) = - psi%a(4)
g1_psi%psi(1)%a(1:4) = - g0_psi%psi(2)%a(1:4)
g1_psi%psi(2)%a(1:4) = - g0_psi%psi(1)%a(1:4)
g1_psi%psi(3)%a(1) = (0,1) * psi%a(1)
g1_psi%psi(3)%a(2) = (0,-1) * psi%a(2)
g1_psi%psi(3)%a(3) = (0,-1) * psi%a(3)
g1_psi%psi(3)%a(4) = (0,1) * psi%a(4)
g1_psi%psi(4)%a(1) = - psi%a(2)
g1_psi%psi(4)%a(2) = psi%a(1)
g1_psi%psi(4)%a(3) = psi%a(4)
g1_psi%psi(4)%a(4) = - psi%a(3)
g2_psi%psi(1)%a(1:4) = - g0_psi%psi(3)%a(1:4)
g2_psi%psi(2)%a(1:4) = - g1_psi%psi(3)%a(1:4)
g2_psi%psi(3)%a(1:4) = - g0_psi%psi(1)%a(1:4)
g2_psi%psi(4)%a(1) = (0,1) * psi%a(2)
g2_psi%psi(4)%a(2) = (0,1) * psi%a(1)
g2_psi%psi(4)%a(3) = (0,-1) * psi%a(4)
g2_psi%psi(4)%a(4) = (0,-1) * psi%a(3)
g3_psi%psi(1)%a(1:4) = - g0_psi%psi(4)%a(1:4)
g3_psi%psi(2)%a(1:4) = - g1_psi%psi(4)%a(1:4)
g3_psi%psi(3)%a(1:4) = - g2_psi%psi(4)%a(1:4)
g3_psi%psi(4)%a(1:4) = - g0_psi%psi(1)%a(1:4)
j%t = (g * phi) * (gravbar * g0_psi)
j%x(1) = (g * phi) * (gravbar * g1_psi)
j%x(2) = (g * phi) * (gravbar * g2_psi)
j%x(3) = (g * phi) * (gravbar * g3_psi)
end function sv2_grf
@
<<Implementation of bispinor currents>>=
pure function slv2_grf (gl, gravbar, phi, psi) result (j)
type(vector) :: j
complex(kind=default), intent(in) :: gl, phi
type(vectorspinor), intent(in) :: gravbar
type(bispinor), intent(in) :: psi
type(bispinor) :: psi_l
psi_l%a(1:2) = psi%a(1:2)
psi_l%a(3:4) = 0
j = sv2_grf (gl, gravbar, phi, psi_l)
end function slv2_grf
@
<<Implementation of bispinor currents>>=
pure function srv2_grf (gr, gravbar, phi, psi) result (j)
type(vector) :: j
complex(kind=default), intent(in) :: gr, phi
type(vectorspinor), intent(in) :: gravbar
type(bispinor), intent(in) :: psi
type(bispinor) :: psi_r
psi_r%a(1:2) = 0
psi_r%a(3:4) = psi%a(3:4)
j = sv2_grf (gr, gravbar, phi, psi_r)
end function srv2_grf
@
<<Implementation of bispinor currents>>=
pure function slrv2_grf (gl, gr, gravbar, phi, psi) result (j)
type(vector) :: j
complex(kind=default), intent(in) :: gl, gr, phi
type(vectorspinor), intent(in) :: gravbar
type(bispinor), intent(in) :: psi
type(bispinor) :: psi_l, psi_r
psi_l%a(1:2) = psi%a(1:2)
psi_l%a(3:4) = 0
psi_r%a(1:2) = 0
psi_r%a(3:4) = psi%a(3:4)
j = sv2_grf (gl, gravbar, phi, psi_l) + sv2_grf (gr, gravbar, phi, psi_r)
end function slrv2_grf
@
<<Implementation of bispinor currents>>=
pure function sv1_fgr (g, psibar, v, grav) result (j)
complex(kind=default) :: j
complex(kind=default), intent(in) :: g
type(bispinor), intent(in) :: psibar
type(vectorspinor), intent(in) :: grav
type(vector), intent(in) :: v
j = g * fg5gkgr (psibar, grav, v)
end function sv1_fgr
@
<<Implementation of bispinor currents>>=
pure function slv1_fgr (gl, psibar, v, grav) result (j)
complex(kind=default) :: j
complex(kind=default), intent(in) :: gl
type(bispinor), intent(in) :: psibar
type(bispinor) :: psibar_l
type(vectorspinor), intent(in) :: grav
type(vector), intent(in) :: v
psibar_l%a(1:2) = psibar%a(1:2)
psibar_l%a(3:4) = 0
j = gl * fg5gkgr (psibar_l, grav, v)
end function slv1_fgr
@
<<Implementation of bispinor currents>>=
pure function srv1_fgr (gr, psibar, v, grav) result (j)
complex(kind=default) :: j
complex(kind=default), intent(in) :: gr
type(bispinor), intent(in) :: psibar
type(bispinor) :: psibar_r
type(vectorspinor), intent(in) :: grav
type(vector), intent(in) :: v
psibar_r%a(1:2) = 0
psibar_r%a(3:4) = psibar%a(3:4)
j = gr * fg5gkgr (psibar_r, grav, v)
end function srv1_fgr
@
<<Implementation of bispinor currents>>=
pure function slrv1_fgr (gl, gr, psibar, v, grav) result (j)
complex(kind=default) :: j
complex(kind=default), intent(in) :: gl, gr
type(bispinor), intent(in) :: psibar
type(bispinor) :: psibar_l, psibar_r
type(vectorspinor), intent(in) :: grav
type(vector), intent(in) :: v
psibar_l%a(1:2) = psibar%a(1:2)
psibar_l%a(3:4) = 0
psibar_r%a(1:2) = 0
psibar_r%a(3:4) = psibar%a(3:4)
j = gl * fg5gkgr (psibar_l, grav, v) + gr * fg5gkgr (psibar_r, grav, v)
end function slrv1_fgr
@
<<Implementation of bispinor currents>>=
pure function sv2_fgr (g, psibar, phi, grav) result (j)
type(vector) :: j
complex(kind=default), intent(in) :: g, phi
type(bispinor), intent(in) :: psibar
type(vectorspinor), intent(in) :: grav
type(bispinor) :: g0_grav, g1_grav, g2_grav, g3_grav
g0_grav%a(1) = -grav%psi(1)%a(1) + grav%psi(2)%a(2) - &
(0,1) * grav%psi(3)%a(2) + grav%psi(4)%a(1)
g0_grav%a(2) = -grav%psi(1)%a(2) + grav%psi(2)%a(1) + &
(0,1) * grav%psi(3)%a(1) - grav%psi(4)%a(2)
g0_grav%a(3) = grav%psi(1)%a(3) + grav%psi(2)%a(4) - &
(0,1) * grav%psi(3)%a(4) + grav%psi(4)%a(3)
g0_grav%a(4) = grav%psi(1)%a(4) + grav%psi(2)%a(3) + &
(0,1) * grav%psi(3)%a(3) - grav%psi(4)%a(4)
!!!
g1_grav%a(1) = grav%psi(1)%a(2) - grav%psi(2)%a(1) + &
(0,1) * grav%psi(3)%a(1) - grav%psi(4)%a(2)
g1_grav%a(2) = grav%psi(1)%a(1) - grav%psi(2)%a(2) - &
(0,1) * grav%psi(3)%a(2) + grav%psi(4)%a(1)
g1_grav%a(3) = grav%psi(1)%a(4) + grav%psi(2)%a(3) - &
(0,1) * grav%psi(3)%a(3) + grav%psi(4)%a(4)
g1_grav%a(4) = grav%psi(1)%a(3) + grav%psi(2)%a(4) + &
(0,1) * grav%psi(3)%a(4) - grav%psi(4)%a(3)
!!!
g2_grav%a(1) = (0,1) * (-grav%psi(1)%a(2) - grav%psi(2)%a(1) + &
grav%psi(4)%a(2)) - grav%psi(3)%a(1)
g2_grav%a(2) = (0,1) * (grav%psi(1)%a(1) + grav%psi(2)%a(2) + &
grav%psi(4)%a(1)) - grav%psi(3)%a(2)
g2_grav%a(3) = (0,1) * (-grav%psi(1)%a(4) + grav%psi(2)%a(3) - &
grav%psi(4)%a(4)) + grav%psi(3)%a(3)
g2_grav%a(4) = (0,1) * (grav%psi(1)%a(3) - grav%psi(2)%a(4) - &
grav%psi(4)%a(3)) + grav%psi(3)%a(4)
!!!
g3_grav%a(1) = -grav%psi(1)%a(2) + grav%psi(2)%a(2) - &
(0,1) * grav%psi(3)%a(2) - grav%psi(4)%a(1)
g3_grav%a(2) = grav%psi(1)%a(1) - grav%psi(2)%a(1) - &
(0,1) * grav%psi(3)%a(1) - grav%psi(4)%a(2)
g3_grav%a(3) = -grav%psi(1)%a(2) - grav%psi(2)%a(4) + &
(0,1) * grav%psi(3)%a(4) + grav%psi(4)%a(3)
g3_grav%a(4) = -grav%psi(1)%a(4) + grav%psi(2)%a(3) + &
(0,1) * grav%psi(3)%a(3) + grav%psi(4)%a(4)
j%t = (g * phi) * (psibar * g0_grav)
j%x(1) = (g * phi) * (psibar * g1_grav)
j%x(2) = (g * phi) * (psibar * g2_grav)
j%x(3) = (g * phi) * (psibar * g3_grav)
end function sv2_fgr
@
<<Implementation of bispinor currents>>=
pure function slv2_fgr (gl, psibar, phi, grav) result (j)
type(vector) :: j
complex(kind=default), intent(in) :: gl, phi
type(bispinor), intent(in) :: psibar
type(bispinor) :: psibar_l
type(vectorspinor), intent(in) :: grav
psibar_l%a(1:2) = psibar%a(1:2)
psibar_l%a(3:4) = 0
j = sv2_fgr (gl, psibar_l, phi, grav)
end function slv2_fgr
@
<<Implementation of bispinor currents>>=
pure function srv2_fgr (gr, psibar, phi, grav) result (j)
type(vector) :: j
complex(kind=default), intent(in) :: gr, phi
type(bispinor), intent(in) :: psibar
type(bispinor) :: psibar_r
type(vectorspinor), intent(in) :: grav
psibar_r%a(1:2) = 0
psibar_r%a(3:4) = psibar%a(3:4)
j = sv2_fgr (gr, psibar_r, phi, grav)
end function srv2_fgr
@
<<Implementation of bispinor currents>>=
pure function slrv2_fgr (gl, gr, psibar, phi, grav) result (j)
type(vector) :: j
complex(kind=default), intent(in) :: gl, gr, phi
type(bispinor), intent(in) :: psibar
type(bispinor) :: psibar_l, psibar_r
type(vectorspinor), intent(in) :: grav
psibar_l%a(1:2) = psibar%a(1:2)
psibar_l%a(3:4) = 0
psibar_r%a(1:2) = 0
psibar_r%a(3:4) = psibar%a(3:4)
j = sv2_fgr (gl, psibar_l, phi, grav) + sv2_fgr (gr, psibar_r, phi, grav)
end function slrv2_fgr
@
<<Implementation of bispinor currents>>=
pure function pv1_grf (g, gravbar, v, psi) result (j)
complex(kind=default) :: j
complex(kind=default), intent(in) :: g
type(vectorspinor), intent(in) :: gravbar
type(bispinor), intent(in) :: psi
type(vector), intent(in) :: v
j = g * grvgf (gravbar, psi, v)
end function pv1_grf
@
<<Implementation of bispinor currents>>=
pure function pv2_grf (g, gravbar, phi, psi) result (j)
type(vector) :: j
complex(kind=default), intent(in) :: g, phi
type(vectorspinor), intent(in) :: gravbar
type(bispinor), intent(in) :: psi
type(bispinor) :: g5_psi
g5_psi%a(1:2) = - psi%a(1:2)
g5_psi%a(3:4) = psi%a(3:4)
j = sv2_grf (g, gravbar, phi, g5_psi)
end function pv2_grf
@
<<Implementation of bispinor currents>>=
pure function pv1_fgr (g, psibar, v, grav) result (j)
complex(kind=default) :: j
complex(kind=default), intent(in) :: g
type(bispinor), intent(in) :: psibar
type(vectorspinor), intent(in) :: grav
type(vector), intent(in) :: v
j = g * fgkgr (psibar, grav, v)
end function pv1_fgr
@
<<Implementation of bispinor currents>>=
pure function pv2_fgr (g, psibar, phi, grav) result (j)
type(vector) :: j
complex(kind=default), intent(in) :: g, phi
type(vectorspinor), intent(in) :: grav
type(bispinor), intent(in) :: psibar
type(bispinor) :: psibar_g5
psibar_g5%a(1:2) = - psibar%a(1:2)
psibar_g5%a(3:4) = psibar%a(3:4)
j = sv2_fgr (g, psibar_g5, phi, grav)
end function pv2_fgr
@
<<Implementation of bispinor currents>>=
pure function v2_grf (g, gravbar, v, psi) result (j)
type(vector) :: j
complex(kind=default), intent(in) :: g
type(vectorspinor), intent(in) :: gravbar
type(bispinor), intent(in) :: psi
type(vector), intent(in) :: v
j = -g * grkgggf (gravbar, psi, v)
end function v2_grf
@
<<Implementation of bispinor currents>>=
pure function v2lr_grf (gl, gr, gravbar, v, psi) result (j)
type(vector) :: j
complex(kind=default), intent(in) :: gl, gr
type(vectorspinor), intent(in) :: gravbar
type(bispinor), intent(in) :: psi
type(bispinor) :: psi_l, psi_r
type(vector), intent(in) :: v
psi_l%a(1:2) = psi%a(1:2)
psi_l%a(3:4) = 0
psi_r%a(1:2) = 0
psi_r%a(3:4) = psi%a(3:4)
j = -(gl * grkgggf (gravbar, psi_l, v) + gr * grkgggf (gravbar, psi_r, v))
end function v2lr_grf
@
<<Implementation of bispinor currents>>=
pure function v2_fgr (g, psibar, v, grav) result (j)
type(vector) :: j
complex(kind=default), intent(in) :: g
type(vectorspinor), intent(in) :: grav
type(bispinor), intent(in) :: psibar
type(vector), intent(in) :: v
j = -g * fggkggr (psibar, grav, v)
end function v2_fgr
@
<<Implementation of bispinor currents>>=
pure function v2lr_fgr (gl, gr, psibar, v, grav) result (j)
type(vector) :: j
complex(kind=default), intent(in) :: gl, gr
type(vectorspinor), intent(in) :: grav
type(bispinor), intent(in) :: psibar
type(bispinor) :: psibar_l, psibar_r
type(vector), intent(in) :: v
psibar_l%a(1:2) = psibar%a(1:2)
psibar_l%a(3:4) = 0
psibar_r%a(1:2) = 0
psibar_r%a(3:4) = psibar%a(3:4)
j = -(gl * fggkggr (psibar_l, grav, v) + gr * fggkggr (psibar_r, grav, v))
end function v2lr_fgr
@ \subsection{On Shell Wave Functions}
<<Declaration of bispinor on shell wave functions>>=
public :: u, v, ghost
@
\begin{subequations}
\begin{align}
\chi_+(\vec p) &=
\frac{1}{\sqrt{2|\vec p|(|\vec p|+p_3)}}
\begin{pmatrix} |\vec p|+p_3 \\ p_1 + \ii p_2 \end{pmatrix} \\
\chi_-(\vec p) &=
\frac{1}{\sqrt{2|\vec p|(|\vec p|+p_3)}}
\begin{pmatrix} - p_1 + \ii p_2 \\ |\vec p|+p_3 \end{pmatrix}
\end{align}
\end{subequations}
@
\begin{equation}
u_\pm(p) =
\begin{pmatrix}
\sqrt{p_0\mp|\vec p|} \cdot \chi_\pm(\vec p) \\
\sqrt{p_0\pm|\vec p|} \cdot \chi_\pm(\vec p)
\end{pmatrix}
\end{equation}
<<Implementation of bispinor on shell wave functions>>=
pure function u (mass, p, s) result (psi)
type(bispinor) :: psi
real(kind=default), intent(in) :: mass
type(momentum), intent(in) :: p
integer, intent(in) :: s
complex(kind=default), dimension(2) :: chip, chim
real(kind=default) :: pabs, norm, delta, m
m = abs(mass)
pabs = sqrt (dot_product (p%x, p%x))
if (m < epsilon (m) * pabs) then
delta = 0
else
delta = sqrt (max (p%t - pabs, 0._default))
end if
if (pabs + p%x(3) <= 1000 * epsilon (pabs) * pabs) then
chip = (/ cmplx ( 0.0, 0.0, kind=default), &
cmplx ( 1.0, 0.0, kind=default) /)
chim = (/ cmplx (-1.0, 0.0, kind=default), &
cmplx ( 0.0, 0.0, kind=default) /)
else
norm = 1 / sqrt (2*pabs*(pabs + p%x(3)))
chip = norm * (/ cmplx (pabs + p%x(3), kind=default), &
cmplx (p%x(1), p%x(2), kind=default) /)
chim = norm * (/ cmplx (-p%x(1), p%x(2), kind=default), &
cmplx (pabs + p%x(3), kind=default) /)
end if
if (s > 0) then
psi%a(1:2) = delta * chip
psi%a(3:4) = sqrt (p%t + pabs) * chip
else
psi%a(1:2) = sqrt (p%t + pabs) * chim
psi%a(3:4) = delta * chim
end if
pabs = m ! make the compiler happy and use m
if (mass < 0) then
psi%a(1:2) = - imago * psi%a(1:2)
psi%a(3:4) = + imago * psi%a(3:4)
end if
end function u
@
\begin{equation}
v_\pm(p) =
\begin{pmatrix}
\mp\sqrt{p_0\pm|\vec p|} \cdot \chi_\mp(\vec p) \\
\pm\sqrt{p_0\mp|\vec p|} \cdot \chi_\mp(\vec p)
\end{pmatrix}
\end{equation}
<<Implementation of bispinor on shell wave functions>>=
pure function v (mass, p, s) result (psi)
type(bispinor) :: psi
real(kind=default), intent(in) :: mass
type(momentum), intent(in) :: p
integer, intent(in) :: s
complex(kind=default), dimension(2) :: chip, chim
real(kind=default) :: pabs, norm, delta, m
pabs = sqrt (dot_product (p%x, p%x))
m = abs(mass)
if (m < epsilon (m) * pabs) then
delta = 0
else
delta = sqrt (max (p%t - pabs, 0._default))
end if
if (pabs + p%x(3) <= 1000 * epsilon (pabs) * pabs) then
chip = (/ cmplx ( 0.0, 0.0, kind=default), &
cmplx ( 1.0, 0.0, kind=default) /)
chim = (/ cmplx (-1.0, 0.0, kind=default), &
cmplx ( 0.0, 0.0, kind=default) /)
else
norm = 1 / sqrt (2*pabs*(pabs + p%x(3)))
chip = norm * (/ cmplx (pabs + p%x(3), kind=default), &
cmplx (p%x(1), p%x(2), kind=default) /)
chim = norm * (/ cmplx (-p%x(1), p%x(2), kind=default), &
cmplx (pabs + p%x(3), kind=default) /)
end if
if (s > 0) then
psi%a(1:2) = - sqrt (p%t + pabs) * chim
psi%a(3:4) = delta * chim
else
psi%a(1:2) = delta * chip
psi%a(3:4) = - sqrt (p%t + pabs) * chip
end if
pabs = m ! make the compiler happy and use m
if (mass < 0) then
psi%a(1:2) = - imago * psi%a(1:2)
psi%a(3:4) = + imago * psi%a(3:4)
end if
end function v
@
<<Implementation of bispinor on shell wave functions>>=
pure function ghost (m, p, s) result (psi)
type(bispinor) :: psi
real(kind=default), intent(in) :: m
type(momentum), intent(in) :: p
integer, intent(in) :: s
psi%a(:) = 0
select case (s)
case (1)
psi%a(1) = 1
psi%a(2:4) = 0
case (2)
psi%a(1) = 0
psi%a(2) = 1
psi%a(3:4) = 0
case (3)
psi%a(1:2) = 0
psi%a(3) = 1
psi%a(4) = 0
case (4)
psi%a(1:3) = 0
psi%a(4) = 1
case (5)
psi%a(1) = 1.4
psi%a(2) = - 2.3
psi%a(3) = - 71.5
psi%a(4) = 0.1
end select
end function ghost
@
\subsection{Off Shell Wave Functions}
This is the same as for the Dirac fermions except that the expressions for
[ubar] and [vbar] are missing.
<<Declaration of bispinor off shell wave functions>>=
public :: brs_u, brs_v
@
In momentum space we have:
\begin{equation}
brs u(p)=(-i) (\fmslash p-m)u(p)
\end{equation}
<<Implementation of bispinor off shell wave functions>>=
pure function brs_u (m, p, s) result (dpsi)
type(bispinor) :: dpsi, psi
real(kind=default), intent(in) :: m
type(momentum), intent(in) :: p
integer, intent(in) :: s
type (vector)::vp
complex(kind=default), parameter :: one = (1, 0)
vp=p
psi=u(m,p,s)
dpsi=cmplx(0.0,-1.0)*(f_vf(one,vp,psi)-m*psi)
end function brs_u
@
\begin{equation}
brs v(p)=i (\fmslash p+m)v(p)
\end{equation}
<<Implementation of bispinor off shell wave functions>>=
pure function brs_v (m, p, s) result (dpsi)
type(bispinor) :: dpsi, psi
real(kind=default), intent(in) :: m
type(momentum), intent(in) :: p
integer, intent(in) :: s
type (vector)::vp
complex(kind=default), parameter :: one = (1, 0)
vp=p
psi=v(m,p,s)
dpsi=cmplx(0.0,1.0)*(f_vf(one,vp,psi)+m*psi)
end function brs_v
@ \subsection{Propagators}
<<Declaration of bispinor propagators>>=
public :: pr_psi, pr_grav
public :: pj_psi, pg_psi
@
\begin{equation}
\frac{\ii(-\fmslash{p}+m)}{p^2-m^2+\ii m\Gamma}\psi
\end{equation}
NB: the sign of the momentum comes about because all momenta are
treated as \emph{outgoing} and the particle charge flow is therefore
opposite to the momentum.
<<Implementation of bispinor propagators>>=
pure function pr_psi (p, m, w, cms, psi) result (ppsi)
type(bispinor) :: ppsi
type(momentum), intent(in) :: p
real(kind=default), intent(in) :: m, w
type(bispinor), intent(in) :: psi
logical, intent(in) :: cms
type(vector) :: vp
complex(kind=default), parameter :: one = (1, 0)
complex(kind=default) :: num_mass
vp = p
if (cms) then
num_mass = sqrt(cmplx(m**2, -m*w, kind=default))
else
num_mass = cmplx (m, 0, kind=default)
end if
ppsi = (1 / cmplx (p*p - m**2, m*w, kind=default)) &
* (- f_vf (one, vp, psi) + num_mass * psi)
end function pr_psi
@
\begin{equation}
\sqrt{\frac{\pi}{M\Gamma}}
(-\fmslash{p}+m)\psi
\end{equation}
<<Implementation of bispinor propagators>>=
pure function pj_psi (p, m, w, psi) result (ppsi)
type(bispinor) :: ppsi
type(momentum), intent(in) :: p
real(kind=default), intent(in) :: m, w
type(bispinor), intent(in) :: psi
type(vector) :: vp
complex(kind=default), parameter :: one = (1, 0)
vp = p
ppsi = (0, -1) * sqrt (PI / m / w) * (- f_vf (one, vp, psi) + m * psi)
end function pj_psi
@
<<Implementation of bispinor propagators>>=
pure function pg_psi (p, m, w, psi) result (ppsi)
type(bispinor) :: ppsi
type(momentum), intent(in) :: p
real(kind=default), intent(in) :: m, w
type(bispinor), intent(in) :: psi
type(vector) :: vp
complex(kind=default), parameter :: one = (1, 0)
vp = p
ppsi = gauss (p*p, m, w) * (- f_vf (one, vp, psi) + m * psi)
end function pg_psi
@
\begin{equation}
\dfrac{\ii\biggl\{(-\fmslash{p} + m)\left(-\eta_{\mu\nu} + \dfrac{p_\mu
p_\nu}{m^2}\right) + \dfrac{1}{3} \left(\gamma_\mu -\dfrac{p_\mu}{m}\right)
(\fmslash{p} + m)\left(\gamma_\nu -
\dfrac{p_\nu}{m}\right)\biggr\}}{p^2 - m^2 + \ii m
\Gamma} \; \psi^\nu
\end{equation}
<<Implementation of bispinor propagators>>=
pure function pr_grav (p, m, w, grav) result (propgrav)
type(vectorspinor) :: propgrav
type(momentum), intent(in) :: p
real(kind=default), intent(in) :: m, w
type(vectorspinor), intent(in) :: grav
type(vector) :: vp
type(bispinor) :: pgrav, ggrav, ggrav1, ggrav2, ppgrav
type(vectorspinor) :: etagrav_dum, etagrav, pppgrav, &
gg_grav_dum, gg_grav
complex(kind=default), parameter :: one = (1, 0)
real(kind=default) :: minv
integer :: i
vp = p
minv = 1/m
pgrav = p%t * grav%psi(1) - p%x(1) * grav%psi(2) - &
p%x(2) * grav%psi(3) - p%x(3) * grav%psi(4)
ggrav%a(1) = grav%psi(1)%a(3) - grav%psi(2)%a(4) + (0,1) * &
grav%psi(3)%a(4) - grav%psi(4)%a(3)
ggrav%a(2) = grav%psi(1)%a(4) - grav%psi(2)%a(3) - (0,1) * &
grav%psi(3)%a(3) + grav%psi(4)%a(4)
ggrav%a(3) = grav%psi(1)%a(1) + grav%psi(2)%a(2) - (0,1) * &
grav%psi(3)%a(2) + grav%psi(4)%a(1)
ggrav%a(4) = grav%psi(1)%a(2) + grav%psi(2)%a(1) + (0,1) * &
grav%psi(3)%a(1) - grav%psi(4)%a(2)
ggrav1 = ggrav - minv * pgrav
ggrav2 = f_vf (one, vp, ggrav1) + m * ggrav - pgrav
ppgrav = (-minv**2) * f_vf (one, vp, pgrav) + minv * pgrav
do i = 1, 4
etagrav_dum%psi(i) = f_vf (one, vp, grav%psi(i))
end do
etagrav = etagrav_dum - m * grav
pppgrav%psi(1) = p%t * ppgrav
pppgrav%psi(2) = p%x(1) * ppgrav
pppgrav%psi(3) = p%x(2) * ppgrav
pppgrav%psi(4) = p%x(3) * ppgrav
gg_grav_dum%psi(1) = p%t * ggrav2
gg_grav_dum%psi(2) = p%x(1) * ggrav2
gg_grav_dum%psi(3) = p%x(2) * ggrav2
gg_grav_dum%psi(4) = p%x(3) * ggrav2
gg_grav = gr_potf (one, one, ggrav2) - minv * gg_grav_dum
propgrav = (1 / cmplx (p*p - m**2, m*w, kind=default)) * &
(etagrav + pppgrav + (1/3.0_default) * gg_grav)
end function pr_grav
@
\section{Polarization vectorspinors}
Here we construct the wavefunctions for (massive) gravitinos out of
the wavefunctions of (massive) vectorbosons and (massive) Majorana
fermions.
\begin{subequations}
\begin{align}
\psi^\mu_{(u; 3/2)} (k) &= \; \epsilon^\mu_+ (k) \cdot u (k, +) \\
\psi^\mu_{(u; 1/2)} (k) &= \; \sqrt{\dfrac{1}{3}} \, \epsilon^\mu_+ (k)
\cdot u (k, -) + \sqrt{\dfrac{2}{3}} \, \epsilon^\mu_0 (k) \cdot
u (k, +) \\
\psi^\mu_{(u; -1/2)} (k) &= \; \sqrt{\dfrac{2}{3}} \, \epsilon^\mu_0 (k)
\cdot u (k, -) + \sqrt{\dfrac{1}{3}} \, \epsilon^\mu_- (k) \cdot
u (k, +) \\
\psi^\mu_{(u; -3/2)} (k) &= \; \epsilon^\mu_- (k) \cdot u (k, -)
\end{align}
\end{subequations}
and in the same manner for $\psi^\mu_{(v; s)}$ with $u$ replaced by
$v$ and with the conjugated polarization vectors. These gravitino
wavefunctions obey the Dirac equation, they are transverse and they
fulfill the irreducibility condition
\begin{equation}
\gamma_\mu \psi^\mu_{(u/v; s)} = 0 .
\end{equation}
<<[[omega_vspinor_polarizations.f90]]>>=
<<Copyleft>>
module omega_vspinor_polarizations
use kinds
use constants
use omega_vectors
use omega_bispinors
use omega_bispinor_couplings
use omega_vectorspinors
implicit none
<<Declaration of polarization vectorspinors>>
integer, parameter, public :: omega_vspinor_pols_2010_01_A = 0
contains
<<Implementation of polarization vectorspinors>>
end module omega_vspinor_polarizations
@
<<Declaration of polarization vectorspinors>>=
public :: ueps, veps
private :: eps
private :: outer_product
@
Here we implement the polarization vectors for vectorbosons with
trigonometric functions, without the rotating of components done in
HELAS~\cite{HELAS}. These are only used for generating the
polarization vectorspinors.
\begin{subequations}
\begin{align}
\epsilon^\mu_+(k) &=
\frac{- e^{+\ii\phi}}{\sqrt{2}}
\left(0; \cos\theta\cos\phi - \ii\sin\phi,
\cos\theta\sin\phi + \ii\cos\phi,
-\sin\theta \right) \\
\epsilon^\mu_-(k) &=
\frac{e^{-\ii\phi}}{\sqrt{2}}
\left(0; \cos\theta\cos\phi + \ii \sin\phi,
\cos\theta\sin\phi - \ii \cos\phi,
- \sin\theta \right) \\
\epsilon^\mu_0(k) &=
\frac{1}{m} \left(|\vec k|; k^0\sin\theta\cos\phi,
k^0\sin\theta\sin\phi,
k^0\cos\theta\right)
\end{align}
\end{subequations}
Determining the mass from the momenta is a numerically haphazardous for
light particles. Therefore, we accept some redundancy and pass the
mass explicitely. For the case that the momentum lies totally in the
$z$-direction we take the convention $\cos\phi=1$ and $\sin\phi=0$.
<<Implementation of polarization vectorspinors>>=
pure function eps (mass, k, s) result (e)
type(vector) :: e
real(kind=default), intent(in) :: mass
type(momentum), intent(in) :: k
integer, intent(in) :: s
real(kind=default) :: kabs, kabs2, sqrt2, m
real(kind=default) :: cos_phi, sin_phi, cos_th, sin_th
complex(kind=default) :: epiphi, emiphi
sqrt2 = sqrt (2.0_default)
kabs2 = dot_product (k%x, k%x)
m = abs(mass)
if (kabs2 > 0) then
kabs = sqrt (kabs2)
if ((k%x(1) == 0) .and. (k%x(2) == 0)) then
cos_phi = 1
sin_phi = 0
else
cos_phi = k%x(1) / sqrt(k%x(1)**2 + k%x(2)**2)
sin_phi = k%x(2) / sqrt(k%x(1)**2 + k%x(2)**2)
end if
cos_th = k%x(3) / kabs
sin_th = sqrt(1 - cos_th**2)
epiphi = cos_phi + (0,1) * sin_phi
emiphi = cos_phi - (0,1) * sin_phi
e%t = 0
e%x = 0
select case (s)
case (1)
e%x(1) = epiphi * (-cos_th * cos_phi + (0,1) * sin_phi) / sqrt2
e%x(2) = epiphi * (-cos_th * sin_phi - (0,1) * cos_phi) / sqrt2
e%x(3) = epiphi * ( sin_th / sqrt2)
case (-1)
e%x(1) = emiphi * ( cos_th * cos_phi + (0,1) * sin_phi) / sqrt2
e%x(2) = emiphi * ( cos_th * sin_phi - (0,1) * cos_phi) / sqrt2
e%x(3) = emiphi * (-sin_th / sqrt2)
case (0)
if (m > 0) then
e%t = kabs / m
e%x = k%t / (m*kabs) * k%x
end if
case (4)
if (m > 0) then
e = (1 / m) * k
else
e = (1 / k%t) * k
end if
end select
else !!! for particles in their rest frame defined to be
!!! polarized along the 3-direction
e%t = 0
e%x = 0
select case (s)
case (1)
e%x(1) = cmplx ( - 1, 0, kind=default) / sqrt2
e%x(2) = cmplx ( 0, 1, kind=default) / sqrt2
case (-1)
e%x(1) = cmplx ( 1, 0, kind=default) / sqrt2
e%x(2) = cmplx ( 0, 1, kind=default) / sqrt2
case (0)
if (m > 0) then
e%x(3) = 1
end if
case (4)
if (m > 0) then
e = (1 / m) * k
else
e = (1 / k%t) * k
end if
end select
end if
end function eps
@
<<Implementation of polarization vectorspinors>>=
pure function ueps (m, k, s) result (t)
type(vectorspinor) :: t
real(kind=default), intent(in) :: m
type(momentum), intent(in) :: k
integer, intent(in) :: s
integer :: i
type(vector) :: ep, e0, em
type(bispinor) :: up, um
do i = 1, 4
t%psi(i)%a = 0
end do
select case (s)
case (2)
ep = eps (m, k, 1)
up = u (m, k, 1)
t = outer_product (ep, up)
case (1)
ep = eps (m, k, 1)
e0 = eps (m, k, 0)
up = u (m, k, 1)
um = u (m, k, -1)
t = (1 / sqrt (3.0_default)) * (outer_product (ep, um) &
+ sqrt (2.0_default) * outer_product (e0, up))
case (-1)
e0 = eps (m, k, 0)
em = eps (m, k, -1)
up = u (m, k, 1)
um = u (m, k, -1)
t = (1 / sqrt (3.0_default)) * (sqrt (2.0_default) * &
outer_product (e0, um) + outer_product (em, up))
case (-2)
em = eps (m, k, -1)
um = u (m, k, -1)
t = outer_product (em, um)
end select
end function ueps
@
<<Implementation of polarization vectorspinors>>=
pure function veps (m, k, s) result (t)
type(vectorspinor) :: t
real(kind=default), intent(in) :: m
type(momentum), intent(in) :: k
integer, intent(in) :: s
integer :: i
type(vector) :: ep, e0, em
type(bispinor) :: vp, vm
do i = 1, 4
t%psi(i)%a = 0
end do
select case (s)
case (2)
ep = conjg(eps (m, k, 1))
vp = v (m, k, 1)
t = outer_product (ep, vp)
case (1)
ep = conjg(eps (m, k, 1))
e0 = conjg(eps (m, k, 0))
vp = v (m, k, 1)
vm = v (m, k, -1)
t = (1 / sqrt (3.0_default)) * (outer_product (ep, vm) &
+ sqrt (2.0_default) * outer_product (e0, vp))
case (-1)
e0 = conjg(eps (m, k, 0))
em = conjg(eps (m, k, -1))
vp = v (m, k, 1)
vm = v (m, k, -1)
t = (1 / sqrt (3.0_default)) * (sqrt (2.0_default) &
* outer_product (e0, vm) + outer_product (em, vp))
case (-2)
em = conjg(eps (m, k, -1))
vm = v (m, k, -1)
t = outer_product (em, vm)
end select
end function veps
@
<<Implementation of polarization vectorspinors>>=
pure function outer_product (ve, sp) result (vs)
type(vectorspinor) :: vs
type(vector), intent(in) :: ve
type(bispinor), intent(in) :: sp
integer :: i
vs%psi(1)%a(1:4) = ve%t * sp%a(1:4)
do i = 1, 3
vs%psi((i+1))%a(1:4) = ve%x(i) * sp%a(1:4)
end do
end function outer_product
@ \section{Color}
<<[[omega_color.f90]]>>=
<<Copyleft>>
module omega_color
use kinds
implicit none
private
<<Declaration of color types>>
<<Declaration of color functions>>
integer, parameter, public :: omega_color_2010_01_A = 0
contains
<<Implementation of color functions>>
end module omega_color
@ \subsection{Color Sum}
<<Declaration of color types>>=
public :: omega_color_factor
type omega_color_factor
integer :: i1, i2
real(kind=default) :: factor
end type omega_color_factor
@
<<Declaration of color functions>>=
public :: omega_color_sum
@
The [[!$omp]] instruction will result in parallel code if compiled with
support for OpenMP otherwise it is ignored.
@
<<Implementation of color functions>>=
<<[[pure]] unless OpenMP>>
function omega_color_sum (flv, hel, amp, cf) result (amp2)
complex(kind=default) :: amp2
integer, intent(in) :: flv, hel
complex(kind=default), dimension(:,:,:), intent(in) :: amp
type(omega_color_factor), dimension(:), intent(in) :: cf
integer :: n
amp2 = 0
!$omp parallel do reduction(+:amp2)
do n = 1, size (cf)
amp2 = amp2 + cf(n)%factor * &
amp(flv,cf(n)%i1,hel) * conjg (amp(flv,cf(n)%i2,hel))
end do
!$omp end parallel do
end function omega_color_sum
@
In the bytecode for the OVM, we only save the symmetric part of the
color factor table. This almost halves the size of $n$ gluon amplitudes
for $n>6$. For $2\,\to\,(5,6)\,g$ the reduced color factor table still
amounts for $\sim(75,93)\%$ of the bytecode, making it desirable to
omit it completely by computing it dynamically to reduce memory
requirements. Note that
$2\text{Re}(A_{i_1}A_{i_2}^*)=A_{i_1}A_{i_2}^*+A_{i_2}A_{i_1}^*$.
<<Declaration of color functions>>=
public :: ovm_color_sum
@
<<Implementation of color functions>>=
<<[[pure]] unless OpenMP>>
function ovm_color_sum (flv, hel, amp, cf) result (amp2)
real(kind=default) :: amp2
integer, intent(in) :: flv, hel
complex(kind=default), dimension(:,:,:), intent(in) :: amp
type(omega_color_factor), dimension(:), intent(in) :: cf
integer :: n
amp2 = 0
!$omp parallel do reduction(+:amp2)
do n = 1, size (cf)
if (cf(n)%i1 == cf(n)%i2) then
amp2 = amp2 + cf(n)%factor * &
real(amp(flv,cf(n)%i1,hel) * conjg(amp(flv,cf(n)%i2,hel)))
else
amp2 = amp2 + cf(n)%factor * 2 * &
real(amp(flv,cf(n)%i1,hel) * conjg(amp(flv,cf(n)%i2,hel)))
end if
end do
!$omp end parallel do
end function ovm_color_sum
@ \section{Utilities}
<<[[omega_utils.f90]]>>=
<<Copyleft>>
module omega_utils
use kinds
use omega_vectors
use omega_polarizations
implicit none
private
<<Declaration of utility functions>>
<<Numerical tolerances>>
integer, parameter, public :: omega_utils_2010_01_A = 0
contains
<<Implementation of utility functions>>
end module omega_utils
@ \subsection{Helicity Selection Rule Heuristics}
<<Declaration of utility functions>>=
public :: omega_update_helicity_selection
@
<<Implementation of utility functions>>=
pure subroutine omega_update_helicity_selection &
(count, amp, max_abs, sum_abs, mask, threshold, cutoff, mask_dirty)
integer, intent(inout) :: count
complex(kind=default), dimension(:,:,:), intent(in) :: amp
real(kind=default), dimension(:), intent(inout) :: max_abs
real(kind=default), intent(inout) :: sum_abs
logical, dimension(:), intent(inout) :: mask
real(kind=default), intent(in) :: threshold
integer, intent(in) :: cutoff
logical, intent(out) :: mask_dirty
integer :: h
real(kind=default) :: avg
mask_dirty = .false.
if (threshold > 0) then
count = count + 1
if (count <= cutoff) then
forall (h = lbound (amp, 3) : ubound (amp, 3))
max_abs(h) = max (max_abs(h), maxval (abs (amp(:,:,h))))
end forall
sum_abs = sum_abs + sum (abs (amp))
if (count == cutoff) then
avg = sum_abs / size (amp) / cutoff
mask = max_abs >= threshold * epsilon (avg) * avg
mask_dirty = .true.
end if
end if
end if
end subroutine omega_update_helicity_selection
@ \subsection{Diagnostics}
<<Declaration of utility functions>>=
public :: omega_report_helicity_selection
@ We shoul try to use [[msg_message]] from WHIZARD's [[diagnostics]] module,
but this would spoil independent builds.
<<Implementation of utility functions>>=
subroutine omega_report_helicity_selection (mask, spin_states, threshold, unit)
logical, dimension(:), intent(in) :: mask
integer, dimension(:,:), intent(in) :: spin_states
real(kind=default), intent(in) :: threshold
integer, intent(in), optional :: unit
integer :: u
integer :: h, i
if (present(unit)) then
u = unit
else
u = 6
end if
if (u >= 0) then
write (unit = u, &
fmt = "('| ','Contributing Helicity Combinations: ', I5, ' of ', I5)") &
count (mask), size (mask)
write (unit = u, &
fmt = "('| ','Threshold: amp / avg > ', E9.2, ' = ', E9.2, ' * epsilon()')") &
threshold * epsilon (threshold), threshold
i = 0
do h = 1, size (mask)
if (mask(h)) then
i = i + 1
write (unit = u, fmt = "('| ',I4,': ',20I4)") i, spin_states (:, h)
end if
end do
end if
end subroutine omega_report_helicity_selection
@
<<Declaration of utility functions>>=
public :: omega_ward_warn, omega_ward_panic
@ The O'Mega amplitudes have only one particle off shell and are the
sum of \emph{all} possible diagrams with the other particles
on-shell.
\begin{dubious}
The problem with these gauge checks is that are numerically very
small amplitudes that vanish analytically and that violate
transversality. The hard part is to determine the thresholds that
make threse tests usable.
\end{dubious}
<<Implementation of utility functions>>=
subroutine omega_ward_warn (name, m, k, e)
character(len=*), intent(in) :: name
real(kind=default), intent(in) :: m
type(momentum), intent(in) :: k
type(vector), intent(in) :: e
type(vector) :: ek
real(kind=default) :: abs_eke, abs_ek_abs_e
ek = eps (m, k, 4)
abs_eke = abs (ek * e)
abs_ek_abs_e = abs (ek) * abs (e)
print *, name, ":", abs_eke / abs_ek_abs_e, abs (ek), abs (e)
if (abs_eke > 1000 * epsilon (abs_ek_abs_e)) then
print *, "O'Mega: warning: non-transverse vector field: ", &
name, ":", abs_eke / abs_ek_abs_e, abs (e)
end if
end subroutine omega_ward_warn
@
<<Implementation of utility functions>>=
subroutine omega_ward_panic (name, m, k, e)
character(len=*), intent(in) :: name
real(kind=default), intent(in) :: m
type(momentum), intent(in) :: k
type(vector), intent(in) :: e
type(vector) :: ek
real(kind=default) :: abs_eke, abs_ek_abs_e
ek = eps (m, k, 4)
abs_eke = abs (ek * e)
abs_ek_abs_e = abs (ek) * abs (e)
if (abs_eke > 1000 * epsilon (abs_ek_abs_e)) then
print *, "O'Mega: panic: non-transverse vector field: ", &
name, ":", abs_eke / abs_ek_abs_e, abs (e)
stop
end if
end subroutine omega_ward_panic
@
<<Declaration of utility functions>>=
public :: omega_slavnov_warn, omega_slavnov_panic
@
<<Implementation of utility functions>>=
subroutine omega_slavnov_warn (name, m, k, e, phi)
character(len=*), intent(in) :: name
real(kind=default), intent(in) :: m
type(momentum), intent(in) :: k
type(vector), intent(in) :: e
complex(kind=default), intent(in) :: phi
type(vector) :: ek
real(kind=default) :: abs_eke, abs_ek_abs_e
ek = eps (m, k, 4)
abs_eke = abs (ek * e - phi)
abs_ek_abs_e = abs (ek) * abs (e)
print *, name, ":", abs_eke / abs_ek_abs_e, abs (ek), abs (e)
if (abs_eke > 1000 * epsilon (abs_ek_abs_e)) then
print *, "O'Mega: warning: non-transverse vector field: ", &
name, ":", abs_eke / abs_ek_abs_e, abs (e)
end if
end subroutine omega_slavnov_warn
@
<<Implementation of utility functions>>=
subroutine omega_slavnov_panic (name, m, k, e, phi)
character(len=*), intent(in) :: name
real(kind=default), intent(in) :: m
type(momentum), intent(in) :: k
type(vector), intent(in) :: e
complex(kind=default), intent(in) :: phi
type(vector) :: ek
real(kind=default) :: abs_eke, abs_ek_abs_e
ek = eps (m, k, 4)
abs_eke = abs (ek * e - phi)
abs_ek_abs_e = abs (ek) * abs (e)
if (abs_eke > 1000 * epsilon (abs_ek_abs_e)) then
print *, "O'Mega: panic: non-transverse vector field: ", &
name, ":", abs_eke / abs_ek_abs_e, abs (e)
stop
end if
end subroutine omega_slavnov_panic
@
<<Declaration of utility functions>>=
public :: omega_check_arguments_warn, omega_check_arguments_panic
@
<<Implementation of utility functions>>=
subroutine omega_check_arguments_warn (n, k)
integer, intent(in) :: n
real(kind=default), dimension(0:,:), intent(in) :: k
integer :: i
i = size(k,dim=1)
if (i /= 4) then
print *, "O'Mega: warning: wrong # of dimensions:", i
end if
i = size(k,dim=2)
if (i /= n) then
print *, "O'Mega: warning: wrong # of momenta:", i, &
", expected", n
end if
end subroutine omega_check_arguments_warn
@
<<Implementation of utility functions>>=
subroutine omega_check_arguments_panic (n, k)
integer, intent(in) :: n
real(kind=default), dimension(0:,:), intent(in) :: k
logical :: error
integer :: i
error = .false.
i = size(k,dim=1)
if (i /= n) then
print *, "O'Mega: warning: wrong # of dimensions:", i
error = .true.
end if
i = size(k,dim=2)
if (i /= n) then
print *, "O'Mega: warning: wrong # of momenta:", i, &
", expected", n
error = .true.
end if
if (error) then
stop
end if
end subroutine omega_check_arguments_panic
@
<<Declaration of utility functions>>=
public :: omega_check_helicities_warn, omega_check_helicities_panic
private :: omega_check_helicity
@
<<Implementation of utility functions>>=
function omega_check_helicity (m, smax, s) result (error)
real(kind=default), intent(in) :: m
integer, intent(in) :: smax, s
logical :: error
select case (smax)
case (0)
error = (s /= 0)
case (1)
error = (abs (s) /= 1)
case (2)
if (m == 0.0_default) then
error = .not. (abs (s) == 1 .or. abs (s) == 4)
else
error = .not. (abs (s) <= 1 .or. abs (s) == 4)
end if
case (4)
error = .true.
case default
error = .true.
end select
end function omega_check_helicity
@
<<Implementation of utility functions>>=
subroutine omega_check_helicities_warn (m, smax, s)
real(kind=default), dimension(:), intent(in) :: m
integer, dimension(:), intent(in) :: smax, s
integer :: i
do i = 1, size (m)
if (omega_check_helicity (m(i), smax(i), s(i))) then
print *, "O'Mega: warning: invalid helicity", s(i)
end if
end do
end subroutine omega_check_helicities_warn
@
<<Implementation of utility functions>>=
subroutine omega_check_helicities_panic (m, smax, s)
real(kind=default), dimension(:), intent(in) :: m
integer, dimension(:), intent(in) :: smax, s
logical :: error
logical :: error1
integer :: i
error = .false.
do i = 1, size (m)
error1 = omega_check_helicity (m(i), smax(i), s(i))
if (error1) then
print *, "O'Mega: panic: invalid helicity", s(i)
error = .true.
end if
end do
if (error) then
stop
end if
end subroutine omega_check_helicities_panic
@
<<Declaration of utility functions>>=
public :: omega_check_momenta_warn, omega_check_momenta_panic
private :: check_momentum_conservation, check_mass_shell
@
<<Numerical tolerances>>=
integer, parameter, private :: MOMENTUM_TOLERANCE = 10000
@
<<Implementation of utility functions>>=
function check_momentum_conservation (k) result (error)
real(kind=default), dimension(0:,:), intent(in) :: k
logical :: error
error = any (abs (sum (k(:,3:), dim = 2) - k(:,1) - k(:,2)) > &
MOMENTUM_TOLERANCE * epsilon (maxval (abs (k), dim = 2)))
if (error) then
print *, sum (k(:,3:), dim = 2) - k(:,1) - k(:,2)
print *, MOMENTUM_TOLERANCE * epsilon (maxval (abs (k), dim = 2)), &
maxval (abs (k), dim = 2)
end if
end function check_momentum_conservation
@
<<Numerical tolerances>>=
integer, parameter, private :: ON_SHELL_TOLERANCE = 1000000
@
<<Implementation of utility functions>>=
function check_mass_shell (m, k) result (error)
real(kind=default), intent(in) :: m
real(kind=default), dimension(0:), intent(in) :: k
real(kind=default) :: e2
logical :: error
e2 = k(1)**2 + k(2)**2 + k(3)**2 + m**2
error = abs (k(0)**2 - e2) > ON_SHELL_TOLERANCE * epsilon (max (k(0)**2, e2))
if (error) then
print *, k(0)**2 - e2
print *, ON_SHELL_TOLERANCE * epsilon (max (k(0)**2, e2)), max (k(0)**2, e2)
end if
end function check_mass_shell
@
<<Implementation of utility functions>>=
subroutine omega_check_momenta_warn (m, k)
real(kind=default), dimension(:), intent(in) :: m
real(kind=default), dimension(0:,:), intent(in) :: k
integer :: i
if (check_momentum_conservation (k)) then
print *, "O'Mega: warning: momentum not conserved"
end if
do i = 1, size(m)
if (check_mass_shell (m(i), k(:,i))) then
print *, "O'Mega: warning: particle #", i, "not on-shell"
end if
end do
end subroutine omega_check_momenta_warn
@
<<Implementation of utility functions>>=
subroutine omega_check_momenta_panic (m, k)
real(kind=default), dimension(:), intent(in) :: m
real(kind=default), dimension(0:,:), intent(in) :: k
logical :: error
logical :: error1
integer :: i
error = check_momentum_conservation (k)
if (error) then
print *, "O'Mega: panic: momentum not conserved"
end if
do i = 1, size(m)
error1 = check_mass_shell (m(i), k(0:,i))
if (error1) then
print *, "O'Mega: panic: particle #", i, "not on-shell"
error = .true.
end if
end do
if (error) then
stop
end if
end subroutine omega_check_momenta_panic
@ \subsection{Obsolete Summation}
\subsubsection{Spin/Helicity Summation}
<<Declaration of obsolete utility functions>>=
public :: omega_sum, omega_sum_nonzero, omega_nonzero
private :: state_index
@
<<Implementation of obsolete utility functions>>=
pure function omega_sum (omega, p, states, fixed) result (sigma)
real(kind=default) :: sigma
real(kind=default), dimension(0:,:), intent(in) :: p
integer, dimension(:), intent(in), optional :: states, fixed
<<[[interface]] for O'Mega Amplitude>>
integer, dimension(size(p,dim=2)) :: s, nstates
integer :: j
complex(kind=default) :: a
if (present (states)) then
nstates = states
else
nstates = 2
end if
sigma = 0
s = -1
sum_spins: do
if (present (fixed)) then
!!! print *, 's = ', s, ', fixed = ', fixed, ', nstates = ', nstates, &
!!! ', fixed|s = ', merge (fixed, s, mask = nstates == 0)
a = omega (p, merge (fixed, s, mask = nstates == 0))
else
a = omega (p, s)
end if
sigma = sigma + a * conjg(a)
<<Step [[s]] like a $n$-ary number and terminate when [[all (s == -1)]]>>
end do sum_spins
sigma = sigma / num_states (2, nstates(1:2))
end function omega_sum
@ We're looping over all spins like a $n$-ary numbers $(-1,\ldots,-1,-1)$,
$(-1,\ldots,-1,0)$, $(-1,\ldots,-1,1)$, $(-1,\ldots,0,-1)$, \ldots,
$(1,\ldots,1,0)$, $(1,\ldots,1,1)$:
<<Step [[s]] like a $n$-ary number and terminate when [[all (s == -1)]]>>=
do j = size (p, dim = 2), 1, -1
select case (nstates (j))
case (3) ! massive vectors
s(j) = modulo (s(j) + 2, 3) - 1
case (2) ! spinors, massless vectors
s(j) = - s(j)
case (1) ! scalars
s(j) = -1
case (0) ! fized spin
s(j) = -1
case default ! ???
s(j) = -1
end select
if (s(j) /= -1) then
cycle sum_spins
end if
end do
exit sum_spins
@ The dual operation evaluates an $n$-number:
<<Implementation of obsolete utility functions>>=
pure function state_index (s, states) result (n)
integer, dimension(:), intent(in) :: s
integer, dimension(:), intent(in), optional :: states
integer :: n
integer :: j, p
n = 1
p = 1
if (present (states)) then
do j = size (s), 1, -1
select case (states(j))
case (3)
n = n + p * (s(j) + 1)
case (2)
n = n + p * (s(j) + 1) / 2
end select
p = p * states(j)
end do
else
do j = size (s), 1, -1
n = n + p * (s(j) + 1) / 2
p = p * 2
end do
end if
end function state_index
@
<<[[interface]] for O'Mega Amplitude>>=
interface
pure function omega (p, s) result (me)
use kinds
implicit none
complex(kind=default) :: me
real(kind=default), dimension(0:,:), intent(in) :: p
integer, dimension(:), intent(in) :: s
end function omega
end interface
@
<<Declaration of obsolete utility functions>>=
public :: num_states
@
<<Implementation of obsolete utility functions>>=
pure function num_states (n, states) result (ns)
integer, intent(in) :: n
integer, dimension(:), intent(in), optional :: states
integer :: ns
if (present (states)) then
ns = product (states, mask = states == 2 .or. states == 3)
else
ns = 2**n
end if
end function num_states
@
\section{\texttt{omega95}}
<<[[omega95.f90]]>>=
<<Copyleft>>
module omega95
use constants
use omega_spinors
use omega_vectors
use omega_polarizations
use omega_tensors
use omega_tensor_polarizations
use omega_couplings
use omega_spinor_couplings
use omega_color
use omega_utils
public
end module omega95
@
\section{\texttt{omega95} Revisited}
<<[[omega95_bispinors.f90]]>>=
<<Copyleft>>
module omega95_bispinors
use constants
use omega_bispinors
use omega_vectors
use omega_vectorspinors
use omega_polarizations
use omega_vspinor_polarizations
use omega_couplings
use omega_bispinor_couplings
use omega_color
use omega_utils
public
end module omega95_bispinors
@
\section{Testing}
<<[[omega_testtools.f90]]>>=
<<Copyleft>>
module omega_testtools
use kinds
implicit none
private
real(kind=default), parameter, private :: ABS_THRESHOLD_DEFAULT = 1E-17
real(kind=default), parameter, private :: THRESHOLD_DEFAULT = 0.6
real(kind=default), parameter, private :: THRESHOLD_WARN = 0.8
<<Declaration of test support functions>>
contains
<<Implementation of test support functions>>
end module omega_testtools
@ Quantify the agreement of two real or complex numbers
\begin{equation}
\text{agreement}(x,y) = \frac{\ln \Delta(x,y)}{\ln\epsilon} \in[0,1]
\end{equation}
with
\begin{equation}
\Delta(x,y) = \frac{|x-y|}{\max(|x|,|y|)}
\end{equation}
and values outside~$[0,1]$ replaced the closed value in the interval.
In other words
\begin{itemize}
\item $1$ for $x-y=\max(|x|,|y|)\cdot\mathcal{O}(\epsilon)$ and
\item $0$~for $x-y=\max(|x|,|y|)\cdot\mathcal{O}(1)$
\end{itemize}
with logarithmic interpolation. The cases~$x=0$ and~$y=0$ must be
treated separately.
<<Declaration of test support functions>>=
public :: agreement
interface agreement
module procedure agreement_real, agreement_complex, &
agreement_real_complex, agreement_complex_real, &
agreement_integer_complex, agreement_complex_integer, &
agreement_integer_real, agreement_real_integer
end interface
private :: agreement_real, agreement_complex, &
agreement_real_complex, agreement_complex_real, &
agreement_integer_complex, agreement_complex_integer, &
agreement_integer_real, agreement_real_integer
@
<<Implementation of test support functions>>=
elemental function agreement_real (x, y, base) result (a)
real(kind=default) :: a
real(kind=default), intent(in) :: x, y
real(kind=default), intent(in), optional :: base
real(kind=default) :: scale, dxy
if (present (base)) then
scale = max (abs (x), abs (y), abs (base))
else
scale = max (abs (x), abs (y))
end if
if (ieee_is_nan (x) .or. ieee_is_nan (y)) then
a = 0
else if (scale <= 0) then
a = -1
else
dxy = abs (x - y) / scale
if (dxy <= 0.0_default) then
a = 1
else
a = log (dxy) / log (epsilon (scale))
a = max (0.0_default, min (1.0_default, a))
if (ieee_is_nan (a)) then
a = 0
end if
end if
end if
if (ieee_is_nan (a)) then
a = 0
end if
end function agreement_real
@ Poor man's replacement
<<Implementation of test support functions>>=
elemental function ieee_is_nan (x) result (yorn)
logical :: yorn
real (kind=default), intent(in) :: x
yorn = (x /= x)
end function ieee_is_nan
@
<<Implementation of test support functions>>=
elemental function agreement_complex (x, y, base) result (a)
real(kind=default) :: a
complex(kind=default), intent(in) :: x, y
real(kind=default), intent(in), optional :: base
real(kind=default) :: scale, dxy
if (present (base)) then
scale = max (abs (x), abs (y), abs (base))
else
scale = max (abs (x), abs (y))
end if
if ( ieee_is_nan (real (x, kind=default)) .or. ieee_is_nan (aimag (x)) &
.or. ieee_is_nan (real (y, kind=default)) .or. ieee_is_nan (aimag (y))) then
a = 0
else if (scale <= 0) then
a = -1
else
dxy = abs (x - y) / scale
if (dxy <= 0.0_default) then
a = 1
else
a = log (dxy) / log (epsilon (scale))
a = max (0.0_default, min (1.0_default, a))
if (ieee_is_nan (a)) then
a = 0
end if
end if
end if
if (ieee_is_nan (a)) then
a = 0
end if
end function agreement_complex
@
<<Implementation of test support functions>>=
elemental function agreement_real_complex (x, y, base) result (a)
real(kind=default) :: a
real(kind=default), intent(in) :: x
complex(kind=default), intent(in) :: y
real(kind=default), intent(in), optional :: base
a = agreement_complex (cmplx (x, kind=default), y, base)
end function agreement_real_complex
@
<<Implementation of test support functions>>=
elemental function agreement_complex_real (x, y, base) result (a)
real(kind=default) :: a
complex(kind=default), intent(in) :: x
real(kind=default), intent(in) :: y
real(kind=default), intent(in), optional :: base
a = agreement_complex (x, cmplx (y, kind=default), base)
end function agreement_complex_real
@
<<Implementation of test support functions>>=
elemental function agreement_integer_complex (x, y, base) result (a)
real(kind=default) :: a
integer, intent(in) :: x
complex(kind=default), intent(in) :: y
real(kind=default), intent(in), optional :: base
a = agreement_complex (cmplx (x, kind=default), y, base)
end function agreement_integer_complex
@
<<Implementation of test support functions>>=
elemental function agreement_complex_integer (x, y, base) result (a)
real(kind=default) :: a
complex(kind=default), intent(in) :: x
integer, intent(in) :: y
real(kind=default), intent(in), optional :: base
a = agreement_complex (x, cmplx (y, kind=default), base)
end function agreement_complex_integer
@
<<Implementation of test support functions>>=
elemental function agreement_integer_real (x, y, base) result (a)
real(kind=default) :: a
integer, intent(in) :: x
real(kind=default), intent(in) :: y
real(kind=default), intent(in), optional :: base
a = agreement_real (real(x, kind=default), y, base)
end function agreement_integer_real
@
<<Implementation of test support functions>>=
elemental function agreement_real_integer (x, y, base) result (a)
real(kind=default) :: a
real(kind=default), intent(in) :: x
integer, intent(in) :: y
real(kind=default), intent(in), optional :: base
a = agreement_real (x, real (y, kind=default), base)
end function agreement_real_integer
@
<<Declaration of test support functions>>=
public:: vanishes
interface vanishes
module procedure vanishes_real, vanishes_complex
end interface
private :: vanishes_real, vanishes_complex
@
<<Implementation of test support functions>>=
elemental function vanishes_real (x, scale) result (a)
real(kind=default) :: a
real(kind=default), intent(in) :: x
real(kind=default), intent(in), optional :: scale
real(kind=default) :: scaled_x
if (x == 0.0_default) then
a = 1
return
else if (ieee_is_nan (x)) then
a = 0
return
end if
scaled_x = x
if (present (scale)) then
if (scale /= 0) then
scaled_x = x / abs (scale)
else
a = 0
return
end if
else
end if
a = log (abs (scaled_x)) / log (epsilon (scaled_x))
a = max (0.0_default, min (1.0_default, a))
if (ieee_is_nan (a)) then
a = 0
end if
end function vanishes_real
@
<<Implementation of test support functions>>=
elemental function vanishes_complex (x, scale) result (a)
real(kind=default) :: a
complex(kind=default), intent(in) :: x
real(kind=default), intent(in), optional :: scale
a = vanishes_real (abs (x), scale)
end function vanishes_complex
@
<<Declaration of test support functions>>=
public :: expect
interface expect
module procedure expect_integer, expect_real, expect_complex, &
expect_real_integer, expect_integer_real, &
expect_complex_integer, expect_integer_complex, &
expect_complex_real, expect_real_complex
end interface
private :: expect_integer, expect_real, expect_complex, &
expect_real_integer, expect_integer_real, &
expect_complex_integer, expect_integer_complex, &
expect_complex_real, expect_real_complex
@
<<Implementation of test support functions>>=
subroutine expect_integer (x, x0, msg, passed, quiet, buffer, unit)
integer, intent(in) :: x, x0
character(len=*), intent(in) :: msg
logical, intent(inout), optional :: passed
logical, intent(in), optional :: quiet
character(len=*), intent(inout), optional :: buffer
integer, intent(in), optional :: unit
logical :: failed, verbose
character(len=*), parameter :: fmt = "(1X,A,': ',A)"
character(len=*), parameter :: &
fmt_verbose = "(1X,A,': ',A,' [expected ',I6,', got ',I6,']')"
failed = .false.
verbose = .true.
if (present (quiet)) then
verbose = .not.quiet
end if
if (x == x0) then
if (verbose) then
if (.not. (present (buffer) .or. present (unit))) then
write (unit = *, fmt = fmt) msg, "passed"
end if
if (present (unit)) then
write (unit = unit, fmt = fmt) msg, "passed"
end if
if (present (buffer)) then
write (unit = buffer, fmt = fmt) msg, "passed"
end if
end if
else
if (.not. (present (buffer) .or. present (unit))) then
write (unit = *, fmt = fmt_verbose) msg, "failed", x0, x
end if
if (present (unit)) then
write (unit = unit, fmt = fmt_verbose) msg, "failed", x0, x
end if
if (present (buffer)) then
write (unit = buffer, fmt = fmt_verbose) msg, "failed", x0, x
end if
failed = .true.
end if
if (present (passed)) then
passed = passed .and. .not.failed
end if
end subroutine expect_integer
@
<<Implementation of test support functions>>=
subroutine expect_real (x, x0, msg, passed, threshold, quiet, abs_threshold)
real(kind=default), intent(in) :: x, x0
character(len=*), intent(in) :: msg
logical, intent(inout), optional :: passed
real(kind=default), intent(in), optional :: threshold
real(kind=default), intent(in), optional :: abs_threshold
logical, intent(in), optional :: quiet
logical :: failed, verbose
real(kind=default) :: agreement_threshold, abs_agreement_threshold
character(len=*), parameter :: fmt = "(1X,A,': ',A,' at ',I4,'%')"
character(len=*), parameter :: fmt_verbose = "(1X,A,': ',A,' at ',I4,'%'," // &
"' [expected ',E10.3,', got ',E10.3,']')"
real(kind=default) :: a
failed = .false.
verbose = .true.
if (present (quiet)) then
verbose = .not.quiet
end if
if (x == x0) then
if (verbose) then
write (unit = *, fmt = fmt) msg, "passed", 100
end if
else
if (x0 == 0) then
a = vanishes (x)
else
a = agreement (x, x0)
end if
if (present (threshold)) then
agreement_threshold = threshold
else
agreement_threshold = THRESHOLD_DEFAULT
end if
if (present (abs_threshold)) then
abs_agreement_threshold = abs_threshold
else
abs_agreement_threshold = ABS_THRESHOLD_DEFAULT
end if
if (a >= agreement_threshold .or. &
max(abs(x), abs(x0)) <= abs_agreement_threshold) then
if (verbose) then
if (a >= THRESHOLD_WARN) then
write (unit = *, fmt = fmt) msg, "passed", int (a * 100)
else
write (unit = *, fmt = fmt_verbose) msg, "passed", int (a * 100), x0, x
end if
end if
else
failed = .true.
write (unit = *, fmt = fmt_verbose) msg, "failed", int (a * 100), x0, x
end if
end if
if (present (passed)) then
passed = passed .and. .not. failed
end if
end subroutine expect_real
@
<<Implementation of test support functions>>=
subroutine expect_complex (x, x0, msg, passed, threshold, quiet, abs_threshold)
complex(kind=default), intent(in) :: x, x0
character(len=*), intent(in) :: msg
logical, intent(inout), optional :: passed
real(kind=default), intent(in), optional :: threshold
real(kind=default), intent(in), optional :: abs_threshold
logical, intent(in), optional :: quiet
logical :: failed, verbose
real(kind=default) :: agreement_threshold, abs_agreement_threshold
character(len=*), parameter :: fmt = "(1X,A,': ',A,' at ',I4,'%')"
character(len=*), parameter :: fmt_verbose = "(1X,A,': ',A,' at ',I4,'%'," // &
"' [expected (',E10.3,',',E10.3,'), got (',E10.3,',',E10.3,')]')"
character(len=*), parameter :: fmt_phase = "(1X,A,': ',A,' at ',I4,'%'," // &
"' [modulus passed at ',I4,'%',', phases ',F5.3,' vs. ',F5.3,']')"
real(kind=default) :: a, a_modulus
failed = .false.
verbose = .true.
if (present (quiet)) then
verbose = .not.quiet
end if
if (x == x0) then
if (verbose) then
write (unit = *, fmt = fmt) msg, "passed", 100
end if
else
if (x0 == 0) then
a = vanishes (x)
else
a = agreement (x, x0)
end if
if (present (threshold)) then
agreement_threshold = threshold
else
agreement_threshold = THRESHOLD_DEFAULT
end if
if (present (abs_threshold)) then
abs_agreement_threshold = abs_threshold
else
abs_agreement_threshold = ABS_THRESHOLD_DEFAULT
end if
if (a >= agreement_threshold .or. &
max(abs(x), abs(x0)) <= abs_agreement_threshold) then
if (verbose) then
if (a >= THRESHOLD_WARN) then
write (unit = *, fmt = fmt) msg, "passed", int (a * 100)
else
write (unit = *, fmt = fmt_verbose) msg, "passed", int (a * 100), x0, x
end if
end if
else
a_modulus = agreement (abs (x), abs (x0))
if (a_modulus >= agreement_threshold) then
write (unit = *, fmt = fmt_phase) msg, "failed", int (a * 100), &
int (a_modulus * 100), &
atan2 (real (x, kind=default), aimag (x)), &
atan2 (real (x0, kind=default), aimag (x0))
else
write (unit = *, fmt = fmt_verbose) msg, "failed", int (a * 100), x0, x
end if
failed = .true.
end if
end if
if (present (passed)) then
passed = passed .and. .not.failed
end if
end subroutine expect_complex
@
<<Implementation of test support functions>>=
subroutine expect_real_integer (x, x0, msg, passed, threshold, quiet)
real(kind=default), intent(in) :: x
integer, intent(in) :: x0
character(len=*), intent(in) :: msg
real(kind=default), intent(in), optional :: threshold
logical, intent(inout), optional :: passed
logical, intent(in), optional :: quiet
call expect_real (x, real (x0, kind=default), msg, passed, threshold, quiet)
end subroutine expect_real_integer
@
<<Implementation of test support functions>>=
subroutine expect_integer_real (x, x0, msg, passed, threshold, quiet)
integer, intent(in) :: x
real(kind=default), intent(in) :: x0
character(len=*), intent(in) :: msg
real(kind=default), intent(in), optional :: threshold
logical, intent(inout), optional :: passed
logical, intent(in), optional :: quiet
call expect_real (real (x, kind=default), x0, msg, passed, threshold, quiet)
end subroutine expect_integer_real
@
<<Implementation of test support functions>>=
subroutine expect_complex_integer (x, x0, msg, passed, threshold, quiet)
complex(kind=default), intent(in) :: x
integer, intent(in) :: x0
character(len=*), intent(in) :: msg
logical, intent(inout), optional :: passed
real(kind=default), intent(in), optional :: threshold
logical, intent(in), optional :: quiet
call expect_complex (x, cmplx (x0, kind=default), msg, passed, threshold, quiet)
end subroutine expect_complex_integer
@
<<Implementation of test support functions>>=
subroutine expect_integer_complex (x, x0, msg, passed, threshold, quiet)
integer, intent(in) :: x
complex(kind=default), intent(in) :: x0
character(len=*), intent(in) :: msg
logical, intent(inout), optional :: passed
real(kind=default), intent(in), optional :: threshold
logical, intent(in), optional :: quiet
call expect_complex (cmplx (x, kind=default), x0, msg, passed, threshold, quiet)
end subroutine expect_integer_complex
@
<<Implementation of test support functions>>=
subroutine expect_complex_real (x, x0, msg, passed, threshold, quiet)
complex(kind=default), intent(in) :: x
real(kind=default), intent(in) :: x0
character(len=*), intent(in) :: msg
logical, intent(inout), optional :: passed
real(kind=default), intent(in), optional :: threshold
logical, intent(in), optional :: quiet
call expect_complex (x, cmplx (x0, kind=default), msg, passed, threshold, quiet)
end subroutine expect_complex_real
@
<<Implementation of test support functions>>=
subroutine expect_real_complex (x, x0, msg, passed, threshold, quiet)
real(kind=default), intent(in) :: x
complex(kind=default), intent(in) :: x0
character(len=*), intent(in) :: msg
logical, intent(inout), optional :: passed
real(kind=default), intent(in), optional :: threshold
logical, intent(in), optional :: quiet
call expect_complex (cmplx (x, kind=default), x0, msg, passed, threshold, quiet)
end subroutine expect_real_complex
@
<<Declaration of test support functions>>=
public :: expect_zero
interface expect_zero
module procedure expect_zero_integer, expect_zero_real, expect_zero_complex
end interface
private :: expect_zero_integer, expect_zero_real, expect_zero_complex
@
<<Implementation of test support functions>>=
subroutine expect_zero_integer (x, msg, passed)
integer, intent(in) :: x
character(len=*), intent(in) :: msg
logical, intent(inout), optional :: passed
call expect_integer (x, 0, msg, passed)
end subroutine expect_zero_integer
@
<<Implementation of test support functions>>=
subroutine expect_zero_real (x, scale, msg, passed, threshold, quiet)
real(kind=default), intent(in) :: x, scale
character(len=*), intent(in) :: msg
logical, intent(inout), optional :: passed
real(kind=default), intent(in), optional :: threshold
logical, intent(in), optional :: quiet
logical :: failed, verbose
real(kind=default) :: agreement_threshold
character(len=*), parameter :: fmt = "(1X,A,': ',A,' at ',I4,'%')"
character(len=*), parameter :: fmt_verbose = "(1X,A,': ',A,' at ',I4,'%'," // &
"' [expected 0 (relative to ',E10.3,') got ',E10.3,']')"
real(kind=default) :: a
failed = .false.
verbose = .true.
if (present (quiet)) then
verbose = .not.quiet
end if
if (x == 0) then
if (verbose) then
write (unit = *, fmt = fmt) msg, "passed", 100
end if
else
a = vanishes (x, scale = scale)
if (present (threshold)) then
agreement_threshold = threshold
else
agreement_threshold = THRESHOLD_DEFAULT
end if
if (a >= agreement_threshold) then
if (verbose) then
if (a >= THRESHOLD_WARN) then
write (unit = *, fmt = fmt) msg, "passed", int (a * 100)
else
write (unit = *, fmt = fmt_verbose) msg, "passed", int (a * 100), scale, x
end if
end if
else
failed = .true.
write (unit = *, fmt = fmt_verbose) msg, "failed", int (a * 100), scale, x
end if
end if
if (present (passed)) then
passed = passed .and. .not.failed
end if
end subroutine expect_zero_real
@
<<Implementation of test support functions>>=
subroutine expect_zero_complex (x, scale, msg, passed, threshold, quiet)
complex(kind=default), intent(in) :: x
real(kind=default), intent(in) :: scale
character(len=*), intent(in) :: msg
logical, intent(inout), optional :: passed
real(kind=default), intent(in), optional :: threshold
logical, intent(in), optional :: quiet
call expect_zero_real (abs (x), scale, msg, passed, threshold, quiet)
end subroutine expect_zero_complex
@
<<Implementation of test support functions>>=
subroutine print_matrix (a)
complex(kind=default), dimension(:,:), intent(in) :: a
integer :: row
do row = 1, size (a, dim=1)
write (unit = *, fmt = "(10(tr2, f5.2, '+', f5.2, 'I'))") a(row,:)
end do
end subroutine print_matrix
@
<<Declaration of test support functions>>=
public :: print_matrix
@
<<[[test_omega95.f90]]>>=
<<Copyleft>>
program test_omega95
use kinds
use omega95
use omega_testtools
implicit none
real(kind=default) :: m, pabs, qabs, w
real(kind=default), dimension(0:3) :: r
complex(kind=default) :: c_one, c_nil
type(momentum) :: p, q, p0
type(vector) :: vp, vq, vtest, v0
type(tensor) :: ttest
type(spinor) :: test_psi, test_spinor1, test_spinor2
type(conjspinor) :: test_psibar, test_conjspinor1, test_conjspinor2
integer, dimension(8) :: date_time
integer :: rsize, i
logical :: passed
call date_and_time (values = date_time)
call random_seed (size = rsize)
call random_seed (put = spread (product (date_time), dim = 1, ncopies = rsize))
w = 1.4142
c_one = 1.0_default
c_nil = 0.0_default
m = 13
pabs = 42
qabs = 137
call random_number (r)
vtest%t = cmplx (10.0_default * r(0), kind=default)
vtest%x(1:3) = cmplx (10.0_default * r(1:3), kind=default)
ttest = vtest.tprod.vtest
call random_momentum (p, pabs, m)
call random_momentum (q, qabs, m)
call random_momentum (p0, 0.0_default, m)
vp = p
vq = q
v0 = p0
passed = .true.
<<Test [[omega95]]>>
if (.not. passed) then
stop 1
end if
end program test_omega95
@
<<Test [[omega95]]>>=
print *, "*** Checking the equations of motion ***:"
call expect (abs(f_vf(c_one,vp,u(m,p,+1))-m*u(m,p,+1)), 0, "|[p-m]u(+)|=0", passed)
call expect (abs(f_vf(c_one,vp,u(m,p,-1))-m*u(m,p,-1)), 0, "|[p-m]u(-)|=0", passed)
call expect (abs(f_vf(c_one,vp,v(m,p,+1))+m*v(m,p,+1)), 0, "|[p+m]v(+)|=0", passed)
call expect (abs(f_vf(c_one,vp,v(m,p,-1))+m*v(m,p,-1)), 0, "|[p+m]v(-)|=0", passed)
call expect (abs(f_fv(c_one,ubar(m,p,+1),vp)-m*ubar(m,p,+1)), 0, "|ubar(+)[p-m]|=0", passed)
call expect (abs(f_fv(c_one,ubar(m,p,-1),vp)-m*ubar(m,p,-1)), 0, "|ubar(-)[p-m]|=0", passed)
call expect (abs(f_fv(c_one,vbar(m,p,+1),vp)+m*vbar(m,p,+1)), 0, "|vbar(+)[p+m]|=0", passed)
call expect (abs(f_fv(c_one,vbar(m,p,-1),vp)+m*vbar(m,p,-1)), 0, "|vbar(-)[p+m]|=0", passed)
print *, "*** Checking the equations of motion for negative mass***:"
call expect (abs(f_vf(c_one,vp,u(-m,p,+1))+m*u(-m,p,+1)), 0, "|[p+m]u(+)|=0", passed)
call expect (abs(f_vf(c_one,vp,u(-m,p,-1))+m*u(-m,p,-1)), 0, "|[p+m]u(-)|=0", passed)
call expect (abs(f_vf(c_one,vp,v(-m,p,+1))-m*v(-m,p,+1)), 0, "|[p-m]v(+)|=0", passed)
call expect (abs(f_vf(c_one,vp,v(-m,p,-1))-m*v(-m,p,-1)), 0, "|[p-m]v(-)|=0", passed)
call expect (abs(f_fv(c_one,ubar(-m,p,+1),vp)+m*ubar(-m,p,+1)), 0, "|ubar(+)[p+m]|=0", passed)
call expect (abs(f_fv(c_one,ubar(-m,p,-1),vp)+m*ubar(-m,p,-1)), 0, "|ubar(-)[p+m]|=0", passed)
call expect (abs(f_fv(c_one,vbar(-m,p,+1),vp)-m*vbar(-m,p,+1)), 0, "|vbar(+)[p-m]|=0", passed)
call expect (abs(f_fv(c_one,vbar(-m,p,-1),vp)-m*vbar(-m,p,-1)), 0, "|vbar(-)[p-m]|=0", passed)
@
<<Test [[omega95]]>>=
print *, "*** Spin Sums"
test_psi%a = [one, two, three, four]
test_spinor1 = f_vf (c_one, vp, test_psi) + m * test_psi
test_spinor2 = u (m, p, +1) * (ubar (m, p, +1) * test_psi) + &
u (m, p, -1) * (ubar (m, p, -1) * test_psi)
do i = 1, 4
call expect (test_spinor1%a(i), test_spinor2%a(i), "(p+m)1=(sum u ubar)1", passed)
end do
test_spinor1 = f_vf (c_one, vp, test_psi) - m * test_psi
test_spinor2 = v (m, p, +1) * (vbar (m, p, +1) * test_psi) + &
v (m, p, -1) * (vbar (m, p, -1) * test_psi)
do i = 1, 4
call expect (test_spinor1%a(i), test_spinor2%a(i), "(p-m)1=(sum v vbar)1", passed)
end do
test_psibar%a = [one, two, three, four]
test_conjspinor1 = f_fv (c_one, test_psibar, vp) - m * test_psibar
test_conjspinor2 = (test_psibar * v (m, p, +1)) * vbar (m, p, +1) + &
(test_psibar * v (m, p, -1)) * vbar (m, p, -1)
do i = 1, 4
call expect (test_conjspinor1%a(i), test_conjspinor2%a(i), "(p-m)1=(sum v vbar)1", passed)
end do
@
<<Test [[omega95]]>>=
print *, "*** Checking the normalization ***:"
call expect (ubar(m,p,+1)*u(m,p,+1), +2*m, "ubar(+)*u(+)=+2m", passed)
call expect (ubar(m,p,-1)*u(m,p,-1), +2*m, "ubar(-)*u(-)=+2m", passed)
call expect (vbar(m,p,+1)*v(m,p,+1), -2*m, "vbar(+)*v(+)=-2m", passed)
call expect (vbar(m,p,-1)*v(m,p,-1), -2*m, "vbar(-)*v(-)=-2m", passed)
call expect (ubar(m,p,+1)*v(m,p,+1), 0, "ubar(+)*v(+)=0 ", passed)
call expect (ubar(m,p,-1)*v(m,p,-1), 0, "ubar(-)*v(-)=0 ", passed)
call expect (vbar(m,p,+1)*u(m,p,+1), 0, "vbar(+)*u(+)=0 ", passed)
call expect (vbar(m,p,-1)*u(m,p,-1), 0, "vbar(-)*u(-)=0 ", passed)
print *, "*** Checking the normalization for negative masses***:"
call expect (ubar(-m,p,+1)*u(-m,p,+1), -2*m, "ubar(+)*u(+)=-2m", passed)
call expect (ubar(-m,p,-1)*u(-m,p,-1), -2*m, "ubar(-)*u(-)=-2m", passed)
call expect (vbar(-m,p,+1)*v(-m,p,+1), +2*m, "vbar(+)*v(+)=+2m", passed)
call expect (vbar(-m,p,-1)*v(-m,p,-1), +2*m, "vbar(-)*v(-)=+2m", passed)
call expect (ubar(-m,p,+1)*v(-m,p,+1), 0, "ubar(+)*v(+)=0 ", passed)
call expect (ubar(-m,p,-1)*v(-m,p,-1), 0, "ubar(-)*v(-)=0 ", passed)
call expect (vbar(-m,p,+1)*u(-m,p,+1), 0, "vbar(+)*u(+)=0 ", passed)
call expect (vbar(-m,p,-1)*u(-m,p,-1), 0, "vbar(-)*u(-)=0 ", passed)
@
<<Test [[omega95]]>>=
print *, "*** Checking the currents ***:"
call expect (abs(v_ff(c_one,ubar(m,p,+1),u(m,p,+1))-2*vp), 0, "ubar(+).V.u(+)=2p", passed)
call expect (abs(v_ff(c_one,ubar(m,p,-1),u(m,p,-1))-2*vp), 0, "ubar(-).V.u(-)=2p", passed)
call expect (abs(v_ff(c_one,vbar(m,p,+1),v(m,p,+1))-2*vp), 0, "vbar(+).V.v(+)=2p", passed)
call expect (abs(v_ff(c_one,vbar(m,p,-1),v(m,p,-1))-2*vp), 0, "vbar(-).V.v(-)=2p", passed)
print *, "*** Checking the currents for negative masses***:"
call expect (abs(v_ff(c_one,ubar(-m,p,+1),u(-m,p,+1))-2*vp), 0, "ubar(+).V.u(+)=2p", passed)
call expect (abs(v_ff(c_one,ubar(-m,p,-1),u(-m,p,-1))-2*vp), 0, "ubar(-).V.u(-)=2p", passed)
call expect (abs(v_ff(c_one,vbar(-m,p,+1),v(-m,p,+1))-2*vp), 0, "vbar(+).V.v(+)=2p", passed)
call expect (abs(v_ff(c_one,vbar(-m,p,-1),v(-m,p,-1))-2*vp), 0, "vbar(-).V.v(-)=2p", passed)
@
<<Test [[omega95]]>>=
print *, "*** Checking current conservation ***:"
call expect ((vp-vq)*v_ff(c_one,ubar(m,p,+1),u(m,q,+1)), 0, "d(ubar(+).V.u(+))=0", passed)
call expect ((vp-vq)*v_ff(c_one,ubar(m,p,-1),u(m,q,-1)), 0, "d(ubar(-).V.u(-))=0", passed)
call expect ((vp-vq)*v_ff(c_one,vbar(m,p,+1),v(m,q,+1)), 0, "d(vbar(+).V.v(+))=0", passed)
call expect ((vp-vq)*v_ff(c_one,vbar(m,p,-1),v(m,q,-1)), 0, "d(vbar(-).V.v(-))=0", passed)
print *, "*** Checking current conservation for negative masses***:"
call expect ((vp-vq)*v_ff(c_one,ubar(-m,p,+1),u(-m,q,+1)), 0, "d(ubar(+).V.u(+))=0", passed)
call expect ((vp-vq)*v_ff(c_one,ubar(-m,p,-1),u(-m,q,-1)), 0, "d(ubar(-).V.u(-))=0", passed)
call expect ((vp-vq)*v_ff(c_one,vbar(-m,p,+1),v(-m,q,+1)), 0, "d(vbar(+).V.v(+))=0", passed)
call expect ((vp-vq)*v_ff(c_one,vbar(-m,p,-1),v(-m,q,-1)), 0, "d(vbar(-).V.v(-))=0", passed)
@
<<Test [[omega95]]>>=
if (m == 0) then
print *, "*** Checking axial current conservation ***:"
call expect ((vp-vq)*a_ff(c_one,ubar(m,p,+1),u(m,q,+1)), 0, "d(ubar(+).A.u(+))=0", passed)
call expect ((vp-vq)*a_ff(c_one,ubar(m,p,-1),u(m,q,-1)), 0, "d(ubar(-).A.u(-))=0", passed)
call expect ((vp-vq)*a_ff(c_one,vbar(m,p,+1),v(m,q,+1)), 0, "d(vbar(+).A.v(+))=0", passed)
call expect ((vp-vq)*a_ff(c_one,vbar(m,p,-1),v(m,q,-1)), 0, "d(vbar(-).A.v(-))=0", passed)
end if
@
<<Test [[omega95]]>>=
print *, "*** Checking implementation of the sigma vertex funktions ***:"
call expect ((vp*tvam_ff(c_one,c_nil,ubar(m,p,+1),u(m,q,+1),q) - (p*q-m**2)*(ubar(m,p,+1)*u(m,q,+1))), 0, &
"p*[ubar(p,+).(Isigma*q).u(q,+)] - (p*q-m^2)*ubar(p,+).u(q,+) = 0", passed)
call expect ((vp*tvam_ff(c_one,c_nil,ubar(m,p,-1),u(m,q,-1),q) - (p*q-m**2)*(ubar(m,p,-1)*u(m,q,-1))), 0, &
"p*[ubar(p,-).(Isigma*q).u(q,-)] - (p*q-m^2)*ubar(p,-).u(q,-) = 0", passed)
call expect ((vp*tvam_ff(c_one,c_nil,vbar(m,p,+1),v(m,q,+1),q) - (p*q-m**2)*(vbar(m,p,+1)*v(m,q,+1))), 0, &
"p*[vbar(p,+).(Isigma*q).v(q,+)] - (p*q-m^2)*vbar(p,+).v(q,+) = 0", passed)
call expect ((vp*tvam_ff(c_one,c_nil,vbar(m,p,-1),v(m,q,-1),q) - (p*q-m**2)*(vbar(m,p,-1)*v(m,q,-1))), 0, &
"p*[vbar(p,-).(Isigma*q).v(q,-)] - (p*q-m^2)*vbar(p,-).v(q,-) = 0", passed)
call expect ((ubar(m,p,+1)*f_tvamf(c_one,c_nil,vp,u(m,q,+1),q) - (p*q-m**2)*(ubar(m,p,+1)*u(m,q,+1))), 0, &
"ubar(p,+).[p*(Isigma*q).u(q,+)] - (p*q-m^2)*ubar(p,+).u(q,+) = 0", passed)
call expect ((ubar(m,p,-1)*f_tvamf(c_one,c_nil,vp,u(m,q,-1),q) - (p*q-m**2)*(ubar(m,p,-1)*u(m,q,-1))), 0, &
"ubar(p,-).[p*(Isigma*q).u(q,-)] - (p*q-m^2)*ubar(p,-).u(q,-) = 0", passed)
call expect ((vbar(m,p,+1)*f_tvamf(c_one,c_nil,vp,v(m,q,+1),q) - (p*q-m**2)*(vbar(m,p,+1)*v(m,q,+1))), 0, &
"vbar(p,+).[p*(Isigma*q).v(q,+)] - (p*q-m^2)*vbar(p,+).v(q,+) = 0", passed)
call expect ((vbar(m,p,-1)*f_tvamf(c_one,c_nil,vp,v(m,q,-1),q) - (p*q-m**2)*(vbar(m,p,-1)*v(m,q,-1))), 0, &
"vbar(p,-).[p*(Isigma*q).v(q,-)] - (p*q-m^2)*vbar(p,-).v(q,-) = 0", passed)
call expect ((f_ftvam(c_one,c_nil,ubar(m,p,+1),vp,q)*u(m,q,+1) - (p*q-m**2)*(ubar(m,p,+1)*u(m,q,+1))), 0, &
"[ubar(p,+).p*(Isigma*q)].u(q,+) - (p*q-m^2)*ubar(p,+).u(q,+) = 0", passed)
call expect ((f_ftvam(c_one,c_nil,ubar(m,p,-1),vp,q)*u(m,q,-1) - (p*q-m**2)*(ubar(m,p,-1)*u(m,q,-1))), 0, &
"[ubar(p,-).p*(Isigma*q)].u(q,-) - (p*q-m^2)*ubar(p,-).u(q,-) = 0", passed)
call expect ((f_ftvam(c_one,c_nil,vbar(m,p,+1),vp,q)*v(m,q,+1) - (p*q-m**2)*(vbar(m,p,+1)*v(m,q,+1))), 0, &
"[vbar(p,+).p*(Isigma*q)].v(q,+) - (p*q-m^2)*vbar(p,+).v(q,+) = 0", passed)
call expect ((f_ftvam(c_one,c_nil,vbar(m,p,-1),vp,q)*v(m,q,-1) - (p*q-m**2)*(vbar(m,p,-1)*v(m,q,-1))), 0, &
"[vbar(p,-).p*(Isigma*q)].v(q,-) - (p*q-m^2)*vbar(p,-).v(q,-) = 0", passed)
call expect ((vp*tvam_ff(c_nil,c_one,ubar(m,p,+1),u(m,q,+1),q) - (p*q+m**2)*p_ff(c_one,ubar(m,p,+1),u(m,q,+1))), 0, &
"p*[ubar(p,+).(Isigma*q).g5.u(q,+)] - (p*q+m^2)*ubar(p,+).g5.u(q,+) = 0", passed)
call expect ((vp*tvam_ff(c_nil,c_one,ubar(m,p,-1),u(m,q,-1),q) - (p*q+m**2)*p_ff(c_one,ubar(m,p,-1),u(m,q,-1))), 0, &
"p*[ubar(p,-).(Isigma*q).g5.u(q,-)] - (p*q+m^2)*ubar(p,-).g5.u(q,-) = 0", passed)
call expect ((vp*tvam_ff(c_nil,c_one,vbar(m,p,+1),v(m,q,+1),q) - (p*q+m**2)*p_ff(c_one,vbar(m,p,+1),v(m,q,+1))), 0, &
"p*[vbar(p,+).(Isigma*q).g5.v(q,+)] - (p*q+m^2)*vbar(p,+).g5.v(q,+) = 0", passed)
call expect ((vp*tvam_ff(c_nil,c_one,vbar(m,p,-1),v(m,q,-1),q) - (p*q+m**2)*p_ff(c_one,vbar(m,p,-1),v(m,q,-1))), 0, &
"p*[vbar(p,-).(Isigma*q).g5.v(q,-)] - (p*q+m^2)*vbar(p,-).g5.v(q,-) = 0", passed)
call expect ((ubar(m,p,+1)*f_tvamf(c_nil,c_one,vp,u(m,q,+1),q) - (p*q+m**2)*p_ff(c_one,ubar(m,p,+1),u(m,q,+1))), 0, &
"p*[ubar(p,+).(Isigma*q).g5.u(q,+)] - (p*q+m^2)*ubar(p,+).g5.u(q,+) = 0", passed)
call expect ((ubar(m,p,-1)*f_tvamf(c_nil,c_one,vp,u(m,q,-1),q) - (p*q+m**2)*p_ff(c_one,ubar(m,p,-1),u(m,q,-1))), 0, &
"p*[ubar(p,-).(Isigma*q).g5.u(q,-)] - (p*q+m^2)*ubar(p,-).g5.u(q,-) = 0", passed)
call expect ((vbar(m,p,+1)*f_tvamf(c_nil,c_one,vp,v(m,q,+1),q) - (p*q+m**2)*p_ff(c_one,vbar(m,p,+1),v(m,q,+1))), 0, &
"p*[vbar(p,+).(Isigma*q).g5.v(q,+)] - (p*q+m^2)*vbar(p,+).g5.v(q,+) = 0", passed)
call expect ((vbar(m,p,-1)*f_tvamf(c_nil,c_one,vp,v(m,q,-1),q) - (p*q+m**2)*p_ff(c_one,vbar(m,p,-1),v(m,q,-1))), 0, &
"p*[vbar(p,-).(Isigma*q).g5.v(q,-)] - (p*q+m^2)*vbar(p,-).g5.v(q,-) = 0", passed)
call expect ((f_ftvam(c_nil,c_one,ubar(m,p,+1),vp,q)*u(m,q,+1) - (p*q+m**2)*p_ff(c_one,ubar(m,p,+1),u(m,q,+1))), 0, &
"p*[ubar(p,+).(Isigma*q).g5.u(q,+)] - (p*q+m^2)*ubar(p,+).g5.u(q,+) = 0", passed)
call expect ((f_ftvam(c_nil,c_one,ubar(m,p,-1),vp,q)*u(m,q,-1) - (p*q+m**2)*p_ff(c_one,ubar(m,p,-1),u(m,q,-1))), 0, &
"p*[ubar(p,-).(Isigma*q).g5.u(q,-)] - (p*q+m^2)*ubar(p,-).g5.u(q,-) = 0", passed)
call expect ((f_ftvam(c_nil,c_one,vbar(m,p,+1),vp,q)*v(m,q,+1) - (p*q+m**2)*p_ff(c_one,vbar(m,p,+1),v(m,q,+1))), 0, &
"p*[vbar(p,+).(Isigma*q).g5.v(q,+)] - (p*q+m^2)*vbar(p,+).g5.v(q,+) = 0", passed)
call expect ((f_ftvam(c_nil,c_one,vbar(m,p,-1),vp,q)*v(m,q,-1) - (p*q+m**2)*p_ff(c_one,vbar(m,p,-1),v(m,q,-1))), 0, &
"p*[vbar(p,-).(Isigma*q).g5.v(q,-)] - (p*q+m^2)*vbar(p,-).g5.v(q,-) = 0", passed)
@
<<Test [[omega95]]>>=
print *, "*** Checking polarisation vectors: ***"
call expect (conjg(eps(m,p, 1))*eps(m,p, 1), -1, "e( 1).e( 1)=-1", passed)
call expect (conjg(eps(m,p, 1))*eps(m,p,-1), 0, "e( 1).e(-1)= 0", passed)
call expect (conjg(eps(m,p,-1))*eps(m,p, 1), 0, "e(-1).e( 1)= 0", passed)
call expect (conjg(eps(m,p,-1))*eps(m,p,-1), -1, "e(-1).e(-1)=-1", passed)
call expect ( p*eps(m,p, 1), 0, " p.e( 1)= 0", passed)
call expect ( p*eps(m,p,-1), 0, " p.e(-1)= 0", passed)
if (m > 0) then
call expect (conjg(eps(m,p, 1))*eps(m,p, 0), 0, "e( 1).e( 0)= 0", passed)
call expect (conjg(eps(m,p, 0))*eps(m,p, 1), 0, "e( 0).e( 1)= 0", passed)
call expect (conjg(eps(m,p, 0))*eps(m,p, 0), -1, "e( 0).e( 0)=-1", passed)
call expect (conjg(eps(m,p, 0))*eps(m,p,-1), 0, "e( 0).e(-1)= 0", passed)
call expect (conjg(eps(m,p,-1))*eps(m,p, 0), 0, "e(-1).e( 0)= 0", passed)
call expect ( p*eps(m,p, 0), 0, " p.e( 0)= 0", passed)
end if
@
<<Test [[omega95]]>>=
print *, "*** Checking epsilon tensor: ***"
call expect ( pseudo_scalar(eps(m,p,1),eps(m,q,1),eps(m,p,0),eps(m,q,0)), &
- pseudo_scalar(eps(m,q,1),eps(m,p,1),eps(m,p,0),eps(m,q,0)), "eps(1<->2)", passed)
call expect ( pseudo_scalar(eps(m,p,1),eps(m,q,1),eps(m,p,0),eps(m,q,0)), &
- pseudo_scalar(eps(m,p,0),eps(m,q,1),eps(m,p,1),eps(m,q,0)), "eps(1<->3)", passed)
call expect ( pseudo_scalar(eps(m,p,1),eps(m,q,1),eps(m,p,0),eps(m,q,0)), &
- pseudo_scalar(eps(m,q,0),eps(m,q,1),eps(m,p,0),eps(m,p,1)), "eps(1<->4)", passed)
call expect ( pseudo_scalar(eps(m,p,1),eps(m,q,1),eps(m,p,0),eps(m,q,0)), &
- pseudo_scalar(eps(m,p,1),eps(m,p,0),eps(m,q,1),eps(m,q,0)), "eps(2<->3)", passed)
call expect ( pseudo_scalar(eps(m,p,1),eps(m,q,1),eps(m,p,0),eps(m,q,0)), &
- pseudo_scalar(eps(m,p,1),eps(m,q,0),eps(m,p,0),eps(m,q,1)), "eps(2<->4)", passed)
call expect ( pseudo_scalar(eps(m,p,1),eps(m,q,1),eps(m,p,0),eps(m,q,0)), &
- pseudo_scalar(eps(m,p,1),eps(m,q,1),eps(m,q,0),eps(m,p,0)), "eps(3<->4)", passed)
call expect ( pseudo_scalar(eps(m,p,1),eps(m,q,1),eps(m,p,0),eps(m,q,0)), &
eps(m,p,1)*pseudo_vector(eps(m,q,1),eps(m,p,0),eps(m,q,0)), "eps'", passed)
@
\begin{equation}
\frac{1}{2} [x\wedge y]^*_{\mu\nu} [x\wedge y]^{\mu\nu}
= \frac{1}{2} (x^*_\mu y^*_\nu-x^*_\nu y^*_\mu) (x^\mu y^\nu-x^\nu y^\mu)
= (x^*x) (y^*y) - (x^*y) (y^*x)
\end{equation}
<<Test [[omega95]]>>=
print *, "*** Checking tensors: ***"
call expect (conjg(p.wedge.q)*(p.wedge.q), (p*p)*(q*q)-(p*q)**2, &
"[p,q].[q,p]=p.p*q.q-p.q^2", passed)
call expect (conjg(p.wedge.q)*(q.wedge.p), (p*q)**2-(p*p)*(q*q), &
"[p,q].[q,p]=p.q^2-p.p*q.q", passed)
@ i.\,e.
\begin{equation}
\frac{1}{2} [p\wedge\epsilon(p,i)]^*_{\mu\nu} [p\wedge\epsilon(p,j)]^{\mu\nu}
= - p^2 \delta_{ij}
\end{equation}
<<Test [[omega95]]>>=
call expect (conjg(p.wedge.eps(m,p, 1))*(p.wedge.eps(m,p, 1)), -p*p, &
"[p,e( 1)].[p,e( 1)]=-p.p", passed)
call expect (conjg(p.wedge.eps(m,p, 1))*(p.wedge.eps(m,p,-1)), 0, &
"[p,e( 1)].[p,e(-1)]=0", passed)
call expect (conjg(p.wedge.eps(m,p,-1))*(p.wedge.eps(m,p, 1)), 0, &
"[p,e(-1)].[p,e( 1)]=0", passed)
call expect (conjg(p.wedge.eps(m,p,-1))*(p.wedge.eps(m,p,-1)), -p*p, &
"[p,e(-1)].[p,e(-1)]=-p.p", passed)
if (m > 0) then
call expect (conjg(p.wedge.eps(m,p, 1))*(p.wedge.eps(m,p, 0)), 0, &
"[p,e( 1)].[p,e( 0)]=0", passed)
call expect (conjg(p.wedge.eps(m,p, 0))*(p.wedge.eps(m,p, 1)), 0, &
"[p,e( 0)].[p,e( 1)]=0", passed)
call expect (conjg(p.wedge.eps(m,p, 0))*(p.wedge.eps(m,p, 0)), -p*p, &
"[p,e( 0)].[p,e( 0)]=-p.p", passed)
call expect (conjg(p.wedge.eps(m,p, 0))*(p.wedge.eps(m,p,-1)), 0, &
"[p,e( 1)].[p,e(-1)]=0", passed)
call expect (conjg(p.wedge.eps(m,p,-1))*(p.wedge.eps(m,p, 0)), 0, &
"[p,e(-1)].[p,e( 0)]=0", passed)
end if
@ also
\begin{align}
[x\wedge y]_{\mu\nu} z^\nu &= x_\mu (yz) - y_\mu (xz) \\
z_\mu [x\wedge y]^{\mu\nu} &= (zx) y^\nu - (zy) x^\nu
\end{align}
<<Test [[omega95]]>>=
call expect (abs ((p.wedge.eps(m,p, 1))*p + (p*p)*eps(m,p, 1)), 0, &
"[p,e( 1)].p=-p.p*e( 1)]", passed)
call expect (abs ((p.wedge.eps(m,p, 0))*p + (p*p)*eps(m,p, 0)), 0, &
"[p,e( 0)].p=-p.p*e( 0)]", passed)
call expect (abs ((p.wedge.eps(m,p,-1))*p + (p*p)*eps(m,p,-1)), 0, &
"[p,e(-1)].p=-p.p*e(-1)]", passed)
call expect (abs (p*(p.wedge.eps(m,p, 1)) - (p*p)*eps(m,p, 1)), 0, &
"p.[p,e( 1)]=p.p*e( 1)]", passed)
call expect (abs (p*(p.wedge.eps(m,p, 0)) - (p*p)*eps(m,p, 0)), 0, &
"p.[p,e( 0)]=p.p*e( 0)]", passed)
call expect (abs (p*(p.wedge.eps(m,p,-1)) - (p*p)*eps(m,p,-1)), 0, &
"p.[p,e(-1)]=p.p*e(-1)]", passed)
@
<<Test [[omega95]]>>=
print *, "*** Checking polarisation tensors: ***"
call expect (conjg(eps2(m,p, 2))*eps2(m,p, 2), 1, "e2( 2).e2( 2)=1", passed)
call expect (conjg(eps2(m,p, 2))*eps2(m,p,-2), 0, "e2( 2).e2(-2)=0", passed)
call expect (conjg(eps2(m,p,-2))*eps2(m,p, 2), 0, "e2(-2).e2( 2)=0", passed)
call expect (conjg(eps2(m,p,-2))*eps2(m,p,-2), 1, "e2(-2).e2(-2)=1", passed)
if (m > 0) then
call expect (conjg(eps2(m,p, 2))*eps2(m,p, 1), 0, "e2( 2).e2( 1)=0", passed)
call expect (conjg(eps2(m,p, 2))*eps2(m,p, 0), 0, "e2( 2).e2( 0)=0", passed)
call expect (conjg(eps2(m,p, 2))*eps2(m,p,-1), 0, "e2( 2).e2(-1)=0", passed)
call expect (conjg(eps2(m,p, 1))*eps2(m,p, 2), 0, "e2( 1).e2( 2)=0", passed)
call expect (conjg(eps2(m,p, 1))*eps2(m,p, 1), 1, "e2( 1).e2( 1)=1", passed)
call expect (conjg(eps2(m,p, 1))*eps2(m,p, 0), 0, "e2( 1).e2( 0)=0", passed)
call expect (conjg(eps2(m,p, 1))*eps2(m,p,-1), 0, "e2( 1).e2(-1)=0", passed)
call expect (conjg(eps2(m,p, 1))*eps2(m,p,-2), 0, "e2( 1).e2(-2)=0", passed)
call expect (conjg(eps2(m,p, 0))*eps2(m,p, 2), 0, "e2( 0).e2( 2)=0", passed)
call expect (conjg(eps2(m,p, 0))*eps2(m,p, 1), 0, "e2( 0).e2( 1)=0", passed)
call expect (conjg(eps2(m,p, 0))*eps2(m,p, 0), 1, "e2( 0).e2( 0)=1", passed)
call expect (conjg(eps2(m,p, 0))*eps2(m,p,-1), 0, "e2( 0).e2(-1)=0", passed)
call expect (conjg(eps2(m,p, 0))*eps2(m,p,-2), 0, "e2( 0).e2(-2)=0", passed)
call expect (conjg(eps2(m,p,-1))*eps2(m,p, 2), 0, "e2(-1).e2( 2)=0", passed)
call expect (conjg(eps2(m,p,-1))*eps2(m,p, 1), 0, "e2(-1).e2( 1)=0", passed)
call expect (conjg(eps2(m,p,-1))*eps2(m,p, 0), 0, "e2(-1).e2( 0)=0", passed)
call expect (conjg(eps2(m,p,-1))*eps2(m,p,-1), 1, "e2(-1).e2(-1)=1", passed)
call expect (conjg(eps2(m,p,-1))*eps2(m,p,-2), 0, "e2(-1).e2(-2)=0", passed)
call expect (conjg(eps2(m,p,-2))*eps2(m,p, 1), 0, "e2(-2).e2( 1)=0", passed)
call expect (conjg(eps2(m,p,-2))*eps2(m,p, 0), 0, "e2(-2).e2( 0)=0", passed)
call expect (conjg(eps2(m,p,-2))*eps2(m,p,-1), 0, "e2(-2).e2(-1)=0", passed)
end if
@
<<Test [[omega95]]>>=
call expect ( abs(p*eps2(m,p, 2) ), 0, " |p.e2( 2)| =0", passed)
call expect ( abs(eps2(m,p, 2)*p), 0, " |e2( 2).p|=0", passed)
call expect ( abs(p*eps2(m,p,-2) ), 0, " |p.e2(-2)| =0", passed)
call expect ( abs(eps2(m,p,-2)*p), 0, " |e2(-2).p|=0", passed)
if (m > 0) then
call expect ( abs(p*eps2(m,p, 1) ), 0, " |p.e2( 1)| =0", passed)
call expect ( abs(eps2(m,p, 1)*p), 0, " |e2( 1).p|=0", passed)
call expect ( abs(p*eps2(m,p, 0) ), 0, " |p.e2( 0)| =0", passed)
call expect ( abs(eps2(m,p, 0)*p), 0, " |e2( 0).p|=0", passed)
call expect ( abs(p*eps2(m,p,-1) ), 0, " |p.e2(-1)| =0", passed)
call expect ( abs(eps2(m,p,-1)*p), 0, " |e2(-1).p|=0", passed)
end if
@
<<XXX Test [[omega95]]>>=
print *, " *** Checking the polarization tensors for massive gravitons:"
call expect (abs(p * eps2(m,p,2)), 0, "p.e(+2)=0", passed)
call expect (abs(p * eps2(m,p,1)), 0, "p.e(+1)=0", passed)
call expect (abs(p * eps2(m,p,0)), 0, "p.e( 0)=0", passed)
call expect (abs(p * eps2(m,p,-1)), 0, "p.e(-1)=0", passed)
call expect (abs(p * eps2(m,p,-2)), 0, "p.e(-2)=0", passed)
call expect (abs(trace(eps2 (m,p,2))), 0, "Tr[e(+2)]=0", passed)
call expect (abs(trace(eps2 (m,p,1))), 0, "Tr[e(+1)]=0", passed)
call expect (abs(trace(eps2 (m,p,0))), 0, "Tr[e( 0)]=0", passed)
call expect (abs(trace(eps2 (m,p,-1))), 0, "Tr[e(-1)]=0", passed)
call expect (abs(trace(eps2 (m,p,-2))), 0, "Tr[e(-2)]=0", passed)
call expect (abs(eps2(m,p,2) * eps2(m,p,2)), 1, &
"e(2).e(2) = 1", passed)
call expect (abs(eps2(m,p,2) * eps2(m,p,1)), 0, &
"e(2).e(1) = 0", passed)
call expect (abs(eps2(m,p,2) * eps2(m,p,0)), 0, &
"e(2).e(0) = 0", passed)
call expect (abs(eps2(m,p,2) * eps2(m,p,-1)), 0, &
"e(2).e(-1) = 0", passed)
call expect (abs(eps2(m,p,2) * eps2(m,p,-2)), 0, &
"e(2).e(-2) = 0", passed)
call expect (abs(eps2(m,p,1) * eps2(m,p,1)), 1, &
"e(1).e(1) = 1", passed)
call expect (abs(eps2(m,p,1) * eps2(m,p,0)), 0, &
"e(1).e(0) = 0", passed)
call expect (abs(eps2(m,p,1) * eps2(m,p,-1)), 0, &
"e(1).e(-1) = 0", passed)
call expect (abs(eps2(m,p,1) * eps2(m,p,-2)), 0, &
"e(1).e(-2) = 0", passed)
call expect (abs(eps2(m,p,0) * eps2(m,p,0)), 1, &
"e(0).e(0) = 1", passed)
call expect (abs(eps2(m,p,0) * eps2(m,p,-1)), 0, &
"e(0).e(-1) = 0", passed)
call expect (abs(eps2(m,p,0) * eps2(m,p,-2)), 0, &
"e(0).e(-2) = 0", passed)
call expect (abs(eps2(m,p,-1) * eps2(m,p,-1)), 1, &
"e(-1).e(-1) = 1", passed)
call expect (abs(eps2(m,p,-1) * eps2(m,p,-2)), 0, &
"e(-1).e(-2) = 0", passed)
call expect (abs(eps2(m,p,-2) * eps2(m,p,-2)), 1, &
"e(-2).e(-2) = 1", passed)
@
<<Test [[omega95]]>>=
print *, " *** Checking the graviton propagator:"
call expect (abs(p * (cmplx (p*p - m**2, m*w, kind=default) * &
pr_tensor(p,m,w,eps2(m,p,-2)))), 0, "p.pr.e(-2)", passed)
call expect (abs(p * (cmplx (p*p - m**2, m*w, kind=default) * &
pr_tensor(p,m,w,eps2(m,p,-1)))), 0, "p.pr.e(-1)", passed)
call expect (abs(p * (cmplx (p*p - m**2, m*w, kind=default) * &
pr_tensor(p,m,w,eps2(m,p,0)))), 0, "p.pr.e(0)", passed)
call expect (abs(p * (cmplx (p*p - m**2, m*w, kind=default) * &
pr_tensor(p,m,w,eps2(m,p,1)))), 0, "p.pr.e(1)", passed)
call expect (abs(p * (cmplx (p*p - m**2, m*w, kind=default) * &
pr_tensor(p,m,w,eps2(m,p,2)))), 0, "p.pr.e(2)", passed)
call expect (abs(p * (cmplx (p*p - m**2, m*w, kind=default) * &
pr_tensor(p,m,w,ttest))), 0, "p.pr.ttest", passed)
@
<<[[test_omega95_bispinors.f90]]>>=
<<Copyleft>>
program test_omega95_bispinors
use kinds
use omega95_bispinors
use omega_vspinor_polarizations
use omega_testtools
implicit none
integer :: i, j
real(kind=default) :: m, pabs, qabs, tabs, zabs, w
real(kind=default), dimension(4) :: r
complex(kind=default) :: c_nil, c_one, c_two
type(momentum) :: p, q, t, z, p_0
type(vector) :: vp, vq, vt, vz
type(vectorspinor) :: testv
type(bispinor) :: vv
logical :: passed
call random_seed ()
c_nil = 0.0_default
c_one = 1.0_default
c_two = 2.0_default
w = 1.4142
m = 13
pabs = 42
qabs = 137
tabs = 84
zabs = 3.1415
p_0%t = m
p_0%x = 0
call random_momentum (p, pabs, m)
call random_momentum (q, qabs, m)
call random_momentum (t, tabs, m)
call random_momentum (z, zabs, m)
call random_number (r)
do i = 1, 4
testv%psi(1)%a(i) = (0.0_default, 0.0_default)
end do
do i = 2, 3
do j = 1, 4
testv%psi(i)%a(j) = cmplx (10.0_default * r(j), kind=default)
end do
end do
testv%psi(4)%a(1) = (1.0_default, 0.0_default)
testv%psi(4)%a(2) = (0.0_default, 2.0_default)
testv%psi(4)%a(3) = (1.0_default, 0.0_default)
testv%psi(4)%a(4) = (3.0_default, 0.0_default)
vp = p
vq = q
vt = t
vz = z
passed = .true.
vv%a(1) = (1.0_default, 0.0_default)
vv%a(2) = (0.0_default, 2.0_default)
vv%a(3) = (1.0_default, 0.0_default)
vv%a(4) = (3.0_default, 0.0_default)
vv = pr_psi(p, m, w, .false., vv)
<<Test [[omega95_bispinors]]>>
if (.not. passed) then
stop 1
end if
end program test_omega95_bispinors
@
<<Test [[omega95_bispinors]]>>=
print *, "*** Checking the equations of motion ***:"
call expect (abs(f_vf(c_one,vp,u(m,p,+1))-m*u(m,p,+1)), 0, "|[p-m]u(+)|=0", passed)
call expect (abs(f_vf(c_one,vp,u(m,p,-1))-m*u(m,p,-1)), 0, "|[p-m]u(-)|=0", passed)
call expect (abs(f_vf(c_one,vp,v(m,p,+1))+m*v(m,p,+1)), 0, "|[p+m]v(+)|=0", passed)
call expect (abs(f_vf(c_one,vp,v(m,p,-1))+m*v(m,p,-1)), 0, "|[p+m]v(-)|=0", passed)
print *, "*** Checking the equations of motion for negative masses***:"
call expect (abs(f_vf(c_one,vp,u(-m,p,+1))+m*u(-m,p,+1)), 0, "|[p+m]u(+)|=0", passed)
call expect (abs(f_vf(c_one,vp,u(-m,p,-1))+m*u(-m,p,-1)), 0, "|[p+m]u(-)|=0", passed)
call expect (abs(f_vf(c_one,vp,v(-m,p,+1))-m*v(-m,p,+1)), 0, "|[p-m]v(+)|=0", passed)
call expect (abs(f_vf(c_one,vp,v(-m,p,-1))-m*v(-m,p,-1)), 0, "|[p-m]v(-)|=0", passed)
@
<<Test [[omega95_bispinors]]>>=
print *, "*** Checking the normalization ***:"
call expect (s_ff(c_one,v(m,p,+1),u(m,p,+1)), +2*m, "ubar(+)*u(+)=+2m", passed)
call expect (s_ff(c_one,v(m,p,-1),u(m,p,-1)), +2*m, "ubar(-)*u(-)=+2m", passed)
call expect (s_ff(c_one,u(m,p,+1),v(m,p,+1)), -2*m, "vbar(+)*v(+)=-2m", passed)
call expect (s_ff(c_one,u(m,p,-1),v(m,p,-1)), -2*m, "vbar(-)*v(-)=-2m", passed)
call expect (s_ff(c_one,v(m,p,+1),v(m,p,+1)), 0, "ubar(+)*v(+)=0 ", passed)
call expect (s_ff(c_one,v(m,p,-1),v(m,p,-1)), 0, "ubar(-)*v(-)=0 ", passed)
call expect (s_ff(c_one,u(m,p,+1),u(m,p,+1)), 0, "vbar(+)*u(+)=0 ", passed)
call expect (s_ff(c_one,u(m,p,-1),u(m,p,-1)), 0, "vbar(-)*u(-)=0 ", passed)
print *, "*** Checking the normalization for negative masses***:"
call expect (s_ff(c_one,v(-m,p,+1),u(-m,p,+1)), -2*m, "ubar(+)*u(+)=-2m", passed)
call expect (s_ff(c_one,v(-m,p,-1),u(-m,p,-1)), -2*m, "ubar(-)*u(-)=-2m", passed)
call expect (s_ff(c_one,u(-m,p,+1),v(-m,p,+1)), +2*m, "vbar(+)*v(+)=+2m", passed)
call expect (s_ff(c_one,u(-m,p,-1),v(-m,p,-1)), +2*m, "vbar(-)*v(-)=+2m", passed)
call expect (s_ff(c_one,v(-m,p,+1),v(-m,p,+1)), 0, "ubar(+)*v(+)=0 ", passed)
call expect (s_ff(c_one,v(-m,p,-1),v(-m,p,-1)), 0, "ubar(-)*v(-)=0 ", passed)
call expect (s_ff(c_one,u(-m,p,+1),u(-m,p,+1)), 0, "vbar(+)*u(+)=0 ", passed)
call expect (s_ff(c_one,u(-m,p,-1),u(-m,p,-1)), 0, "vbar(-)*u(-)=0 ", passed)
@
<<Test [[omega95_bispinors]]>>=
print *, "*** Checking the currents ***:"
call expect (abs(v_ff(c_one,v(m,p,+1),u(m,p,+1))-2*vp), 0, "ubar(+).V.u(+)=2p", passed)
call expect (abs(v_ff(c_one,v(m,p,-1),u(m,p,-1))-2*vp), 0, "ubar(-).V.u(-)=2p", passed)
call expect (abs(v_ff(c_one,u(m,p,+1),v(m,p,+1))-2*vp), 0, "vbar(+).V.v(+)=2p", passed)
call expect (abs(v_ff(c_one,u(m,p,-1),v(m,p,-1))-2*vp), 0, "vbar(-).V.v(-)=2p", passed)
print *, "*** Checking the currents for negative masses***:"
call expect (abs(v_ff(c_one,v(-m,p,+1),u(-m,p,+1))-2*vp), 0, "ubar(+).V.u(+)=2p", passed)
call expect (abs(v_ff(c_one,v(-m,p,-1),u(-m,p,-1))-2*vp), 0, "ubar(-).V.u(-)=2p", passed)
call expect (abs(v_ff(c_one,u(-m,p,+1),v(-m,p,+1))-2*vp), 0, "vbar(+).V.v(+)=2p", passed)
call expect (abs(v_ff(c_one,u(-m,p,-1),v(-m,p,-1))-2*vp), 0, "vbar(-).V.v(-)=2p", passed)
@
<<Test [[omega95_bispinors]]>>=
print *, "*** Checking current conservation ***:"
call expect ((vp-vq)*v_ff(c_one,v(m,p,+1),u(m,q,+1)), 0, "d(ubar(+).V.u(+))=0", passed)
call expect ((vp-vq)*v_ff(c_one,v(m,p,-1),u(m,q,-1)), 0, "d(ubar(-).V.u(-))=0", passed)
call expect ((vp-vq)*v_ff(c_one,u(m,p,+1),v(m,q,+1)), 0, "d(vbar(+).V.v(+))=0", passed)
call expect ((vp-vq)*v_ff(c_one,u(m,p,-1),v(m,q,-1)), 0, "d(vbar(-).V.v(-))=0", passed)
<<Test [[omega95_bispinors]]>>=
print *, "*** Checking current conservation for negative masses***:"
call expect ((vp-vq)*v_ff(c_one,v(-m,p,+1),u(-m,q,+1)), 0, "d(ubar(+).V.u(+))=0", passed)
call expect ((vp-vq)*v_ff(c_one,v(-m,p,-1),u(-m,q,-1)), 0, "d(ubar(-).V.u(-))=0", passed)
call expect ((vp-vq)*v_ff(c_one,u(-m,p,+1),v(-m,q,+1)), 0, "d(vbar(+).V.v(+))=0", passed)
call expect ((vp-vq)*v_ff(c_one,u(-m,p,-1),v(-m,q,-1)), 0, "d(vbar(-).V.v(-))=0", passed)
@
<<Test [[omega95_bispinors]]>>=
if (m == 0) then
print *, "*** Checking axial current conservation ***:"
call expect ((vp-vq)*a_ff(c_one,v(m,p,+1),u(m,q,+1)), 0, "d(ubar(+).A.u(+))=0", passed)
call expect ((vp-vq)*a_ff(c_one,v(m,p,-1),u(m,q,-1)), 0, "d(ubar(-).A.u(-))=0", passed)
call expect ((vp-vq)*a_ff(c_one,u(m,p,+1),v(m,q,+1)), 0, "d(vbar(+).A.v(+))=0", passed)
call expect ((vp-vq)*a_ff(c_one,u(m,p,-1),v(m,q,-1)), 0, "d(vbar(-).A.v(-))=0", passed)
end if
<<Test [[omega95_bispinors]]>>=
print *, "*** Checking implementation of the sigma vertex funktions ***:"
call expect ((vp*tvam_ff(c_one,c_nil,v(m,p,+1),u(m,q,+1),q) - (p*q-m**2)*(v(m,p,+1)*u(m,q,+1))), 0, &
"p*[ubar(p,+).(Isigma*q).u(q,+)] - (p*q-m^2)*ubar(p,+).u(q,+) = 0", passed)
call expect ((vp*tvam_ff(c_one,c_nil,v(m,p,-1),u(m,q,-1),q) - (p*q-m**2)*(v(m,p,-1)*u(m,q,-1))), 0, &
"p*[ubar(p,-).(Isigma*q).u(q,-)] - (p*q-m^2)*ubar(p,-).u(q,-) = 0", passed)
call expect ((vp*tvam_ff(c_one,c_nil,u(m,p,+1),v(m,q,+1),q) - (p*q-m**2)*(u(m,p,+1)*v(m,q,+1))), 0, &
"p*[vbar(p,+).(Isigma*q).v(q,+)] - (p*q-m^2)*vbar(p,+).v(q,+) = 0", passed)
call expect ((vp*tvam_ff(c_one,c_nil,u(m,p,-1),v(m,q,-1),q) - (p*q-m**2)*(u(m,p,-1)*v(m,q,-1))), 0, &
"p*[vbar(p,-).(Isigma*q).v(q,-)] - (p*q-m^2)*vbar(p,-).v(q,-) = 0", passed)
call expect ((v(m,p,+1)*f_tvamf(c_one,c_nil,vp,u(m,q,+1),q) - (p*q-m**2)*(v(m,p,+1)*u(m,q,+1))), 0, &
"ubar(p,+).[p*(Isigma*q).u(q,+)] - (p*q-m^2)*ubar(p,+).u(q,+) = 0", passed)
call expect ((v(m,p,-1)*f_tvamf(c_one,c_nil,vp,u(m,q,-1),q) - (p*q-m**2)*(v(m,p,-1)*u(m,q,-1))), 0, &
"ubar(p,-).[p*(Isigma*q).u(q,-)] - (p*q-m^2)*ubar(p,-).u(q,-) = 0", passed)
call expect ((u(m,p,+1)*f_tvamf(c_one,c_nil,vp,v(m,q,+1),q) - (p*q-m**2)*(u(m,p,+1)*v(m,q,+1))), 0, &
"vbar(p,+).[p*(Isigma*q).v(q,+)] - (p*q-m^2)*vbar(p,+).v(q,+) = 0", passed)
call expect ((u(m,p,-1)*f_tvamf(c_one,c_nil,vp,v(m,q,-1),q) - (p*q-m**2)*(u(m,p,-1)*v(m,q,-1))), 0, &
"vbar(p,-).[p*(Isigma*q).v(q,-)] - (p*q-m^2)*vbar(p,-).v(q,-) = 0", passed)
call expect ((vp*tvam_ff(c_nil,c_one,v(m,p,+1),u(m,q,+1),q) - (p*q+m**2)*p_ff(c_one,v(m,p,+1),u(m,q,+1))), 0, &
"p*[ubar(p,+).(Isigma*q).g5.u(q,+)] - (p*q+m^2)*ubar(p,+).g5.u(q,+) = 0", passed)
call expect ((vp*tvam_ff(c_nil,c_one,v(m,p,-1),u(m,q,-1),q) - (p*q+m**2)*p_ff(c_one,v(m,p,-1),u(m,q,-1))), 0, &
"p*[ubar(p,-).(Isigma*q).g5.u(q,-)] - (p*q+m^2)*ubar(p,-).g5.u(q,-) = 0", passed)
call expect ((vp*tvam_ff(c_nil,c_one,u(m,p,+1),v(m,q,+1),q) - (p*q+m**2)*p_ff(c_one,u(m,p,+1),v(m,q,+1))), 0, &
"p*[vbar(p,+).(Isigma*q).g5.v(q,+)] - (p*q+m^2)*vbar(p,+).g5.v(q,+) = 0", passed)
call expect ((vp*tvam_ff(c_nil,c_one,u(m,p,-1),v(m,q,-1),q) - (p*q+m**2)*p_ff(c_one,u(m,p,-1),v(m,q,-1))), 0, &
"p*[vbar(p,-).(Isigma*q).g5.v(q,-)] - (p*q+m^2)*vbar(p,-).g5.v(q,-) = 0", passed)
call expect ((v(m,p,+1)*f_tvamf(c_nil,c_one,vp,u(m,q,+1),q) - (p*q+m**2)*p_ff(c_one,v(m,p,+1),u(m,q,+1))), 0, &
"p*[ubar(p,+).(Isigma*q).g5.u(q,+)] - (p*q+m^2)*ubar(p,+).g5.u(q,+) = 0", passed)
call expect ((v(m,p,-1)*f_tvamf(c_nil,c_one,vp,u(m,q,-1),q) - (p*q+m**2)*p_ff(c_one,v(m,p,-1),u(m,q,-1))), 0, &
"p*[ubar(p,-).(Isigma*q).g5.u(q,-)] - (p*q+m^2)*ubar(p,-).g5.u(q,-) = 0", passed)
call expect ((u(m,p,+1)*f_tvamf(c_nil,c_one,vp,v(m,q,+1),q) - (p*q+m**2)*p_ff(c_one,u(m,p,+1),v(m,q,+1))), 0, &
"p*[vbar(p,+).(Isigma*q).g5.v(q,+)] - (p*q+m^2)*vbar(p,+).g5.v(q,+) = 0", passed)
call expect ((u(m,p,-1)*f_tvamf(c_nil,c_one,vp,v(m,q,-1),q) - (p*q+m**2)*p_ff(c_one,u(m,p,-1),v(m,q,-1))), 0, &
"p*[vbar(p,-).(Isigma*q).g5.v(q,-)] - (p*q+m^2)*vbar(p,-).g5.v(q,-) = 0", passed)
@
<<Test [[omega95_bispinors]]>>=
print *, "*** Checking polarization vectors: ***"
call expect (conjg(eps(m,p, 1))*eps(m,p, 1), -1, "e( 1).e( 1)=-1", passed)
call expect (conjg(eps(m,p, 1))*eps(m,p,-1), 0, "e( 1).e(-1)= 0", passed)
call expect (conjg(eps(m,p,-1))*eps(m,p, 1), 0, "e(-1).e( 1)= 0", passed)
call expect (conjg(eps(m,p,-1))*eps(m,p,-1), -1, "e(-1).e(-1)=-1", passed)
call expect ( p*eps(m,p, 1), 0, " p.e( 1)= 0", passed)
call expect ( p*eps(m,p,-1), 0, " p.e(-1)= 0", passed)
if (m > 0) then
call expect (conjg(eps(m,p, 1))*eps(m,p, 0), 0, "e( 1).e( 0)= 0", passed)
call expect (conjg(eps(m,p, 0))*eps(m,p, 1), 0, "e( 0).e( 1)= 0", passed)
call expect (conjg(eps(m,p, 0))*eps(m,p, 0), -1, "e( 0).e( 0)=-1", passed)
call expect (conjg(eps(m,p, 0))*eps(m,p,-1), 0, "e( 0).e(-1)= 0", passed)
call expect (conjg(eps(m,p,-1))*eps(m,p, 0), 0, "e(-1).e( 0)= 0", passed)
call expect ( p*eps(m,p, 0), 0, " p.e( 0)= 0", passed)
end if
@
<<Test [[omega95_bispinors]]>>=
print *, "*** Checking polarization vectorspinors: ***"
call expect (abs(p * ueps(m, p, 2)), 0, "p.ueps ( 2)= 0", passed)
call expect (abs(p * ueps(m, p, 1)), 0, "p.ueps ( 1)= 0", passed)
call expect (abs(p * ueps(m, p, -1)), 0, "p.ueps (-1)= 0", passed)
call expect (abs(p * ueps(m, p, -2)), 0, "p.ueps (-2)= 0", passed)
call expect (abs(p * veps(m, p, 2)), 0, "p.veps ( 2)= 0", passed)
call expect (abs(p * veps(m, p, 1)), 0, "p.veps ( 1)= 0", passed)
call expect (abs(p * veps(m, p, -1)), 0, "p.veps (-1)= 0", passed)
call expect (abs(p * veps(m, p, -2)), 0, "p.veps (-2)= 0", passed)
print *, "*** Checking polarization vectorspinors (neg. masses): ***"
call expect (abs(p * ueps(-m, p, 2)), 0, "p.ueps ( 2)= 0", passed)
call expect (abs(p * ueps(-m, p, 1)), 0, "p.ueps ( 1)= 0", passed)
call expect (abs(p * ueps(-m, p, -1)), 0, "p.ueps (-1)= 0", passed)
call expect (abs(p * ueps(-m, p, -2)), 0, "p.ueps (-2)= 0", passed)
call expect (abs(p * veps(-m, p, 2)), 0, "p.veps ( 2)= 0", passed)
call expect (abs(p * veps(-m, p, 1)), 0, "p.veps ( 1)= 0", passed)
call expect (abs(p * veps(-m, p, -1)), 0, "p.veps (-1)= 0", passed)
call expect (abs(p * veps(-m, p, -2)), 0, "p.veps (-2)= 0", passed)
print *, "*** in the rest frame ***"
call expect (abs(p_0 * ueps(m, p_0, 2)), 0, "p0.ueps ( 2)= 0", passed)
call expect (abs(p_0 * ueps(m, p_0, 1)), 0, "p0.ueps ( 1)= 0", passed)
call expect (abs(p_0 * ueps(m, p_0, -1)), 0, "p0.ueps (-1)= 0", passed)
call expect (abs(p_0 * ueps(m, p_0, -2)), 0, "p0.ueps (-2)= 0", passed)
call expect (abs(p_0 * veps(m, p_0, 2)), 0, "p0.veps ( 2)= 0", passed)
call expect (abs(p_0 * veps(m, p_0, 1)), 0, "p0.veps ( 1)= 0", passed)
call expect (abs(p_0 * veps(m, p_0, -1)), 0, "p0.veps (-1)= 0", passed)
call expect (abs(p_0 * veps(m, p_0, -2)), 0, "p0.veps (-2)= 0", passed)
print *, "*** in the rest frame (neg. masses) ***"
call expect (abs(p_0 * ueps(-m, p_0, 2)), 0, "p0.ueps ( 2)= 0", passed)
call expect (abs(p_0 * ueps(-m, p_0, 1)), 0, "p0.ueps ( 1)= 0", passed)
call expect (abs(p_0 * ueps(-m, p_0, -1)), 0, "p0.ueps (-1)= 0", passed)
call expect (abs(p_0 * ueps(-m, p_0, -2)), 0, "p0.ueps (-2)= 0", passed)
call expect (abs(p_0 * veps(-m, p_0, 2)), 0, "p0.veps ( 2)= 0", passed)
call expect (abs(p_0 * veps(-m, p_0, 1)), 0, "p0.veps ( 1)= 0", passed)
call expect (abs(p_0 * veps(-m, p_0, -1)), 0, "p0.veps (-1)= 0", passed)
call expect (abs(p_0 * veps(-m, p_0, -2)), 0, "p0.veps (-2)= 0", passed)
@
<<Test [[omega95_bispinors]]>>=
print *, "*** Checking the irreducibility condition: ***"
call expect (abs(f_potgr (c_one, c_one, ueps(m, p, 2))), 0, "g.ueps ( 2)", passed)
call expect (abs(f_potgr (c_one, c_one, ueps(m, p, 1))), 0, "g.ueps ( 1)", passed)
call expect (abs(f_potgr (c_one, c_one, ueps(m, p, -1))), 0, "g.ueps (-1)", passed)
call expect (abs(f_potgr (c_one, c_one, ueps(m, p, -2))), 0, "g.ueps (-2)", passed)
call expect (abs(f_potgr (c_one, c_one, veps(m, p, 2))), 0, "g.veps ( 2)", passed)
call expect (abs(f_potgr (c_one, c_one, veps(m, p, 1))), 0, "g.veps ( 1)", passed)
call expect (abs(f_potgr (c_one, c_one, veps(m, p, -1))), 0, "g.veps (-1)", passed)
call expect (abs(f_potgr (c_one, c_one, veps(m, p, -2))), 0, "g.veps (-2)", passed)
print *, "*** Checking the irreducibility condition (neg. masses): ***"
call expect (abs(f_potgr (c_one, c_one, ueps(-m, p, 2))), 0, "g.ueps ( 2)", passed)
call expect (abs(f_potgr (c_one, c_one, ueps(-m, p, 1))), 0, "g.ueps ( 1)", passed)
call expect (abs(f_potgr (c_one, c_one, ueps(-m, p, -1))), 0, "g.ueps (-1)", passed)
call expect (abs(f_potgr (c_one, c_one, ueps(-m, p, -2))), 0, "g.ueps (-2)", passed)
call expect (abs(f_potgr (c_one, c_one, veps(-m, p, 2))), 0, "g.veps ( 2)", passed)
call expect (abs(f_potgr (c_one, c_one, veps(-m, p, 1))), 0, "g.veps ( 1)", passed)
call expect (abs(f_potgr (c_one, c_one, veps(-m, p, -1))), 0, "g.veps (-1)", passed)
call expect (abs(f_potgr (c_one, c_one, veps(-m, p, -2))), 0, "g.veps (-2)", passed)
print *, "*** in the rest frame ***"
call expect (abs(f_potgr (c_one, c_one, ueps(m, p_0, 2))), 0, "g.ueps ( 2)", passed)
call expect (abs(f_potgr (c_one, c_one, ueps(m, p_0, 1))), 0, "g.ueps ( 1)", passed)
call expect (abs(f_potgr (c_one, c_one, ueps(m, p_0, -1))), 0, "g.ueps (-1)", passed)
call expect (abs(f_potgr (c_one, c_one, ueps(m, p_0, -2))), 0, "g.ueps (-2)", passed)
call expect (abs(f_potgr (c_one, c_one, veps(m, p_0, 2))), 0, "g.veps ( 2)", passed)
call expect (abs(f_potgr (c_one, c_one, veps(m, p_0, 1))), 0, "g.veps ( 1)", passed)
call expect (abs(f_potgr (c_one, c_one, veps(m, p_0, -1))), 0, "g.veps (-1)", passed)
call expect (abs(f_potgr (c_one, c_one, veps(m, p_0, -2))), 0, "g.veps (-2)", passed)
print *, "*** in the rest frame (neg. masses) ***"
call expect (abs(f_potgr (c_one, c_one, ueps(m, p_0, 2))), 0, "g.ueps ( 2)", passed)
call expect (abs(f_potgr (c_one, c_one, ueps(m, p_0, 1))), 0, "g.ueps ( 1)", passed)
call expect (abs(f_potgr (c_one, c_one, ueps(m, p_0, -1))), 0, "g.ueps (-1)", passed)
call expect (abs(f_potgr (c_one, c_one, ueps(m, p_0, -2))), 0, "g.ueps (-2)", passed)
call expect (abs(f_potgr (c_one, c_one, veps(m, p_0, 2))), 0, "g.veps ( 2)", passed)
call expect (abs(f_potgr (c_one, c_one, veps(m, p_0, 1))), 0, "g.veps ( 1)", passed)
call expect (abs(f_potgr (c_one, c_one, veps(m, p_0, -1))), 0, "g.veps (-1)", passed)
call expect (abs(f_potgr (c_one, c_one, veps(m, p_0, -2))), 0, "g.veps (-2)", passed)
@
<<Test [[omega95_bispinors]]>>=
print *, "*** Testing vectorspinor normalization ***"
call expect (veps(m,p, 2)*ueps(m,p, 2), -2*m, "ueps( 2).ueps( 2)= -2m", passed)
call expect (veps(m,p, 1)*ueps(m,p, 1), -2*m, "ueps( 1).ueps( 1)= -2m", passed)
call expect (veps(m,p,-1)*ueps(m,p,-1), -2*m, "ueps(-1).ueps(-1)= -2m", passed)
call expect (veps(m,p,-2)*ueps(m,p,-2), -2*m, "ueps(-2).ueps(-2)= -2m", passed)
call expect (ueps(m,p, 2)*veps(m,p, 2), 2*m, "veps( 2).veps( 2)= +2m", passed)
call expect (ueps(m,p, 1)*veps(m,p, 1), 2*m, "veps( 1).veps( 1)= +2m", passed)
call expect (ueps(m,p,-1)*veps(m,p,-1), 2*m, "veps(-1).veps(-1)= +2m", passed)
call expect (ueps(m,p,-2)*veps(m,p,-2), 2*m, "veps(-2).veps(-2)= +2m", passed)
call expect (ueps(m,p, 2)*ueps(m,p, 2), 0, "ueps( 2).veps( 2)= 0", passed)
call expect (ueps(m,p, 1)*ueps(m,p, 1), 0, "ueps( 1).veps( 1)= 0", passed)
call expect (ueps(m,p,-1)*ueps(m,p,-1), 0, "ueps(-1).veps(-1)= 0", passed)
call expect (ueps(m,p,-2)*ueps(m,p,-2), 0, "ueps(-2).veps(-2)= 0", passed)
call expect (veps(m,p, 2)*veps(m,p, 2), 0, "veps( 2).ueps( 2)= 0", passed)
call expect (veps(m,p, 1)*veps(m,p, 1), 0, "veps( 1).ueps( 1)= 0", passed)
call expect (veps(m,p,-1)*veps(m,p,-1), 0, "veps(-1).ueps(-1)= 0", passed)
call expect (veps(m,p,-2)*veps(m,p,-2), 0, "veps(-2).ueps(-2)= 0", passed)
print *, "*** Testing vectorspinor normalization (neg. masses) ***"
call expect (veps(-m,p, 2)*ueps(-m,p, 2), +2*m, "ueps( 2).ueps( 2)= +2m", passed)
call expect (veps(-m,p, 1)*ueps(-m,p, 1), +2*m, "ueps( 1).ueps( 1)= +2m", passed)
call expect (veps(-m,p,-1)*ueps(-m,p,-1), +2*m, "ueps(-1).ueps(-1)= +2m", passed)
call expect (veps(-m,p,-2)*ueps(-m,p,-2), +2*m, "ueps(-2).ueps(-2)= +2m", passed)
call expect (ueps(-m,p, 2)*veps(-m,p, 2), -2*m, "veps( 2).veps( 2)= -2m", passed)
call expect (ueps(-m,p, 1)*veps(-m,p, 1), -2*m, "veps( 1).veps( 1)= -2m", passed)
call expect (ueps(-m,p,-1)*veps(-m,p,-1), -2*m, "veps(-1).veps(-1)= -2m", passed)
call expect (ueps(-m,p,-2)*veps(-m,p,-2), -2*m, "veps(-2).veps(-2)= -2m", passed)
call expect (ueps(-m,p, 2)*ueps(-m,p, 2), 0, "ueps( 2).veps( 2)= 0", passed)
call expect (ueps(-m,p, 1)*ueps(-m,p, 1), 0, "ueps( 1).veps( 1)= 0", passed)
call expect (ueps(-m,p,-1)*ueps(-m,p,-1), 0, "ueps(-1).veps(-1)= 0", passed)
call expect (ueps(-m,p,-2)*ueps(-m,p,-2), 0, "ueps(-2).veps(-2)= 0", passed)
call expect (veps(-m,p, 2)*veps(-m,p, 2), 0, "veps( 2).ueps( 2)= 0", passed)
call expect (veps(-m,p, 1)*veps(-m,p, 1), 0, "veps( 1).ueps( 1)= 0", passed)
call expect (veps(-m,p,-1)*veps(-m,p,-1), 0, "veps(-1).ueps(-1)= 0", passed)
call expect (veps(-m,p,-2)*veps(-m,p,-2), 0, "veps(-2).ueps(-2)= 0", passed)
print *, "*** in the rest frame ***"
call expect (veps(m,p_0, 2)*ueps(m,p_0, 2), -2*m, "ueps( 2).ueps( 2)= -2m", passed)
call expect (veps(m,p_0, 1)*ueps(m,p_0, 1), -2*m, "ueps( 1).ueps( 1)= -2m", passed)
call expect (veps(m,p_0,-1)*ueps(m,p_0,-1), -2*m, "ueps(-1).ueps(-1)= -2m", passed)
call expect (veps(m,p_0,-2)*ueps(m,p_0,-2), -2*m, "ueps(-2).ueps(-2)= -2m", passed)
call expect (ueps(m,p_0, 2)*veps(m,p_0, 2), 2*m, "veps( 2).veps( 2)= +2m", passed)
call expect (ueps(m,p_0, 1)*veps(m,p_0, 1), 2*m, "veps( 1).veps( 1)= +2m", passed)
call expect (ueps(m,p_0,-1)*veps(m,p_0,-1), 2*m, "veps(-1).veps(-1)= +2m", passed)
call expect (ueps(m,p_0,-2)*veps(m,p_0,-2), 2*m, "veps(-2).veps(-2)= +2m", passed)
call expect (ueps(m,p_0, 2)*ueps(m,p_0, 2), 0, "ueps( 2).veps( 2)= 0", passed)
call expect (ueps(m,p_0, 1)*ueps(m,p_0, 1), 0, "ueps( 1).veps( 1)= 0", passed)
call expect (ueps(m,p_0,-1)*ueps(m,p_0,-1), 0, "ueps(-1).veps(-1)= 0", passed)
call expect (ueps(m,p_0,-2)*ueps(m,p_0,-2), 0, "ueps(-2).veps(-2)= 0", passed)
call expect (veps(m,p_0, 2)*veps(m,p_0, 2), 0, "veps( 2).ueps( 2)= 0", passed)
call expect (veps(m,p_0, 1)*veps(m,p_0, 1), 0, "veps( 1).ueps( 1)= 0", passed)
call expect (veps(m,p_0,-1)*veps(m,p_0,-1), 0, "veps(-1).ueps(-1)= 0", passed)
call expect (veps(m,p_0,-2)*veps(m,p_0,-2), 0, "veps(-2).ueps(-2)= 0", passed)
print *, "*** in the rest frame (neg. masses) ***"
call expect (veps(-m,p_0, 2)*ueps(-m,p_0, 2), +2*m, "ueps( 2).ueps( 2)= +2m", passed)
call expect (veps(-m,p_0, 1)*ueps(-m,p_0, 1), +2*m, "ueps( 1).ueps( 1)= +2m", passed)
call expect (veps(-m,p_0,-1)*ueps(-m,p_0,-1), +2*m, "ueps(-1).ueps(-1)= +2m", passed)
call expect (veps(-m,p_0,-2)*ueps(-m,p_0,-2), +2*m, "ueps(-2).ueps(-2)= +2m", passed)
call expect (ueps(-m,p_0, 2)*veps(-m,p_0, 2), -2*m, "veps( 2).veps( 2)= -2m", passed)
call expect (ueps(-m,p_0, 1)*veps(-m,p_0, 1), -2*m, "veps( 1).veps( 1)= -2m", passed)
call expect (ueps(-m,p_0,-1)*veps(-m,p_0,-1), -2*m, "veps(-1).veps(-1)= -2m", passed)
call expect (ueps(-m,p_0,-2)*veps(-m,p_0,-2), -2*m, "veps(-2).veps(-2)= -2m", passed)
call expect (ueps(-m,p_0, 2)*ueps(-m,p_0, 2), 0, "ueps( 2).veps( 2)= 0", passed)
call expect (ueps(-m,p_0, 1)*ueps(-m,p_0, 1), 0, "ueps( 1).veps( 1)= 0", passed)
call expect (ueps(-m,p_0,-1)*ueps(-m,p_0,-1), 0, "ueps(-1).veps(-1)= 0", passed)
call expect (ueps(-m,p_0,-2)*ueps(-m,p_0,-2), 0, "ueps(-2).veps(-2)= 0", passed)
call expect (veps(-m,p_0, 2)*veps(-m,p_0, 2), 0, "veps( 2).ueps( 2)= 0", passed)
call expect (veps(-m,p_0, 1)*veps(-m,p_0, 1), 0, "veps( 1).ueps( 1)= 0", passed)
call expect (veps(-m,p_0,-1)*veps(-m,p_0,-1), 0, "veps(-1).ueps(-1)= 0", passed)
call expect (veps(-m,p_0,-2)*veps(-m,p_0,-2), 0, "veps(-2).ueps(-2)= 0", passed)
@
<<Test [[omega95_bispinors]]>>=
print *, "*** Majorana properties of gravitino vertices: ***"
call expect (abs(u (m,q,1) * f_sgr (c_one, c_one, ueps(m,p,2), t) + &
ueps(m,p,2) * gr_sf(c_one,c_one,u(m,q,1),t)), 0, "f_sgr + gr_sf = 0", passed)
!!! call expect (abs(u (m,q,-1) * f_sgr (c_one, c_one, ueps(m,p,2), t) + &
!!! ueps(m,p,2) * gr_sf(c_one,c_one,u(m,q,-1),t)), 0, "f_sgr + gr_sf = 0", passed)
!!! call expect (abs(u (m,q,1) * f_sgr (c_one, c_one, ueps(m,p,1), t) + &
!!! ueps(m,p,1) * gr_sf(c_one,c_one,u(m,q,1),t)), 0, "f_sgr + gr_sf = 0", passed)
!!! call expect (abs(u (m,q,-1) * f_sgr (c_one, c_one, ueps(m,p,1), t) + &
!!! ueps(m,p,1) * gr_sf(c_one,c_one,u(m,q,-1),t)), 0, "f_sgr + gr_sf = 0", passed)
!!! call expect (abs(u (m,q,1) * f_sgr (c_one, c_one, ueps(m,p,-1), t) + &
!!! ueps(m,p,-1) * gr_sf(c_one,c_one,u(m,q,1),t)), 0, "f_sgr + gr_sf = 0", passed)
!!! call expect (abs(u (m,q,-1) * f_sgr (c_one, c_one, ueps(m,p,-1), t) + &
!!! ueps(m,p,-1) * gr_sf(c_one,c_one,u(m,q,-1),t)), 0, "f_sgr + gr_sf = 0", passed)
!!! call expect (abs(u (m,q,1) * f_sgr (c_one, c_one, ueps(m,p,-2), t) + &
!!! ueps(m,p,-2) * gr_sf(c_one,c_one,u(m,q,1),t)), 0, "f_sgr + gr_sf = 0", passed)
!!! call expect (abs(u (m,q,-1) * f_sgr (c_one, c_one, ueps(m,p,-2), t) + &
!!! ueps(m,p,-2) * gr_sf(c_one,c_one,u(m,q,-1),t)), 0, "f_sgr + gr_sf = 0", passed)
call expect (abs(u (m,q,1) * f_slgr (c_one, c_one, ueps(m,p,2), t) + &
ueps(m,p,2) * gr_slf(c_one,c_one,u(m,q,1),t)), 0, "f_slgr + gr_slf = 0", passed, threshold = 0.5_default)
call expect (abs(u (m,q,1) * f_srgr (c_one, c_one, ueps(m,p,2), t) + &
ueps(m,p,2) * gr_srf(c_one,c_one,u(m,q,1),t)), 0, "f_srgr + gr_srf = 0", passed, threshold = 0.5_default)
call expect (abs(u (m,q,1) * f_slrgr (c_one, c_two, c_one, ueps(m,p,2), t) + &
ueps(m,p,2) * gr_slrf(c_one,c_two,c_one,u(m,q,1),t)), 0, "f_slrgr + gr_slrf = 0", passed, threshold = 0.5_default)
call expect (abs(u (m,q,1) * f_pgr (c_one, c_one, ueps(m,p,2), t) + &
ueps(m,p,2) * gr_pf(c_one,c_one,u(m,q,1),t)), 0, "f_pgr + gr_pf = 0", passed, threshold = 0.5_default)
call expect (abs(u (m,q,1) * f_vgr (c_one, vt, ueps(m,p,2), p+q) + &
ueps(m,p,2) * gr_vf(c_one,vt,u(m,q,1),p+q)), 0, "f_vgr + gr_vf = 0", passed, threshold = 0.5_default)
call expect (abs(u (m,q,1) * f_vlrgr (c_one, c_two, vt, ueps(m,p,2), p+q) + &
ueps(m,p,2) * gr_vlrf(c_one,c_two,vt,u(m,q,1),p+q)), 0, "f_vlrgr + gr_vlrf = 0", &
passed, threshold = 0.5_default)
!!! call expect (abs(u (m,q,-1) * f_vgr (c_one, vt, ueps(m,p,2), p+q) + &
!!! ueps(m,p,2) * gr_vf(c_one,vt,u(m,q,-1),p+q)), 0, "f_vgr + gr_vf = 0", passed)
!!! call expect (abs(u (m,q,1) * f_vgr (c_one, vt, ueps(m,p,1), p+q) + &
!!! ueps(m,p,1) * gr_vf(c_one,vt,u(m,q,1),p+q)), 0, "f_vgr + gr_vf = 0", passed)
!!! call expect (abs(u (m,q,-1) * f_vgr (c_one, vt, ueps(m,p,1), p+q) + &
!!! ueps(m,p,1) * gr_vf(c_one,vt,u(m,q,-1),p+q)), 0, "f_vgr + gr_vf = 0", passed)
!!! call expect (abs(u (m,q,1) * f_vgr (c_one, vt, ueps(m,p,-1), p+q) + &
!!! ueps(m,p,-1) * gr_vf(c_one,vt,u(m,q,1),p+q)), 0, "f_vgr + gr_vf = 0", passed)
!!! call expect (abs(u (m,q,-1) * f_vgr (c_one, vt, veps(m,p,-1), p+q) + &
!!! veps(m,p,-1) * gr_vf(c_one,vt,u(m,q,-1),p+q)), 0, "f_vgr + gr_vf = 0", passed)
!!! call expect (abs(v (m,q,1) * f_vgr (c_one, vt, ueps(m,p,-2), p+q) + &
!!! ueps(m,p,-2) * gr_vf(c_one,vt,v(m,q,1),p+q)), 0, "f_vgr + gr_vf = 0", passed)
!!! call expect (abs(u (m,q,-1) * f_vgr (c_one, vt, ueps(m,p,-2), p+q) + &
!!! ueps(m,p,-2) * gr_vf(c_one,vt,u(m,q,-1),p+q)), 0, "f_vgr + gr_vf = 0", passed)
call expect (abs(s_grf (c_one, ueps(m,p,2), u(m,q,1),t) + &
s_fgr(c_one,u(m,q,1),ueps(m,p,2),t)), 0, "s_grf + s_fgr = 0", passed)
call expect (abs(sl_grf (c_one, ueps(m,p,2), u(m,q,1),t) + &
sl_fgr(c_one,u(m,q,1),ueps(m,p,2),t)), 0, "sl_grf + sl_fgr = 0", passed)
call expect (abs(sr_grf (c_one, ueps(m,p,2), u(m,q,1),t) + &
sr_fgr(c_one,u(m,q,1),ueps(m,p,2),t)), 0, "sr_grf + sr_fgr = 0", passed)
call expect (abs(slr_grf (c_one, c_two, ueps(m,p,2), u(m,q,1),t) + &
slr_fgr(c_one,c_two,u(m,q,1),ueps(m,p,2),t)), 0, "slr_grf + slr_fgr = 0", passed)
call expect (abs(p_grf (c_one, ueps(m,p,2), u(m,q,1),t) + &
p_fgr(c_one,u(m,q,1),ueps(m,p,2),t)), 0, "p_grf + p_fgr = 0", passed)
call expect (abs(v_grf (c_one, ueps(m,p,2), u(m,q,1),t) + &
v_fgr(c_one,u(m,q,1),ueps(m,p,2),t)), 0, "v_grf + v_fgr = 0", passed)
call expect (abs(vlr_grf (c_one, c_two, ueps(m,p,2), u(m,q,1),t) + &
vlr_fgr(c_one,c_two,u(m,q,1),ueps(m,p,2),t)), 0, "vlr_grf + vlr_fgr = 0", passed)
call expect (abs(u(m,p,1) * f_potgr (c_one,c_one,testv) - testv * gr_potf &
(c_one,c_one,u (m,p,1))), 0, "f_potgr - gr_potf = 0", passed)
call expect (abs (pot_fgr (c_one,u(m,p,1),testv) - pot_grf(c_one, &
testv,u(m,p,1))), 0, "pot_fgr - pot_grf = 0", passed)
call expect (abs(u(m,p,1) * f_s2gr (c_one,c_one,c_one,testv) - testv * gr_s2f &
(c_one,c_one,c_one,u (m,p,1))), 0, "f_s2gr - gr_s2f = 0", passed)
call expect (abs (s2_fgr (c_one,u(m,p,1),c_one,testv) - s2_grf(c_one, &
testv,c_one,u(m,p,1))), 0, "s2_fgr - s2_grf = 0", passed)
call expect (abs(u (m,q,1) * f_svgr (c_one, c_one, vt, ueps(m,p,2)) + &
ueps(m,p,2) * gr_svf(c_one,c_one,vt,u(m,q,1))), 0, "f_svgr + gr_svf = 0", passed)
call expect (abs(u (m,q,1) * f_slvgr (c_one, c_one, vt, ueps(m,p,2)) + &
ueps(m,p,2) * gr_slvf(c_one,c_one,vt,u(m,q,1))), 0, "f_slvgr + gr_slvf = 0", passed)
call expect (abs(u (m,q,1) * f_srvgr (c_one, c_one, vt, ueps(m,p,2)) + &
ueps(m,p,2) * gr_srvf(c_one,c_one,vt,u(m,q,1))), 0, "f_srvgr + gr_srvf = 0", passed)
call expect (abs(u (m,q,1) * f_slrvgr (c_one, c_two, c_one, vt, ueps(m,p,2)) + &
ueps(m,p,2) * gr_slrvf(c_one,c_two,c_one,vt,u(m,q,1))), 0, "f_slrvgr + gr_slrvf = 0", passed)
call expect (abs (sv1_fgr (c_one,u(m,p,1),vt,ueps(m,q,2)) + sv1_grf(c_one, &
ueps(m,q,2),vt,u(m,p,1))), 0, "sv1_fgr + sv1_grf = 0", passed)
call expect (abs (sv2_fgr (c_one,u(m,p,1),c_one,ueps(m,q,2)) + sv2_grf(c_one, &
ueps(m,q,2),c_one,u(m,p,1))), 0, "sv2_fgr + sv2_grf = 0", passed)
call expect (abs (slv1_fgr (c_one,u(m,p,1),vt,ueps(m,q,2)) + slv1_grf(c_one, &
ueps(m,q,2),vt,u(m,p,1))), 0, "slv1_fgr + slv1_grf = 0", passed)
call expect (abs (srv2_fgr (c_one,u(m,p,1),c_one,ueps(m,q,2)) + srv2_grf(c_one, &
ueps(m,q,2),c_one,u(m,p,1))), 0, "srv2_fgr + srv2_grf = 0", passed)
call expect (abs (slrv1_fgr (c_one,c_two,u(m,p,1),vt,ueps(m,q,2)) + slrv1_grf(c_one,c_two, &
ueps(m,q,2),vt,u(m,p,1))), 0, "slrv1_fgr + slrv1_grf = 0", passed)
call expect (abs (slrv2_fgr (c_one,c_two,u(m,p,1),c_one,ueps(m,q,2)) + slrv2_grf(c_one, &
c_two,ueps(m,q,2),c_one,u(m,p,1))), 0, "slrv2_fgr + slrv2_grf = 0", passed)
call expect (abs(u (m,q,1) * f_pvgr (c_one, c_one, vt, ueps(m,p,2)) + &
ueps(m,p,2) * gr_pvf(c_one,c_one,vt,u(m,q,1))), 0, "f_pvgr + gr_pvf = 0", passed)
call expect (abs (pv1_fgr (c_one,u(m,p,1),vt,ueps(m,q,2)) + pv1_grf(c_one, &
ueps(m,q,2),vt,u(m,p,1))), 0, "pv1_fgr + pv1_grf = 0", passed)
call expect (abs (pv2_fgr (c_one,u(m,p,1),c_one,ueps(m,q,2)) + pv2_grf(c_one, &
ueps(m,q,2),c_one,u(m,p,1))), 0, "pv2_fgr + pv2_grf = 0", passed)
call expect (abs(u (m,q,1) * f_v2gr (c_one, vt, vz, ueps(m,p,2)) + &
ueps(m,p,2) * gr_v2f(c_one,vt,vz,u(m,q,1))), 0, "f_v2gr + gr_v2f = 0", passed)
call expect (abs(u (m,q,1) * f_v2lrgr (c_one, c_two, vt, vz, ueps(m,p,2)) + &
ueps(m,p,2) * gr_v2lrf(c_one,c_two,vt,vz,u(m,q,1))), 0, "f_v2lrgr + gr_v2lrf = 0", passed)
call expect (abs (v2_fgr (c_one,u(m,p,1),vt,ueps(m,q,2)) + v2_grf(c_one, &
ueps(m,q,2),vt,u(m,p,1))), 0, "v2_fgr + v2_grf = 0", passed)
call expect (abs (v2lr_fgr (c_one,c_two,u(m,p,1),vt,ueps(m,q,2)) + v2lr_grf(c_one, c_two, &
ueps(m,q,2),vt,u(m,p,1))), 0, "v2lr_fgr + v2lr_grf = 0", passed)
@
<<Test [[omega95_bispinors]]>>=
print *, "*** Testing the gravitino propagator: ***"
print *, "Transversality:"
call expect (abs(p * (cmplx (p*p - m**2, m*w, kind=default) * &
pr_grav(p,m,w,testv))), 0, "p.pr.test", passed)
call expect (abs(p * (cmplx (p*p - m**2, m*w, kind=default) * &
pr_grav(p,m,w,ueps(m,p,2)))), 0, "p.pr.ueps ( 2)", passed)
call expect (abs(p * (cmplx (p*p - m**2, m*w, kind=default) * &
pr_grav(p,m,w,ueps(m,p,1)))), 0, "p.pr.ueps ( 1)", passed)
call expect (abs(p * (cmplx (p*p - m**2, m*w, kind=default) * &
pr_grav(p,m,w,ueps(m,p,-1)))), 0, "p.pr.ueps (-1)", passed)
call expect (abs(p * (cmplx (p*p - m**2, m*w, kind=default) * &
pr_grav(p,m,w,ueps(m,p,-2)))), 0, "p.pr.ueps (-2)", passed)
call expect (abs(p * (cmplx (p*p - m**2, m*w, kind=default) * &
pr_grav(p,m,w,veps(m,p,2)))), 0, "p.pr.veps ( 2)", passed)
call expect (abs(p * (cmplx (p*p - m**2, m*w, kind=default) * &
pr_grav(p,m,w,veps(m,p,1)))), 0, "p.pr.veps ( 1)", passed)
call expect (abs(p * (cmplx (p*p - m**2, m*w, kind=default) * &
pr_grav(p,m,w,veps(m,p,-1)))), 0, "p.pr.veps (-1)", passed)
call expect (abs(p * (cmplx (p*p - m**2, m*w, kind=default) * &
pr_grav(p,m,w,veps(m,p,-2)))), 0, "p.pr.veps (-2)", passed)
print *, "Irreducibility:"
call expect (abs(f_potgr (c_one, c_one, (cmplx (p*p - m**2, m*w, &
kind=default) * pr_grav(p,m,w,testv)))), 0, "g.pr.test", passed)
call expect (abs(f_potgr (c_one, c_one, (cmplx (p*p - m**2, m*w, &
kind=default) * pr_grav(p,m,w,ueps(m,p,2))))), 0, &
"g.pr.ueps ( 2)", passed)
call expect (abs(f_potgr (c_one, c_one, (cmplx (p*p - m**2, m*w, &
kind=default) * pr_grav(p,m,w,ueps(m,p,1))))), 0, &
"g.pr.ueps ( 1)", passed)
call expect (abs(f_potgr (c_one, c_one, (cmplx (p*p - m**2, m*w, &
kind=default) * pr_grav(p,m,w,ueps(m,p,-1))))), 0, &
"g.pr.ueps (-1)", passed)
call expect (abs(f_potgr (c_one, c_one, (cmplx (p*p - m**2, m*w, &
kind=default) * pr_grav(p,m,w,ueps(m,p,-2))))), 0, &
"g.pr.ueps (-2)", passed)
call expect (abs(f_potgr (c_one, c_one, (cmplx (p*p - m**2, m*w, &
kind=default) * pr_grav(p,m,w,veps(m,p,2))))), 0, &
"g.pr.veps ( 2)", passed)
call expect (abs(f_potgr (c_one, c_one, (cmplx (p*p - m**2, m*w, &
kind=default) * pr_grav(p,m,w,veps(m,p,1))))), 0, &
"g.pr.veps ( 1)", passed)
call expect (abs(f_potgr (c_one, c_one, (cmplx (p*p - m**2, m*w, &
kind=default) * pr_grav(p,m,w,veps(m,p,-1))))), 0, &
"g.pr.veps (-1)", passed)
call expect (abs(f_potgr (c_one, c_one, (cmplx (p*p - m**2, m*w, &
kind=default) * pr_grav(p,m,w,veps(m,p,-2))))), 0, &
"g.pr.veps (-2)", passed)
@
<<[[omega_bundle.f90]]>>=
<<[[omega_vectors.f90]]>>
<<[[omega_spinors.f90]]>>
<<[[omega_bispinors.f90]]>>
<<[[omega_vectorspinors.f90]]>>
<<[[omega_polarizations.f90]]>>
<<[[omega_tensors.f90]]>>
<<[[omega_tensor_polarizations.f90]]>>
<<[[omega_couplings.f90]]>>
<<[[omega_spinor_couplings.f90]]>>
<<[[omega_bispinor_couplings.f90]]>>
<<[[omega_vspinor_polarizations.f90]]>>
<<[[omega_utils.f90]]>>
<<[[omega95.f90]]>>
<<[[omega95_bispinors.f90]]>>
<<[[omega_parameters.f90]]>>
<<[[omega_parameters_madgraph.f90]]>>
@
<<[[omega_bundle_whizard.f90]]>>=
<<[[omega_bundle.f90]]>>
<<[[omega_parameters_whizard.f90]]>>
@ %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\section{O'Mega Virtual Machine}
This module defines the O'Mega Virtual Machine (OVM) completely, whereby
all environmental dependencies like masses, widths and couplings have to
be given to the constructor [[vm%init]] at runtime.
Support for Majorana particles and vectorspinors is only partially,
especially all fusions are missing. Maybe it would be easier to make an
additional [[omegavm95_bispinors]] to avoid namespace issues. Non-type
specific chunks could be reused
<<[[omegavm95.f90]]>>=
<<Copyleft>>
module omegavm95
use kinds, only: default
use constants
use iso_varying_string, string_t => varying_string
use, intrinsic :: iso_fortran_env, only : input_unit, output_unit, error_unit
use omega95
use omega95_bispinors, only: bispinor, vectorspinor, veps, pr_grav
use omega95_bispinors, only: bi_u => u
use omega95_bispinors, only: bi_v => v
use omega95_bispinors, only: bi_pr_psi => pr_psi
use omega_bispinors, only: operator (*), operator (+)
use omega_color, only: ovm_color_sum, OCF => omega_color_factor
implicit none
private
<<Utilities Declarations>>
<<OVM Data Declarations>>
<<OVM Instructions>>
contains
<<OVM Procedure Implementations>>
<<Utilities Procedure Implementations>>
end module omegavm95
@ This might not be the proper place but I don't know where to put it
<<Utilities Declarations>>=
integer, parameter, public :: stdin = input_unit
integer, parameter, public :: stdout = output_unit
integer, parameter, public :: stderr = error_unit
integer, parameter :: MIN_UNIT = 11, MAX_UNIT = 99
@
<<OVM Procedure Implementations>>=
subroutine find_free_unit (u, iostat)
integer, intent(out) :: u
integer, intent(out), optional :: iostat
logical :: exists, is_open
integer :: i, status
do i = MIN_UNIT, MAX_UNIT
inquire (unit = i, exist = exists, opened = is_open, &
iostat = status)
if (status == 0) then
if (exists .and. .not. is_open) then
u = i
if (present (iostat)) then
iostat = 0
end if
return
end if
end if
end do
if (present (iostat)) then
iostat = -1
end if
u = -1
end subroutine find_free_unit
@ These abstract data types would ideally be the interface to
communicate quantum numbers between O'Mega and Whizard. This gives full
flexibility to change the representation at any time
<<Utilities Declarations>>=
public :: color_t
type color_t
contains
procedure :: write => color_write
end type color_t
public :: col_discrete
type, extends(color_t) :: col_discrete
integer :: i
end type col_discrete
public :: flavor_t
type flavor_t
contains
procedure :: write => flavor_write
end type flavor_t
public :: flv_discrete
type, extends(flavor_t) :: flv_discrete
integer :: i
end type flv_discrete
public :: helicity_t
type :: helicity_t
contains
procedure :: write => helicity_write
end type helicity_t
public :: hel_discrete
type, extends(helicity_t) :: hel_discrete
integer :: i
end type hel_discrete
public :: hel_trigonometric
type, extends(helicity_t) :: hel_trigonometric
real :: theta
end type hel_trigonometric
public :: hel_exponential
type, extends(helicity_t) :: hel_exponential
real :: phi
end type hel_exponential
public :: hel_spherical
type, extends(helicity_t) :: hel_spherical
real :: theta, phi
end type hel_spherical
<<Utilities Procedure Implementations>>=
subroutine color_write (color, fh)
class(color_t), intent(in) :: color
integer, intent(in) :: fh
select type(color)
type is (col_discrete)
write(fh, *) 'color_discrete%i = ', color%i
end select
end subroutine color_write
subroutine helicity_write (helicity, fh)
class(helicity_t), intent(in) :: helicity
integer, intent(in) :: fh
select type(helicity)
type is (hel_discrete)
write(fh, *) 'helicity_discrete%i = ', helicity%i
type is (hel_trigonometric)
write(fh, *) 'helicity_trigonometric%theta = ', helicity%theta
type is (hel_exponential)
write(fh, *) 'helicity_exponential%phi = ', helicity%phi
type is (hel_spherical)
write(fh, *) 'helicity_spherical%phi = ', helicity%phi
write(fh, *) 'helicity_spherical%theta = ', helicity%theta
end select
end subroutine helicity_write
subroutine flavor_write (flavor, fh)
class(flavor_t), intent(in) :: flavor
integer, intent(in) :: fh
select type(flavor)
type is (flv_discrete)
write(fh, *) 'flavor_discrete%i = ', flavor%i
end select
end subroutine flavor_write
@
\subsection{Memory Layout}
Some internal parameters
<<OVM Data Declarations>>=
integer, parameter :: len_instructions = 8
integer, parameter :: N_version_lines = 2
! Comment lines including the first header description line
integer, parameter :: N_comments = 6
! Actual data lines plus intermediate description lines
! 'description \n 1 2 3 \n description \n 3 2 1' would count as 3
integer, parameter :: N_header_lines = 5
real(default), parameter, public :: N_ = three
@ This is the basic type of a VM
<<OVM Data Declarations>>=
type :: basic_vm_t
private
logical :: verbose
type(string_t) :: bytecode_file
integer :: bytecode_fh, out_fh
integer :: N_instructions, N_levels
integer :: N_table_lines
integer, dimension(:, :), allocatable :: instructions
integer, dimension(:), allocatable :: levels
end type
@ To allow for a lazy evaluation of amplitudes, we have to keep track
whether a wave function has already been computed, to avoid
multiple-computing that would arise when the bytecode has redundant
fusions, which is necessary for flavor and color MC (and helicity MC
when we use Weyl-van-der-Waerden-spinors)
<<OVM Data Declarations>>=
type :: vm_scalar
logical :: c
complex(kind=default) :: v
end type
type :: vm_spinor
logical :: c
type(spinor) :: v
end type
type :: vm_conjspinor
logical :: c
type(conjspinor) :: v
end type
type :: vm_bispinor
logical :: c
type(bispinor) :: v
end type
type :: vm_vector
logical :: c
type(vector) :: v
end type
type :: vm_tensor_2
logical :: c
type(tensor) :: v
end type
type :: vm_tensor_1
logical :: c
type(tensor2odd) :: v
end type
type :: vm_vectorspinor
logical :: c
type(vectorspinor) :: v
end type
@ We need a memory pool for all the intermediate results
<<OVM Data Declarations>>=
type, public, extends (basic_vm_t) :: vm_t
private
type(string_t) :: version
type(string_t) :: model
integer :: N_momenta, N_particles, N_prt_in, N_prt_out, N_amplitudes
! helicities = helicity combinations
integer :: N_helicities, N_col_flows, N_col_indices, N_flavors, N_col_factors
integer :: N_scalars, N_spinors, N_conjspinors, N_bispinors
integer :: N_vectors, N_tensors_2, N_tensors_1, N_vectorspinors
integer :: N_coupl_real, N_coupl_real2, N_coupl_cmplx, N_coupl_cmplx2
integer, dimension(:, :), allocatable :: table_flavor
integer, dimension(:, :, :), allocatable :: table_color_flows
integer, dimension(:, :), allocatable :: table_spin
logical, dimension(:, :), allocatable :: table_ghost_flags
type(OCF), dimension(:), allocatable :: table_color_factors
logical, dimension(:, :), allocatable :: table_flv_col_is_allowed
real(default), dimension(:), allocatable :: coupl_real
real(default), dimension(:, :), allocatable :: coupl_real2
complex(default), dimension(:), allocatable :: coupl_cmplx
complex(default), dimension(:, :), allocatable :: coupl_cmplx2
real(default), dimension(:), allocatable :: mass
real(default), dimension(:), allocatable :: width
type(momentum), dimension(:), allocatable :: momenta
complex(default), dimension(:), allocatable :: amplitudes
complex(default), dimension(:, :, :), allocatable :: table_amplitudes
class(flavor_t), dimension(:), allocatable :: flavor
class(color_t), dimension(:), allocatable :: color
! gfortran 4.7
!class(helicity_t), dimension(:), pointer :: helicity => null()
integer, dimension(:), allocatable :: helicity
type(vm_scalar), dimension(:), allocatable :: scalars
type(vm_spinor), dimension(:), allocatable :: spinors
type(vm_conjspinor), dimension(:), allocatable :: conjspinors
type(vm_bispinor), dimension(:), allocatable :: bispinors
type(vm_vector), dimension(:), allocatable :: vectors
type(vm_tensor_2), dimension(:), allocatable :: tensors_2
type(vm_tensor_1), dimension(:), allocatable :: tensors_1
type(vm_vectorspinor), dimension(:), allocatable :: vectorspinors
logical, dimension(:), allocatable :: hel_is_allowed
real(default), dimension(:), allocatable :: hel_max_abs
real(default) :: hel_sum_abs = 0, hel_threshold = 1E10
integer :: hel_count = 0, hel_cutoff = 100
integer, dimension(:), allocatable :: hel_map
integer :: hel_finite
logical :: cms
logical :: openmp
contains
<<VM: TBP>>
end type
@
<<OVM Procedure Implementations>>=
subroutine alloc_arrays (vm)
type(vm_t), intent(inout) :: vm
integer :: i
allocate (vm%table_flavor(vm%N_particles, vm%N_flavors))
allocate (vm%table_color_flows(vm%N_col_indices, vm%N_particles, &
vm%N_col_flows))
allocate (vm%table_spin(vm%N_particles, vm%N_helicities))
allocate (vm%table_ghost_flags(vm%N_particles, vm%N_col_flows))
allocate (vm%table_color_factors(vm%N_col_factors))
allocate (vm%table_flv_col_is_allowed(vm%N_flavors, vm%N_col_flows))
allocate (vm%momenta(vm%N_momenta))
allocate (vm%amplitudes(vm%N_amplitudes))
allocate (vm%table_amplitudes(vm%N_flavors, vm%N_col_flows, &
vm%N_helicities))
vm%table_amplitudes = zero
allocate (vm%scalars(vm%N_scalars))
allocate (vm%spinors(vm%N_spinors))
allocate (vm%conjspinors(vm%N_conjspinors))
allocate (vm%bispinors(vm%N_bispinors))
allocate (vm%vectors(vm%N_vectors))
allocate (vm%tensors_2(vm%N_tensors_2))
allocate (vm%tensors_1(vm%N_tensors_1))
allocate (vm%vectorspinors(vm%N_vectorspinors))
allocate (vm%hel_is_allowed(vm%N_helicities))
vm%hel_is_allowed = .True.
allocate (vm%hel_max_abs(vm%N_helicities))
vm%hel_max_abs = 0
allocate (vm%hel_map(vm%N_helicities))
vm%hel_map = (/(i, i = 1, vm%N_helicities)/)
vm%hel_finite = vm%N_helicities
end subroutine alloc_arrays
@
\subsection{Controlling the VM}
These type-bound procedures steer the VM
<<VM: TBP>>=
procedure :: init => vm_init
procedure :: write => vm_write
procedure :: reset => vm_reset
procedure :: run => vm_run
procedure :: final => vm_final
@ The [[init]] completely sets the environment for the OVM. Parameters
can be changed with [[reset]] without reloading the bytecode.
<<OVM Procedure Implementations>>=
subroutine vm_init (vm, bytecode_file, version, model, &
coupl_real, coupl_real2, coupl_cmplx, coupl_cmplx2, &
mass, width, verbose, out_fh, openmp)
class(vm_t), intent(out) :: vm
type(string_t), intent(in) :: bytecode_file
type(string_t), intent(in) :: version
type(string_t), intent(in) :: model
real(default), dimension(:), optional, intent(in) :: coupl_real
real(default), dimension(:, :), optional, intent(in) :: coupl_real2
complex(default), dimension(:), optional, intent(in) :: coupl_cmplx
complex(default), dimension(:, :), optional, intent(in) :: coupl_cmplx2
real(default), dimension(:), optional, intent(in) :: mass
real(default), dimension(:), optional, intent(in) :: width
logical, optional, intent(in) :: verbose
integer, optional, intent(in) :: out_fh
logical, optional, intent(in) :: openmp
vm%bytecode_file = bytecode_file
vm%version = version
vm%model = model
if (present (coupl_real)) then
allocate (vm%coupl_real (size (coupl_real)), source=coupl_real)
end if
if (present (coupl_real2)) then
allocate (vm%coupl_real2 (2, size (coupl_real2, 2)), source=coupl_real2)
end if
if (present (coupl_cmplx)) then
allocate (vm%coupl_cmplx (size (coupl_cmplx)), source=coupl_cmplx)
end if
if (present (coupl_cmplx2)) then
allocate (vm%coupl_cmplx2 (2, size (coupl_cmplx2, 2)), &
source=coupl_cmplx2)
end if
if (present (mass)) then
allocate (vm%mass(size(mass)), source=mass)
end if
if (present (width)) then
allocate (vm%width(size (width)), source=width)
end if
if (present (openmp)) then
vm%openmp = openmp
else
vm%openmp = .false.
end if
vm%cms = .false.
call basic_init (vm, verbose, out_fh)
end subroutine vm_init
@
<<OVM Procedure Implementations>>=
subroutine vm_reset (vm, &
coupl_real, coupl_real2, coupl_cmplx, coupl_cmplx2, &
mass, width, verbose, out_fh)
class(vm_t), intent(inout) :: vm
real(default), dimension(:), optional, intent(in) :: coupl_real
real(default), dimension(:, :), optional, intent(in) :: coupl_real2
complex(default), dimension(:), optional, intent(in) :: coupl_cmplx
complex(default), dimension(:, :), optional, intent(in) :: coupl_cmplx2
real(default), dimension(:), optional, intent(in) :: mass
real(default), dimension(:), optional, intent(in) :: width
logical, optional, intent(in) :: verbose
integer, optional, intent(in) :: out_fh
if (present (coupl_real)) then
vm%coupl_real = coupl_real
end if
if (present (coupl_real2)) then
vm%coupl_real2 = coupl_real2
end if
if (present (coupl_cmplx)) then
vm%coupl_cmplx = coupl_cmplx
end if
if (present (coupl_cmplx2)) then
vm%coupl_cmplx2 = coupl_cmplx2
end if
if (present (mass)) then
vm%mass = mass
end if
if (present (width)) then
vm%width = width
end if
if (present (verbose)) then
vm%verbose = verbose
end if
if (present (out_fh)) then
vm%out_fh = out_fh
end if
end subroutine vm_reset
@ Mainly for debugging
<<OVM Procedure Implementations>>=
subroutine vm_write (vm)
class(vm_t), intent(in) :: vm
integer :: i, j, k
call basic_write (vm)
write(vm%out_fh, *) 'table_flavor = ', vm%table_flavor
write(vm%out_fh, *) 'table_color_flows = ', vm%table_color_flows
write(vm%out_fh, *) 'table_spin = ', vm%table_spin
write(vm%out_fh, *) 'table_ghost_flags = ', vm%table_ghost_flags
write(vm%out_fh, *) 'table_color_factors = '
do i = 1, size(vm%table_color_factors)
write(vm%out_fh, *) vm%table_color_factors(i)%i1, &
vm%table_color_factors(i)%i2, &
vm%table_color_factors(i)%factor
end do
write(vm%out_fh, *) 'table_flv_col_is_allowed = ', &
vm%table_flv_col_is_allowed
do i = 1, vm%N_flavors
do j = 1, vm%N_col_flows
do k = 1, vm%N_helicities
write(vm%out_fh, *) 'table_amplitudes(f,c,h), f, c, h = ', vm%table_amplitudes(i,j,k), i, j, k
end do
end do
end do
if (allocated(vm%coupl_real)) then
write(vm%out_fh, *) 'coupl_real = ', vm%coupl_real
end if
if (allocated(vm%coupl_real2)) then
write(vm%out_fh, *) 'coupl_real2 = ', vm%coupl_real2
end if
if (allocated(vm%coupl_cmplx)) then
write(vm%out_fh, *) 'coupl_cmplx = ', vm%coupl_cmplx
end if
if (allocated(vm%coupl_cmplx2)) then
write(vm%out_fh, *) 'coupl_cmplx2 = ', vm%coupl_cmplx2
end if
write(vm%out_fh, *) 'mass = ', vm%mass
write(vm%out_fh, *) 'width = ', vm%width
write(vm%out_fh, *) 'momenta = ', vm%momenta
! gfortran 4.7
!do i = 1, size(vm%flavor)
!call vm%flavor(i)%write (vm%out_fh)
!end do
!do i = 1, size(vm%color)
!call vm%color(i)%write (vm%out_fh)
!end do
!do i = 1, size(vm%helicity)
!call vm%helicity(i)%write (vm%out_fh)
!end do
write(vm%out_fh, *) 'helicity = ', vm%helicity
write(vm%out_fh, *) 'amplitudes = ', vm%amplitudes
write(vm%out_fh, *) 'scalars = ', vm%scalars
write(vm%out_fh, *) 'spinors = ', vm%spinors
write(vm%out_fh, *) 'conjspinors = ', vm%conjspinors
write(vm%out_fh, *) 'bispinors = ', vm%bispinors
write(vm%out_fh, *) 'vectors = ', vm%vectors
write(vm%out_fh, *) 'tensors_2 = ', vm%tensors_2
write(vm%out_fh, *) 'tensors_1 = ', vm%tensors_1
!!! !!! !!! Regression with ifort 16.0.0
!!! write(vm%out_fh, *) 'vectorspinors = ', vm%vectorspinors
write(vm%out_fh, *) 'N_momenta = ', vm%N_momenta
write(vm%out_fh, *) 'N_particles = ', vm%N_particles
write(vm%out_fh, *) 'N_prt_in = ', vm%N_prt_in
write(vm%out_fh, *) 'N_prt_out = ', vm%N_prt_out
write(vm%out_fh, *) 'N_amplitudes = ', vm%N_amplitudes
write(vm%out_fh, *) 'N_helicities = ', vm%N_helicities
write(vm%out_fh, *) 'N_col_flows = ', vm%N_col_flows
write(vm%out_fh, *) 'N_col_indices = ', vm%N_col_indices
write(vm%out_fh, *) 'N_flavors = ', vm%N_flavors
write(vm%out_fh, *) 'N_col_factors = ', vm%N_col_factors
write(vm%out_fh, *) 'N_scalars = ', vm%N_scalars
write(vm%out_fh, *) 'N_spinors = ', vm%N_spinors
write(vm%out_fh, *) 'N_conjspinors = ', vm%N_conjspinors
write(vm%out_fh, *) 'N_bispinors = ', vm%N_bispinors
write(vm%out_fh, *) 'N_vectors = ', vm%N_vectors
write(vm%out_fh, *) 'N_tensors_2 = ', vm%N_tensors_2
write(vm%out_fh, *) 'N_tensors_1 = ', vm%N_tensors_1
write(vm%out_fh, *) 'N_vectorspinors = ', vm%N_vectorspinors
write(vm%out_fh, *) 'Overall size of VM: '
! GNU extension
! write(vm%out_fh, *) 'sizeof(wavefunctions) = ', &
! sizeof(vm%scalars) + sizeof(vm%spinors) + sizeof(vm%conjspinors) + &
! sizeof(vm%bispinors) + sizeof(vm%vectors) + sizeof(vm%tensors_2) + &
! sizeof(vm%tensors_1) + sizeof(vm%vectorspinors)
! write(vm%out_fh, *) 'sizeof(mometa) = ', sizeof(vm%momenta)
! write(vm%out_fh, *) 'sizeof(amplitudes) = ', sizeof(vm%amplitudes)
! write(vm%out_fh, *) 'sizeof(tables) = ', &
! sizeof(vm%table_amplitudes) + sizeof(vm%table_spin) + &
! sizeof(vm%table_flavor) + sizeof(vm%table_flv_col_is_allowed) + &
! sizeof(vm%table_color_flows) + sizeof(vm%table_color_factors) + &
! sizeof(vm%table_ghost_flags)
end subroutine vm_write
@ Most of this is redundant (Fortran will deallocate when we leave the
scope) but when we change from [[allocatable]]s to [[pointer]]s, it is
necessary to avoid leaks
<<OVM Procedure Implementations>>=
subroutine vm_final (vm)
class(vm_t), intent(inout) :: vm
deallocate (vm%table_flavor)
deallocate (vm%table_color_flows)
deallocate (vm%table_spin)
deallocate (vm%table_ghost_flags)
deallocate (vm%table_color_factors)
deallocate (vm%table_flv_col_is_allowed)
if (allocated (vm%coupl_real)) then
deallocate (vm%coupl_real)
end if
if (allocated (vm%coupl_real2)) then
deallocate (vm%coupl_real2)
end if
if (allocated (vm%coupl_cmplx)) then
deallocate (vm%coupl_cmplx)
end if
if (allocated (vm%coupl_cmplx2)) then
deallocate (vm%coupl_cmplx2)
end if
if (allocated (vm%mass)) then
deallocate (vm%mass)
end if
if (allocated (vm%width)) then
deallocate (vm%width)
end if
deallocate (vm%momenta)
deallocate (vm%flavor)
deallocate (vm%color)
deallocate (vm%helicity)
deallocate (vm%amplitudes)
deallocate (vm%table_amplitudes)
deallocate (vm%scalars)
deallocate (vm%spinors)
deallocate (vm%conjspinors)
deallocate (vm%bispinors)
deallocate (vm%vectors)
deallocate (vm%tensors_2)
deallocate (vm%tensors_1)
deallocate (vm%vectorspinors)
end subroutine vm_final
@ Handing over the polymorph object helicity didn't work out as planned.
A work-around is the use of [[pointer]]s. [[flavor]] and [[color]] are
not yet used but would have to be changed to [[pointer]]s as well. At
least this potentially avoids copying. Actually, neither the allocatable
nor the pointer version works in [[gfortran 4.7]] due to the broken
[[select type]]. Back to Stone Age, i.e. integers.
<<OVM Procedure Implementations>>=
subroutine vm_run (vm, mom, flavor, color, helicity)
class(vm_t), intent(inout) :: vm
real(default), dimension(0:3, *), intent(in) :: mom
class(flavor_t), dimension(:), optional, intent(in) :: flavor
class(color_t), dimension(:), optional, intent(in) :: color
! gfortran 4.7
!class(helicity_t), dimension(:), optional, target, intent(in) :: helicity
integer, dimension(:), optional, intent(in) :: helicity
integer :: i, h, hi
do i = 1, vm%N_particles
if (i <= vm%N_prt_in) then
vm%momenta(i) = - mom(:, i) ! incoming, crossing symmetry
else
vm%momenta(i) = mom(:, i) ! outgoing
end if
end do
if (present (flavor)) then
allocate(vm%flavor(size(flavor)), source=flavor)
else
if (.not. (allocated (vm%flavor))) then
allocate(flv_discrete::vm%flavor(vm%N_particles))
end if
end if
if (present (color)) then
allocate(vm%color(size(color)), source=color)
else
if (.not. (allocated (vm%color))) then
allocate(col_discrete::vm%color(vm%N_col_flows))
end if
end if
! gfortran 4.7
if (present (helicity)) then
!vm%helicity => helicity
vm%helicity = helicity
call vm_run_one_helicity (vm, 1)
else
!if (.not. (associated (vm%helicity))) then
!allocate(hel_discrete::vm%helicity(vm%N_particles))
!end if
if (.not. (allocated (vm%helicity))) then
allocate(vm%helicity(vm%N_particles))
end if
if (vm%hel_finite == 0) return
do hi = 1, vm%hel_finite
h = vm%hel_map(hi)
!<Work around [[gfortran 4.7 Bug 56731]] Implementation>>
vm%helicity = vm%table_spin(:,h)
call vm_run_one_helicity (vm, h)
end do
end if
end subroutine vm_run
@
This only removes the [[ICE]] but still leads to a segmentation fault in
[[gfortran 4.7]]. I am running out of ideas how to make this compiler
work with arrays of polymorph datatypes.
<<Work around [[gfortran 4.7 Bug 56731]] Declarations>>=
integer :: hj
<<Work around [[gfortran 4.7 Bug 56731]] Implementation>>=
do hj = 1, size(vm%helicity)
select type (hel => vm%helicity(hj))
type is (hel_discrete)
hel%i = vm%table_spin(hj,h)
end select
end do
@
<<Original version>>=
select type (hel => vm%helicity)
type is (hel_discrete)
hel(:)%i = vm%table_spin(:,h)
end select
@
<<OVM Procedure Implementations>>=
subroutine vm_run_one_helicity (vm, h)
class(vm_t), intent(inout) :: vm
integer, intent(in) :: h
integer :: f, c, i
vm%amplitudes = zero
if (vm%N_levels > 0) then
call null_all_wfs (vm)
call iterate_instructions (vm)
end if
i = 1
do c = 1, vm%N_col_flows
do f = 1, vm%N_flavors
if (vm%table_flv_col_is_allowed(f,c)) then
vm%table_amplitudes(f,c,h) = vm%amplitudes(i)
i = i + 1
end if
end do
end do
end subroutine
@
<<OVM Procedure Implementations>>=
subroutine null_all_wfs (vm)
type(vm_t), intent(inout) :: vm
integer :: i, j
vm%scalars%c = .False.
vm%scalars%v = zero
vm%spinors%c = .False.
vm%conjspinors%c = .False.
vm%bispinors%c = .False.
vm%vectorspinors%c = .False.
do i = 1, 4
vm%spinors%v%a(i) = zero
vm%conjspinors%v%a(i) = zero
vm%bispinors%v%a(i) = zero
do j = 1, 4
vm%vectorspinors%v%psi(i)%a(j) = zero
end do
end do
vm%vectors%c = .False.
vm%vectors%v%t = zero
vm%tensors_1%c = .False.
vm%tensors_2%c = .False.
do i = 1, 3
vm%vectors%v%x(i) = zero
vm%tensors_1%v%e(i) = zero
vm%tensors_1%v%b(i) = zero
do j = 1, 3
vm%tensors_2%v%t(i,j) = zero
end do
end do
end subroutine
@
\subsection{Reading the bytecode}
<<OVM Procedure Implementations>>=
subroutine load_header (vm, IO)
type(vm_t), intent(inout) :: vm
integer, intent(inout) :: IO
integer, dimension(len_instructions) :: line
read(vm%bytecode_fh, fmt = *, iostat = IO) line
vm%N_momenta = line(1)
vm%N_particles = line(2)
vm%N_prt_in = line(3)
vm%N_prt_out = line(4)
vm%N_amplitudes = line(5)
vm%N_helicities = line(6)
vm%N_col_flows = line(7)
if (vm%N_momenta == 0) then
vm%N_col_indices = 2
else
vm%N_col_indices = line(8)
end if
read(vm%bytecode_fh, fmt = *, iostat = IO)
read(vm%bytecode_fh, fmt = *, iostat = IO) line
vm%N_flavors = line(1)
vm%N_col_factors = line(2)
vm%N_scalars = line(3)
vm%N_spinors = line(4)
vm%N_conjspinors = line(5)
vm%N_bispinors = line(6)
vm%N_vectors = line(7)
vm%N_tensors_2 = line(8)
read(vm%bytecode_fh, fmt = *, iostat = IO)
read(vm%bytecode_fh, fmt = *, iostat = IO) line
vm%N_tensors_1 = line(1)
vm%N_vectorspinors = line(2)
! Add 1 for seperating label lines like 'Another table'
vm%N_table_lines = vm%N_helicities + 1 + vm%N_flavors + 1 + vm%N_col_flows &
+ 1 + vm%N_col_flows + 1 + vm%N_col_factors + 1 + vm%N_col_flows
end subroutine load_header
@
<<OVM Procedure Implementations>>=
subroutine read_tables (vm, IO)
type(vm_t), intent(inout) :: vm
integer, intent(inout) :: IO
integer :: i
integer, dimension(2) :: tmpcf
integer, dimension(3) :: tmpfactor
integer, dimension(vm%N_flavors) :: tmpF
integer, dimension(vm%N_particles) :: tmpP
real(default) :: factor
do i = 1, vm%N_helicities
read(vm%bytecode_fh, fmt = *, iostat = IO) vm%table_spin(:, i)
end do
read(vm%bytecode_fh, fmt = *, iostat = IO)
do i = 1, vm%N_flavors
read(vm%bytecode_fh, fmt = *, iostat = IO) vm%table_flavor(:, i)
end do
read(vm%bytecode_fh, fmt = *, iostat = IO)
do i = 1, vm%N_col_flows
read(vm%bytecode_fh, fmt = *, iostat = IO) vm%table_color_flows(:, :, i)
end do
read(vm%bytecode_fh, fmt = *, iostat = IO)
do i = 1, vm%N_col_flows
read(vm%bytecode_fh, fmt = *, iostat = IO) tmpP
vm%table_ghost_flags(:, i) = int_to_log(tmpP)
end do
read(vm%bytecode_fh, fmt = *, iostat = IO)
do i = 1, vm%N_col_factors
read(vm%bytecode_fh, fmt = '(2I9)', iostat = IO, advance='no') tmpcf
factor = zero
do
read(vm%bytecode_fh, fmt = '(3I9)', iostat = IO, advance='no', EOR=10) tmpfactor
factor = factor + color_factor(tmpfactor(1), tmpfactor(2), tmpfactor(3))
end do
10 vm%table_color_factors(i) = OCF(tmpcf(1), tmpcf(2), factor)
end do
read(vm%bytecode_fh, fmt = *, iostat = IO)
do i = 1, vm%N_col_flows
read(vm%bytecode_fh, fmt = *, iostat = IO) tmpF
vm%table_flv_col_is_allowed(:, i) = int_to_log(tmpF)
end do
end subroutine read_tables
@ This checking has proven useful more than once
<<OVM Procedure Implementations>>=
subroutine extended_version_check (vm, IO)
type(vm_t), intent(in) :: vm
integer, intent(inout) :: IO
character(256) :: buffer
read(vm%bytecode_fh, fmt = *, iostat = IO) buffer
if (vm%model /= buffer) then
print *, "Warning: Bytecode has been generated with an older SVN revision."
else
if (vm%verbose) then
write (vm%out_fh, fmt = *) "Using the model: "
write (vm%out_fh, fmt = *) char(vm%model)
end if
end if
end subroutine extended_version_check
@ This chunk is copied verbatim from the [[basic_vm]]
<<OVM Procedure Implementations>>=
subroutine basic_init (vm, verbose, out_fh)
type(vm_t), intent(inout) :: vm
logical, optional, intent(in) :: verbose
integer, optional, intent(in) :: out_fh
if (present (verbose)) then
vm%verbose = verbose
else
vm%verbose = .true.
end if
if (present (out_fh)) then
vm%out_fh = out_fh
else
vm%out_fh = stdout
end if
call set_stream (vm)
call alloc_and_count (vm)
if (vm%N_levels > 0) then
call read_bytecode (vm)
call sanity_check (vm)
end if
close (vm%bytecode_fh)
end subroutine basic_init
subroutine basic_write (vm)
type(vm_t), intent(in) :: vm
integer :: i
write (vm%out_fh, *) '=====> VM ', char(vm%version), ' <====='
write (vm%out_fh, *) 'verbose = ', vm%verbose
write (vm%out_fh, *) 'bytecode_file = ', char (vm%bytecode_file)
write (vm%out_fh, *) 'N_instructions = ', vm%N_instructions
write (vm%out_fh, *) 'N_levels = ', vm%N_levels
write (vm%out_fh, *) 'instructions = '
do i = 1, vm%N_instructions
write (vm%out_fh, *) vm%instructions(:, i)
end do
write (vm%out_fh, *) 'levels = ', vm%levels
end subroutine basic_write
subroutine alloc_and_count (vm)
type(vm_t), intent(inout) :: vm
integer, dimension(len_instructions) :: line
character(256) :: buffer
integer :: i, IO
read(vm%bytecode_fh, fmt = *, iostat = IO) buffer
if (vm%version /= buffer) then
print *, "Warning: Bytecode has been generated with an older SVN revision."
else
if (vm%verbose) then
write (vm%out_fh, fmt = *) "Bytecode version fits."
end if
end if
call extended_version_check (vm, IO)
if (vm%verbose) then
write (vm%out_fh, fmt = *) "Trying to allocate."
end if
do i = 1, N_comments
read(vm%bytecode_fh, fmt = *, iostat = IO)
end do
call load_header (vm, IO)
call alloc_arrays (vm)
if (vm%N_momenta /= 0) then
do i = 1, vm%N_table_lines + 1
read(vm%bytecode_fh, fmt = *, iostat = IO)
end do
vm%N_instructions = 0
vm%N_levels = 0
do
read(vm%bytecode_fh, fmt = *, end = 42) line
if (line(1) /= 0) then
vm%N_instructions = vm%N_instructions + 1
else
vm%N_levels = vm%N_levels + 1
end if
end do
42 rewind(vm%bytecode_fh, iostat = IO)
allocate (vm%instructions(len_instructions, vm%N_instructions))
allocate (vm%levels(vm%N_levels))
if (IO /= 0) then
print *, "Error: vm.alloc : Couldn't load bytecode!"
stop 1
end if
end if
end subroutine alloc_and_count
subroutine read_bytecode (vm)
type(vm_t), intent(inout) :: vm
integer, dimension(len_instructions) :: line
integer :: i, j, IO
! Jump over version number, comments, header and first table description
do i = 1, N_version_lines + N_comments + N_header_lines + 1
read (vm%bytecode_fh, fmt = *, iostat = IO)
end do
call read_tables (vm, IO)
read (vm%bytecode_fh, fmt = *, iostat = IO)
i = 0; j = 0
do
read (vm%bytecode_fh, fmt = *, iostat = IO) line
if (IO /= 0) exit
if (line(1) == 0) then
if (j <= vm%N_levels) then
j = j + 1
vm%levels(j) = i ! last index of a level is saved
else
print *, 'Error: vm.read_bytecode: File has more levels than anticipated!'
stop 1
end if
else
if (i <= vm%N_instructions) then
i = i + 1 ! A valid instruction line
vm%instructions(:, i) = line
else
print *, 'Error: vm.read_bytecode: File is larger than anticipated!'
stop 1
end if
end if
end do
end subroutine read_bytecode
subroutine iterate_instructions (vm)
type(vm_t), intent(inout) :: vm
integer :: i, j
if (vm%openmp) then
!$omp parallel
do j = 1, vm%N_levels - 1
!$omp do schedule (static)
do i = vm%levels (j) + 1, vm%levels (j + 1)
call decode (vm, i)
end do
!$omp end do
end do
!$omp end parallel
else
do j = 1, vm%N_levels - 1
do i = vm%levels (j) + 1, vm%levels (j + 1)
call decode (vm, i)
end do
end do
end if
end subroutine iterate_instructions
subroutine set_stream (vm)
type(vm_t), intent(inout) :: vm
integer :: IO
call find_free_unit (vm%bytecode_fh, IO)
open (vm%bytecode_fh, file = char (vm%bytecode_file), form = 'formatted', &
access = 'sequential', status = 'old', position = 'rewind', iostat = IO, &
action = 'read')
if (IO /= 0) then
print *, "Error: vm.set_stream: Bytecode file '", char(vm%bytecode_file), &
"' not found!"
stop 1
end if
end subroutine set_stream
subroutine sanity_check (vm)
type(vm_t), intent(in) :: vm
if (vm%levels(1) /= 0) then
print *, "Error: vm.vm_init: levels(1) != 0"
stop 1
end if
if (vm%levels(vm%N_levels) /= vm%N_instructions) then
print *, "Error: vm.vm_init: levels(N_levels) != N_instructions"
stop 1
end if
if (vm%verbose) then
write(vm%out_fh, *) "vm passed sanity check. Starting calculation."
end if
end subroutine sanity_check
@
\subsection{Main Decode Function}
This is the heart of the OVM
<<OVM Procedure Implementations>>=
! pure & ! if no warnings
subroutine decode (vm, instruction_index)
type(vm_t), intent(inout) :: vm
integer, intent(in) :: instruction_index
integer, dimension(len_instructions) :: i, curr
complex(default) :: braket
integer :: tmp
real(default) :: w
i = vm%instructions (:, instruction_index)
select case (i(1))
case ( : -1) ! Jump over subinstructions
<<[[case]]s of [[decode]]>>
case (0)
print *, 'Error: Levelbreak put in decode! Line:', &
instruction_index
stop 1
case default
print *, "Error: Decode has case not catched! Line: ", &
instruction_index
stop 1
end select
end subroutine decode
@
\subsubsection{Momenta}
The most trivial instruction
<<OVM Instructions>>=
integer, parameter :: ovm_ADD_MOMENTA = 1
@
<<[[case]]s of [[decode]]>>=
case (ovm_ADD_MOMENTA)
vm%momenta(i(4)) = vm%momenta(i(5)) + vm%momenta(i(6))
if (i(7) > 0) then
vm%momenta(i(4)) = vm%momenta(i(4)) + vm%momenta(i(7))
end if
@
\subsubsection{Loading External states}
<<OVM Instructions>>=
integer, parameter :: ovm_LOAD_SCALAR = 10
integer, parameter :: ovm_LOAD_SPINOR_INC = 11
integer, parameter :: ovm_LOAD_SPINOR_OUT = 12
integer, parameter :: ovm_LOAD_CONJSPINOR_INC = 13
integer, parameter :: ovm_LOAD_CONJSPINOR_OUT = 14
integer, parameter :: ovm_LOAD_MAJORANA_INC = 15
integer, parameter :: ovm_LOAD_MAJORANA_OUT = 16
integer, parameter :: ovm_LOAD_VECTOR_INC = 17
integer, parameter :: ovm_LOAD_VECTOR_OUT = 18
integer, parameter :: ovm_LOAD_VECTORSPINOR_INC = 19
integer, parameter :: ovm_LOAD_VECTORSPINOR_OUT = 20
integer, parameter :: ovm_LOAD_TENSOR2_INC = 21
integer, parameter :: ovm_LOAD_TENSOR2_OUT = 22
integer, parameter :: ovm_LOAD_BRS_SCALAR = 30
integer, parameter :: ovm_LOAD_BRS_SPINOR_INC = 31
integer, parameter :: ovm_LOAD_BRS_SPINOR_OUT = 32
integer, parameter :: ovm_LOAD_BRS_CONJSPINOR_INC = 33
integer, parameter :: ovm_LOAD_BRS_CONJSPINOR_OUT = 34
integer, parameter :: ovm_LOAD_BRS_VECTOR_INC = 37
integer, parameter :: ovm_LOAD_BRS_VECTOR_OUT = 38
integer, parameter :: ovm_LOAD_MAJORANA_GHOST_INC = 23
integer, parameter :: ovm_LOAD_MAJORANA_GHOST_OUT = 24
integer, parameter :: ovm_LOAD_BRS_MAJORANA_INC = 35
integer, parameter :: ovm_LOAD_BRS_MAJORANA_OUT = 36
@
<<[[case]]s of [[decode]]>>=
case (ovm_LOAD_SCALAR)
vm%scalars(i(4))%v = one
vm%scalars(i(4))%c = .True.
case (ovm_LOAD_SPINOR_INC)
call load_spinor(vm%spinors(i(4)), - <<p>>, <<m>>, &
vm%helicity(i(5)), ovm_LOAD_SPINOR_INC)
case (ovm_LOAD_SPINOR_OUT)
call load_spinor(vm%spinors(i(4)), <<p>>, <<m>>, &
vm%helicity(i(5)), ovm_LOAD_SPINOR_OUT)
case (ovm_LOAD_CONJSPINOR_INC)
call load_conjspinor(vm%conjspinors(i(4)), - <<p>>, &
<<m>>, vm%helicity(i(5)), ovm_LOAD_CONJSPINOR_INC)
case (ovm_LOAD_CONJSPINOR_OUT)
call load_conjspinor(vm%conjspinors(i(4)), <<p>>, &
<<m>>, vm%helicity(i(5)), ovm_LOAD_CONJSPINOR_OUT)
case (ovm_LOAD_MAJORANA_INC)
call load_bispinor(vm%bispinors(i(4)), - <<p>>, &
<<m>>, vm%helicity(i(5)), ovm_LOAD_MAJORANA_INC)
case (ovm_LOAD_MAJORANA_OUT)
call load_bispinor(vm%bispinors(i(4)), <<p>>, <<m>>, &
vm%helicity(i(5)), ovm_LOAD_MAJORANA_OUT)
case (ovm_LOAD_VECTOR_INC)
call load_vector(vm%vectors(i(4)), - <<p>>, <<m>>, &
vm%helicity(i(5)), ovm_LOAD_VECTOR_INC)
case (ovm_LOAD_VECTOR_OUT)
call load_vector(vm%vectors(i(4)), <<p>>, <<m>>, &
vm%helicity(i(5)), ovm_LOAD_VECTOR_OUT)
case (ovm_LOAD_VECTORSPINOR_INC)
!select type (h => vm%helicity(i(5)))
!type is (hel_discrete)
!vm%vectorspinors(i(4))%v = veps(<<m>>, - <<p>>, &
!h%i)
!end select
vm%vectorspinors(i(4))%v = veps(<<m>>, - <<p>>, &
vm%helicity(i(5)))
vm%vectorspinors(i(4))%c = .True.
case (ovm_LOAD_VECTORSPINOR_OUT)
!select type (h => vm%helicity(i(5)))
!type is (hel_discrete)
!vm%vectorspinors(i(4))%v = veps(<<m>>, <<p>>, &
!h%i)
!end select
vm%vectorspinors(i(4))%v = veps(<<m>>, <<p>>, &
vm%helicity(i(5)))
vm%vectorspinors(i(4))%c = .True.
case (ovm_LOAD_TENSOR2_INC)
!select type (h => vm%helicity(i(5)))
!type is (hel_discrete)
!vm%tensors_2(i(4))%v = eps2(<<m>>, - <<p>>, &
!h%i)
!end select
vm%tensors_2(i(4))%c = .True.
case (ovm_LOAD_TENSOR2_OUT)
!select type (h => vm%helicity(i(5)))
!type is (hel_discrete)
!vm%tensors_2(i(4))%v = eps2(<<m>>, <<p>>, h%i)
!end select
vm%tensors_2(i(4))%c = .True.
case (ovm_LOAD_BRS_SCALAR)
vm%scalars(i(4))%v = (0, -1) * (<<p>> * <<p>> - &
<<m>>**2)
vm%scalars(i(4))%c = .True.
case (ovm_LOAD_BRS_SPINOR_INC)
print *, 'not implemented'
stop 1
case (ovm_LOAD_BRS_SPINOR_OUT)
print *, 'not implemented'
stop 1
case (ovm_LOAD_BRS_CONJSPINOR_INC)
print *, 'not implemented'
stop 1
case (ovm_LOAD_BRS_CONJSPINOR_OUT)
print *, 'not implemented'
stop 1
case (ovm_LOAD_BRS_VECTOR_INC)
print *, 'not implemented'
stop 1
case (ovm_LOAD_BRS_VECTOR_OUT)
print *, 'not implemented'
stop 1
case (ovm_LOAD_MAJORANA_GHOST_INC)
print *, 'not implemented'
stop 1
case (ovm_LOAD_MAJORANA_GHOST_OUT)
print *, 'not implemented'
stop 1
case (ovm_LOAD_BRS_MAJORANA_INC)
print *, 'not implemented'
stop 1
case (ovm_LOAD_BRS_MAJORANA_OUT)
print *, 'not implemented'
stop 1
@
\subsubsection{Brakets and Fusions}
NB: during, execution, the type of the coupling constant is implicit in
the instruction
<<OVM Instructions>>=
integer, parameter :: ovm_CALC_BRAKET = 2
integer, parameter :: ovm_FUSE_V_FF = -1
integer, parameter :: ovm_FUSE_F_VF = -2
integer, parameter :: ovm_FUSE_F_FV = -3
integer, parameter :: ovm_FUSE_VA_FF = -4
integer, parameter :: ovm_FUSE_F_VAF = -5
integer, parameter :: ovm_FUSE_F_FVA = -6
integer, parameter :: ovm_FUSE_VA2_FF = -7
integer, parameter :: ovm_FUSE_F_VA2F = -8
integer, parameter :: ovm_FUSE_F_FVA2 = -9
integer, parameter :: ovm_FUSE_A_FF = -10
integer, parameter :: ovm_FUSE_F_AF = -11
integer, parameter :: ovm_FUSE_F_FA = -12
integer, parameter :: ovm_FUSE_VL_FF = -13
integer, parameter :: ovm_FUSE_F_VLF = -14
integer, parameter :: ovm_FUSE_F_FVL = -15
integer, parameter :: ovm_FUSE_VR_FF = -16
integer, parameter :: ovm_FUSE_F_VRF = -17
integer, parameter :: ovm_FUSE_F_FVR = -18
integer, parameter :: ovm_FUSE_VLR_FF = -19
integer, parameter :: ovm_FUSE_F_VLRF = -20
integer, parameter :: ovm_FUSE_F_FVLR = -21
integer, parameter :: ovm_FUSE_SP_FF = -22
integer, parameter :: ovm_FUSE_F_SPF = -23
integer, parameter :: ovm_FUSE_F_FSP = -24
integer, parameter :: ovm_FUSE_S_FF = -25
integer, parameter :: ovm_FUSE_F_SF = -26
integer, parameter :: ovm_FUSE_F_FS = -27
integer, parameter :: ovm_FUSE_P_FF = -28
integer, parameter :: ovm_FUSE_F_PF = -29
integer, parameter :: ovm_FUSE_F_FP = -30
integer, parameter :: ovm_FUSE_SL_FF = -31
integer, parameter :: ovm_FUSE_F_SLF = -32
integer, parameter :: ovm_FUSE_F_FSL = -33
integer, parameter :: ovm_FUSE_SR_FF = -34
integer, parameter :: ovm_FUSE_F_SRF = -35
integer, parameter :: ovm_FUSE_F_FSR = -36
integer, parameter :: ovm_FUSE_SLR_FF = -37
integer, parameter :: ovm_FUSE_F_SLRF = -38
integer, parameter :: ovm_FUSE_F_FSLR = -39
integer, parameter :: ovm_FUSE_G_GG = -40
integer, parameter :: ovm_FUSE_V_SS = -41
integer, parameter :: ovm_FUSE_S_VV = -42
integer, parameter :: ovm_FUSE_S_VS = -43
integer, parameter :: ovm_FUSE_V_SV = -44
integer, parameter :: ovm_FUSE_S_SS = -45
integer, parameter :: ovm_FUSE_S_SVV = -46
integer, parameter :: ovm_FUSE_V_SSV = -47
integer, parameter :: ovm_FUSE_S_SSS = -48
integer, parameter :: ovm_FUSE_V_VVV = -49
integer, parameter :: ovm_FUSE_S_G2 = -50
integer, parameter :: ovm_FUSE_G_SG = -51
integer, parameter :: ovm_FUSE_G_GS = -52
integer, parameter :: ovm_FUSE_S_G2_SKEW = -53
integer, parameter :: ovm_FUSE_G_SG_SKEW = -54
integer, parameter :: ovm_FUSE_G_GS_SKEW = -55
@
Shorthands
<<p>>=
vm%momenta(i(5))
<<m>>=
vm%mass(i(2))
<<p1>>=
vm%momenta(curr(6))
<<p2>>=
vm%momenta(curr(8))
<<v1>>=
vm%vectors(curr(5))%v
<<v2>>=
vm%vectors(curr(7))%v
<<s1>>=
vm%scalars(curr(5))%v
<<s2>>=
vm%scalars(curr(7))%v
<<c>>=
sgn_coupl_cmplx(vm, curr(2))
<<c1>>=
sgn_coupl_cmplx2(vm, curr(2), 1)
<<c2>>=
sgn_coupl_cmplx2(vm, curr(2), 2)
@
<<check for matching color and flavor amplitude of braket (old)>>=
if ((i(4) == o%cols(1)) .or. (i(4) == o%cols(2)) .or. &
((mode%col_MC .eq. FULL_SUM) .or. (mode%col_MC .eq. DIAG_COL))) then
@ Just a stub for now. Will be reimplemented with the polymorph type
[[color]] similar to the [[select type(helicity)]] when we need it.
<<check for matching color and flavor amplitude>>=
@
<<[[case]]s of [[decode]]>>=
case (ovm_CALC_BRAKET)
<<check for matching color and flavor amplitude>>
tmp = instruction_index + 1
do
if (tmp > vm%N_instructions) exit
curr = vm%instructions(:, tmp)
if (curr(1) >= 0) exit ! End of fusions
select case (curr(1))
case (ovm_FUSE_V_FF, ovm_FUSE_VL_FF, ovm_FUSE_VR_FF)
braket = vm%vectors(curr(4))%v * vec_ff(vm, curr)
case (ovm_FUSE_F_VF, ovm_FUSE_F_VLF, ovm_FUSE_F_VRF)
braket = vm%conjspinors(curr(4))%v * ferm_vf(vm, curr)
case (ovm_FUSE_F_FV, ovm_FUSE_F_FVL, ovm_FUSE_F_FVR)
braket = ferm_fv(vm, curr) * vm%spinors(curr(4))%v
case (ovm_FUSE_VA_FF)
braket = vm%vectors(curr(4))%v * vec_ff2(vm, curr)
case (ovm_FUSE_F_VAF)
braket = vm%conjspinors(curr(4))%v * ferm_vf2(vm, curr)
case (ovm_FUSE_F_FVA)
braket = ferm_fv2(vm, curr) * vm%spinors(curr(4))%v
case (ovm_FUSE_S_FF, ovm_FUSE_SP_FF)
braket = vm%scalars(curr(4))%v * scal_ff(vm, curr)
case (ovm_FUSE_F_SF, ovm_FUSE_F_SPF)
braket = vm%conjspinors(curr(4))%v * ferm_sf(vm, curr)
case (ovm_FUSE_F_FS, ovm_FUSE_F_FSP)
braket = ferm_fs(vm, curr) * vm%spinors(curr(4))%v
case (ovm_FUSE_G_GG)
braket = vm%vectors(curr(4))%v * &
g_gg(<<c>>, &
<<v1>>, <<p1>>, &
<<v2>>, <<p2>>)
case (ovm_FUSE_S_VV)
braket = vm%scalars(curr(4))%v * <<c>> * &
(<<v1>> * vm%vectors(curr(6))%v)
case (ovm_FUSE_V_SS)
braket = vm%vectors(curr(4))%v * &
v_ss(<<c>>, <<s1>>, <<p1>>, &
<<s2>>, <<p2>>)
case (ovm_FUSE_S_G2, ovm_FUSE_S_G2_SKEW)
braket = vm%scalars(curr(4))%v * scal_g2(vm, curr)
case (ovm_FUSE_G_SG, ovm_FUSE_G_GS, ovm_FUSE_G_SG_SKEW, ovm_FUSE_G_GS_SKEW)
braket = vm%vectors(curr(4))%v * gauge_sg(vm, curr)
case (ovm_FUSE_S_VS)
braket = vm%scalars(curr(4))%v * &
s_vs(<<c>>, &
<<v1>>, <<p1>>, &
<<s2>>, <<p2>>)
case (ovm_FUSE_V_SV)
braket = (vm%vectors(curr(4))%v * vm%vectors(curr(6))%v) * &
(<<c>> * <<s1>>)
case (ovm_FUSE_S_SS)
braket = vm%scalars(curr(4))%v * &
<<c>> * &
(<<s1>> * vm%scalars(curr(6))%v)
case (ovm_FUSE_S_SSS)
braket = vm%scalars(curr(4))%v * &
<<c>> * &
(<<s1>> * vm%scalars(curr(6))%v * &
<<s2>>)
case (ovm_FUSE_S_SVV)
braket = vm%scalars(curr(4))%v * &
<<c>> * &
<<s1>> * (vm%vectors(curr(6))%v * &
<<v2>>)
case (ovm_FUSE_V_SSV)
braket = vm%vectors(curr(4))%v * &
(<<c>> * <<s1>> * &
vm%scalars(curr(6))%v) * <<v2>>
case (ovm_FUSE_V_VVV)
braket = <<c>> * &
(<<v1>> * vm%vectors(curr(6))%v) * &
(vm%vectors(curr(4))%v * <<v2>>)
case default
print *, 'Braket', curr(1), 'not implemented'
stop 1
end select
vm%amplitudes(i(4)) = vm%amplitudes(i(4)) + curr(3) * braket
tmp = tmp + 1
end do
vm%amplitudes(i(4)) = vm%amplitudes(i(4)) * i(2)
if (i(5) > 1) then
vm%amplitudes(i(4)) = vm%amplitudes(i(4)) * & ! Symmetry factor
(one / sqrt(real(i(5), kind=default)))
end if
@
\subsubsection{Propagators}
<<OVM Instructions>>=
integer, parameter :: ovm_PROPAGATE_SCALAR = 51
integer, parameter :: ovm_PROPAGATE_COL_SCALAR = 52
integer, parameter :: ovm_PROPAGATE_GHOST = 53
integer, parameter :: ovm_PROPAGATE_SPINOR = 54
integer, parameter :: ovm_PROPAGATE_CONJSPINOR = 55
integer, parameter :: ovm_PROPAGATE_MAJORANA = 56
integer, parameter :: ovm_PROPAGATE_COL_MAJORANA = 57
integer, parameter :: ovm_PROPAGATE_UNITARITY = 58
integer, parameter :: ovm_PROPAGATE_COL_UNITARITY = 59
integer, parameter :: ovm_PROPAGATE_FEYNMAN = 60
integer, parameter :: ovm_PROPAGATE_COL_FEYNMAN = 61
integer, parameter :: ovm_PROPAGATE_VECTORSPINOR = 62
integer, parameter :: ovm_PROPAGATE_TENSOR2 = 63
integer, parameter :: ovm_PROPAGATE_NONE = 64
@
<<check for matching color and flavor amplitude of propagator (old)>>=
if ((mode%col_MC .eq. FULL_SUM) .or. (mode%col_MC .eq. DIAG_COL)) then
select case(i(1))
case (ovm_PROPAGATE_PSI)
go = .not. vm%spinors%c(i(4))
case (ovm_PROPAGATE_PSIBAR)
go = .not. vm%conjspinors%c(i(4))
case (ovm_PROPAGATE_UNITARITY, ovm_PROPAGATE_FEYNMAN, &
ovm_PROPAGATE_COL_FEYNMAN)
go = .not. vm%vectors%c(i(4))
end select
else
go = (i(8) == o%cols(1)) .or. (i(8) == o%cols(2))
end if
if (go) then
<<[[case]]s of [[decode]]>>=
<<check for matching color and flavor amplitude>>
case (ovm_PROPAGATE_SCALAR : ovm_PROPAGATE_NONE)
tmp = instruction_index + 1
do
curr = vm%instructions(:,tmp)
if (curr(1) >= 0) exit ! End of fusions
select case (curr(1))
case (ovm_FUSE_V_FF, ovm_FUSE_VL_FF, ovm_FUSE_VR_FF)
vm%vectors(curr(4))%v = vm%vectors(curr(4))%v + curr(3) * &
vec_ff(vm, curr)
case (ovm_FUSE_F_VF, ovm_FUSE_F_VLF, ovm_FUSE_F_VRF)
vm%spinors(curr(4))%v = vm%spinors(curr(4))%v + curr(3) * &
ferm_vf(vm, curr)
case (ovm_FUSE_F_FV, ovm_FUSE_F_FVL, ovm_FUSE_F_FVR)
vm%conjspinors(curr(4))%v = vm%conjspinors(curr(4))%v + curr(3) * &
ferm_fv(vm, curr)
case (ovm_FUSE_VA_FF)
vm%vectors(curr(4))%v = vm%vectors(curr(4))%v + curr(3) * &
vec_ff2(vm, curr)
case (ovm_FUSE_F_VAF)
vm%spinors(curr(4))%v = vm%spinors(curr(4))%v + curr(3) * &
ferm_vf2(vm, curr)
case (ovm_FUSE_F_FVA)
vm%conjspinors(curr(4))%v = vm%conjspinors(curr(4))%v + curr(3) * &
ferm_fv2(vm, curr)
case (ovm_FUSE_S_FF, ovm_FUSE_SP_FF)
vm%scalars(curr(4))%v = vm%scalars(curr(4))%v + curr(3) * &
scal_ff(vm, curr)
case (ovm_FUSE_F_SF, ovm_FUSE_F_SPF)
vm%spinors(curr(4))%v = vm%spinors(curr(4))%v + curr(3) * &
ferm_sf(vm, curr)
case (ovm_FUSE_F_FS, ovm_FUSE_F_FSP)
vm%conjspinors(curr(4))%v = vm%conjspinors(curr(4))%v + curr(3) * &
ferm_fs(vm, curr)
case (ovm_FUSE_G_GG)
vm%vectors(curr(4))%v = vm%vectors(curr(4))%v + curr(3) * &
g_gg(<<c>>, <<v1>>, &
<<p1>>, <<v2>>, &
<<p2>>)
case (ovm_FUSE_S_VV)
vm%scalars(curr(4))%v = vm%scalars(curr(4))%v + curr(3) * &
<<c>> * &
(<<v1>> * vm%vectors(curr(6))%v)
case (ovm_FUSE_V_SS)
vm%vectors(curr(4))%v = vm%vectors(curr(4))%v + curr(3) * &
v_ss(<<c>>, <<s1>>, <<p1>>, &
<<s2>>, <<p2>>)
case (ovm_FUSE_S_G2, ovm_FUSE_S_G2_SKEW)
vm%scalars(curr(4))%v = vm%scalars(curr(4))%v + &
scal_g2(vm, curr) * curr(3)
case (ovm_FUSE_G_SG, ovm_FUSE_G_GS, ovm_FUSE_G_SG_SKEW, ovm_FUSE_G_GS_SKEW)
vm%vectors(curr(4))%v = vm%vectors(curr(4))%v + &
gauge_sg(vm, curr) * curr(3)
case (ovm_FUSE_S_VS)
vm%scalars(curr(4))%v = vm%scalars(curr(4))%v + &
s_vs(<<c>>, &
<<v1>>, <<p1>>, &
<<s2>>, <<p2>>) * curr(3)
case (ovm_FUSE_V_SV)
vm%vectors(curr(4))%v = vm%vectors(curr(4))%v + &
vm%vectors(curr(6))%v * &
(<<c>> * <<s1>> * curr(3))
case (ovm_FUSE_S_SS)
vm%scalars(curr(4))%v = vm%scalars(curr(4))%v + &
<<c>> * &
(<<s1>> * vm%scalars(curr(6))%v) * curr(3)
case (ovm_FUSE_S_SSS)
vm%scalars(curr(4))%v = vm%scalars(curr(4))%v + &
<<c>> * &
(<<s1>> * vm%scalars(curr(6))%v * &
<<s2>>) * curr(3)
case (ovm_FUSE_S_SVV)
vm%scalars(curr(4))%v = vm%scalars(curr(4))%v + &
<<c>> * &
<<s1>> * (vm%vectors(curr(6))%v * &
<<v2>>) * curr(3)
case (ovm_FUSE_V_SSV)
vm%vectors(curr(4))%v = vm%vectors(curr(4))%v + &
(<<c>> * <<s1>> * &
vm%scalars(curr(6))%v) * <<v2>> * curr(3)
case (ovm_FUSE_V_VVV)
vm%vectors(curr(4))%v = vm%vectors(curr(4))%v + &
(<<c>> * (<<v1>> * &
vm%vectors(curr(6))%v)) * curr(3) * <<v2>>
case default
print *, 'Fusion', curr(1), 'not implemented'
stop 1
end select
tmp = tmp + 1
end do
select case (i(3))
case (0)
w = zero
case (1)
w = vm%width(i(2))
vm%cms = .false.
case (2)
w = wd_tl(<<p>>, vm%width(i(2)))
case (3)
w = vm%width(i(2))
vm%cms = .true.
case (4)
w = wd_run(<<p>>, <<m>>, vm%width(i(2)))
case default
print *, 'not implemented'
stop 1
end select
select case (i(1))
<<propagator [[case]]s in [[decode]]>>
end select
@
<<propagator [[case]]s in [[decode]]>>=
case (ovm_PROPAGATE_SCALAR)
vm%scalars(i(4))%v = pr_phi(<<p>>, <<m>>, &
w, vm%scalars(i(4))%v)
vm%scalars(i(4))%c = .True.
case (ovm_PROPAGATE_COL_SCALAR)
vm%scalars(i(4))%v = - one / N_ * pr_phi(<<p>>, &
<<m>>, w, vm%scalars(i(4))%v)
vm%scalars(i(4))%c = .True.
case (ovm_PROPAGATE_GHOST)
vm%scalars(i(4))%v = imago * pr_phi(<<p>>, <<m>>, &
w, vm%scalars(i(4))%v)
vm%scalars(i(4))%c = .True.
case (ovm_PROPAGATE_SPINOR)
vm%spinors(i(4))%v = pr_psi(<<p>>, <<m>>, &
w, vm%cms, vm%spinors(i(4))%v)
vm%spinors(i(4))%c = .True.
case (ovm_PROPAGATE_CONJSPINOR)
vm%conjspinors(i(4))%v = pr_psibar(<<p>>, <<m>>, &
w, vm%cms, vm%conjspinors(i(4))%v)
vm%conjspinors(i(4))%c = .True.
case (ovm_PROPAGATE_MAJORANA)
vm%bispinors(i(4))%v = bi_pr_psi(<<p>>, <<m>>, &
w, vm%cms, vm%bispinors(i(4))%v)
vm%bispinors(i(4))%c = .True.
case (ovm_PROPAGATE_COL_MAJORANA)
vm%bispinors(i(4))%v = (- one / N_) * &
bi_pr_psi(<<p>>, <<m>>, &
w, vm%cms, vm%bispinors(i(4))%v)
vm%bispinors(i(4))%c = .True.
case (ovm_PROPAGATE_UNITARITY)
vm%vectors(i(4))%v = pr_unitarity(<<p>>, <<m>>, &
w, vm%cms, vm%vectors(i(4))%v)
vm%vectors(i(4))%c = .True.
case (ovm_PROPAGATE_COL_UNITARITY)
vm%vectors(i(4))%v = - one / N_ * pr_unitarity(<<p>>, &
<<m>>, w, vm%cms, vm%vectors(i(4))%v)
vm%vectors(i(4))%c = .True.
case (ovm_PROPAGATE_FEYNMAN)
vm%vectors(i(4))%v = pr_feynman(<<p>>, vm%vectors(i(4))%v)
vm%vectors(i(4))%c = .True.
case (ovm_PROPAGATE_COL_FEYNMAN)
vm%vectors(i(4))%v = - one / N_ * &
pr_feynman(<<p>>, vm%vectors(i(4))%v)
vm%vectors(i(4))%c = .True.
case (ovm_PROPAGATE_VECTORSPINOR)
vm%vectorspinors(i(4))%v = pr_grav(<<p>>, <<m>>, &
w, vm%vectorspinors(i(4))%v)
vm%vectorspinors(i(4))%c = .True.
case (ovm_PROPAGATE_TENSOR2)
vm%tensors_2(i(4))%v = pr_tensor(<<p>>, <<m>>, &
w, vm%tensors_2(i(4))%v)
vm%tensors_2(i(4))%c = .True.
case (ovm_PROPAGATE_NONE)
! This will not work with color MC. Appropriate type%c has to be set to
! .True.
@
\subsection{Helper functions}
Factoring out these parts helps a lot to keep sane but might hurt the
performance of the VM noticably. In that case, we have to copy \&
paste to avoid the additional function calls. Note that with
preprocessor macros, we could maintain this factorized form (and factor
out even more since types don't have to match), in case we would decide
to allow this
<<load outer wave function>>=
!select type (h)
!type is (hel_trigonometric)
!wf%v = (cos (h%theta) * load_wf (m, p, + 1) + &
!sin (h%theta) * load_wf (m, p, - 1)) * sqrt2
!type is (hel_exponential)
!wf%v = exp (+ imago * h%phi) * load_wf (m, p, + 1) + &
!exp (- imago * h%phi) * load_wf (m, p, - 1)
!type is (hel_spherical)
!wf%v = (exp (+ imago * h%phi) * cos (h%theta) * load_wf (m, p, + 1) + &
!exp (- imago * h%phi) * sin (h%theta) * load_wf (m, p, - 1)) * &
!sqrt2
!type is(hel_discrete)
!wf%v = load_wf (m, p, h%i)
!end select
wf%v = load_wf (m, p, h)
wf%c = .True.
@
Caveat: Helicity MC not tested with Majorana particles but should be
fine
<<check for matching color and flavor amplitude of wf (old)>>=
if ((mode%col_MC .eq. FULL_SUM) .or. (mode%col_MC .eq. DIAG_COL)) then
go = .not. vm%spinors%c(i(4))
else
go = (i(8) == o%cols(1)) .or. (i(8) == o%cols(2))
end if
if (go) ..
<<OVM Procedure Implementations>>=
subroutine load_bispinor(wf, p, m, h, opcode)
type(vm_bispinor), intent(out) :: wf
type(momentum), intent(in) :: p
real(default), intent(in) :: m
!class(helicity_t), intent(in) :: h
integer, intent(in) :: h
integer, intent(in) :: opcode
procedure(bi_u), pointer :: load_wf
<<check for matching color and flavor amplitude>>
select case (opcode)
case (ovm_LOAD_MAJORANA_INC)
load_wf => bi_u
case (ovm_LOAD_MAJORANA_OUT)
load_wf => bi_v
case default
load_wf => null()
end select
<<load outer wave function>>
end subroutine load_bispinor
subroutine load_spinor(wf, p, m, h, opcode)
type(vm_spinor), intent(out) :: wf
type(momentum), intent(in) :: p
real(default), intent(in) :: m
!class(helicity_t), intent(in) :: h
integer, intent(in) :: h
integer, intent(in) :: opcode
procedure(u), pointer :: load_wf
<<check for matching color and flavor amplitude>>
select case (opcode)
case (ovm_LOAD_SPINOR_INC)
load_wf => u
case (ovm_LOAD_SPINOR_OUT)
load_wf => v
case default
load_wf => null()
end select
<<load outer wave function>>
end subroutine load_spinor
subroutine load_conjspinor(wf, p, m, h, opcode)
type(vm_conjspinor), intent(out) :: wf
type(momentum), intent(in) :: p
real(default), intent(in) :: m
!class(helicity_t), intent(in) :: h
integer, intent(in) :: h
integer, intent(in) :: opcode
procedure(ubar), pointer :: load_wf
<<check for matching color and flavor amplitude>>
select case (opcode)
case (ovm_LOAD_CONJSPINOR_INC)
load_wf => vbar
case (ovm_LOAD_CONJSPINOR_OUT)
load_wf => ubar
case default
load_wf => null()
end select
<<load outer wave function>>
end subroutine load_conjspinor
subroutine load_vector(wf, p, m, h, opcode)
type(vm_vector), intent(out) :: wf
type(momentum), intent(in) :: p
real(default), intent(in) :: m
!class(helicity_t), intent(in) :: h
integer, intent(in) :: h
integer, intent(in) :: opcode
procedure(eps), pointer :: load_wf
<<check for matching color and flavor amplitude>>
load_wf => eps
<<load outer wave function>>
if (opcode == ovm_LOAD_VECTOR_OUT) then
wf%v = conjg(wf%v)
end if
end subroutine load_vector
@
<<OVM Procedure Implementations>>=
function ferm_vf(vm, curr) result (x)
type(spinor) :: x
class(vm_t), intent(in) :: vm
integer, dimension(:), intent(in) :: curr
procedure(f_vf), pointer :: load_wf
select case (curr(1))
case (ovm_FUSE_F_VF)
load_wf => f_vf
case (ovm_FUSE_F_VLF)
load_wf => f_vlf
case (ovm_FUSE_F_VRF)
load_wf => f_vrf
case default
load_wf => null()
end select
x = load_wf(<<c>>, <<v1>>, vm%spinors(curr(6))%v)
end function ferm_vf
function ferm_vf2(vm, curr) result (x)
type(spinor) :: x
class(vm_t), intent(in) :: vm
integer, dimension(:), intent(in) :: curr
procedure(f_vaf), pointer :: load_wf
select case (curr(1))
case (ovm_FUSE_F_VAF)
load_wf => f_vaf
case default
load_wf => null()
end select
x = f_vaf(<<c1>>, <<c2>>, <<v1>>, vm%spinors(curr(6))%v)
end function ferm_vf2
function ferm_sf(vm, curr) result (x)
type(spinor) :: x
class(vm_t), intent(in) :: vm
integer, dimension(:), intent(in) :: curr
select case (curr(1))
case (ovm_FUSE_F_SF)
x = f_sf(<<c>>, <<s1>>, vm%spinors(curr(6))%v)
case (ovm_FUSE_F_SPF)
x = f_spf(<<c1>>, <<c2>>, <<s1>>, vm%spinors(curr(6))%v)
case default
end select
end function ferm_sf
function ferm_fv(vm, curr) result (x)
type(conjspinor) :: x
class(vm_t), intent(in) :: vm
integer, dimension(:), intent(in) :: curr
procedure(f_fv), pointer :: load_wf
select case (curr(1))
case (ovm_FUSE_F_FV)
load_wf => f_fv
case (ovm_FUSE_F_FVL)
load_wf => f_fvl
case (ovm_FUSE_F_FVR)
load_wf => f_fvr
case default
load_wf => null()
end select
x = load_wf(<<c>>, vm%conjspinors(curr(5))%v, vm%vectors(curr(6))%v)
end function ferm_fv
function ferm_fv2(vm, curr) result (x)
type(conjspinor) :: x
class(vm_t), intent(in) :: vm
integer, dimension(:), intent(in) :: curr
procedure(f_fva), pointer :: load_wf
select case (curr(1))
case (ovm_FUSE_F_FVA)
load_wf => f_fva
case default
load_wf => null()
end select
x = f_fva(<<c1>>, <<c2>>, &
vm%conjspinors(curr(5))%v, vm%vectors(curr(6))%v)
end function ferm_fv2
function ferm_fs(vm, curr) result (x)
type(conjspinor) :: x
class(vm_t), intent(in) :: vm
integer, dimension(:), intent(in) :: curr
procedure(f_fs), pointer :: load_wf
select case (curr(1))
case (ovm_FUSE_F_FS)
x = f_fs(<<c>>, vm%conjspinors(curr(5))%v, vm%scalars(curr(6))%v)
case (ovm_FUSE_F_FSP)
x = f_fsp(<<c1>>, <<c2>>, &
vm%conjspinors(curr(5))%v, vm%scalars(curr(6))%v)
case default
x%a = zero
end select
end function ferm_fs
function vec_ff(vm, curr) result (x)
type(vector) :: x
class(vm_t), intent(in) :: vm
integer, dimension(:), intent(in) :: curr
procedure(v_ff), pointer :: load_wf
select case (curr(1))
case (ovm_FUSE_V_FF)
load_wf => v_ff
case (ovm_FUSE_VL_FF)
load_wf => vl_ff
case (ovm_FUSE_VR_FF)
load_wf => vr_ff
case default
load_wf => null()
end select
x = load_wf(<<c>>, vm%conjspinors(curr(5))%v, vm%spinors(curr(6))%v)
end function vec_ff
function vec_ff2(vm, curr) result (x)
type(vector) :: x
class(vm_t), intent(in) :: vm
integer, dimension(:), intent(in) :: curr
procedure(va_ff), pointer :: load_wf
select case (curr(1))
case (ovm_FUSE_VA_FF)
load_wf => va_ff
case default
load_wf => null()
end select
x = load_wf(<<c1>>, <<c2>>, &
vm%conjspinors(curr(5))%v, vm%spinors(curr(6))%v)
end function vec_ff2
function scal_ff(vm, curr) result (x)
complex(default) :: x
class(vm_t), intent(in) :: vm
integer, dimension(:), intent(in) :: curr
select case (curr(1))
case (ovm_FUSE_S_FF)
x = s_ff(<<c>>, &
vm%conjspinors(curr(5))%v, vm%spinors(curr(6))%v)
case (ovm_FUSE_SP_FF)
x = sp_ff(<<c1>>, <<c2>>, &
vm%conjspinors(curr(5))%v, vm%spinors(curr(6))%v)
case default
x = zero
end select
end function scal_ff
function scal_g2(vm, curr) result (x)
complex(default) :: x
class(vm_t), intent(in) :: vm
integer, dimension(:), intent(in) :: curr
select case (curr(1))
case (ovm_FUSE_S_G2)
x = <<c>> * ((<<p1>> * <<v2>>) * &
(<<p2>> * <<v1>>) - &
(<<p1>> * <<p2>>) * &
(<<v2>> * <<v1>>))
case (ovm_FUSE_S_G2_SKEW)
x = - phi_vv(<<c>>, <<p1>>, <<p2>>, &
<<v1>>, <<v2>>)
case default
x = zero
end select
end function scal_g2
pure function gauge_sg(vm, curr) result (x)
type(vector) :: x
class(vm_t), intent(in) :: vm
integer, dimension(:), intent(in) :: curr
select case (curr(1))
case (ovm_FUSE_G_SG)
x = <<c>> * <<s1>> * ( &
-((<<p1>> + <<p2>>) * &
<<v2>>) * <<p2>> - &
(-(<<p1>> + <<p2>>) * &
<<p2>>) * <<v2>>)
case (ovm_FUSE_G_GS)
x = <<c>> * <<s1>> * ( &
-((<<p1>> + <<p2>>) * &
<<v2>>) * <<p2>> - &
(-(<<p1>> + <<p2>>) * &
<<p2>>) * <<v2>>)
case (ovm_FUSE_G_SG_SKEW)
x = - v_phiv(<<c>>, <<s1>>, <<p1>>, &
<<p2>>, <<v2>>)
case (ovm_FUSE_G_GS_SKEW)
x = - v_phiv(<<c>>, <<s2>>, <<p1>>, &
<<p2>>, <<v1>>)
case default
x = [zero, zero, zero, zero]
end select
end function gauge_sg
@ Some really tiny ones that hopefully get inlined by the compiler
<<OVM Procedure Implementations>>=
elemental function sgn_coupl_cmplx(vm, j) result (s)
class(vm_t), intent(in) :: vm
integer, intent(in) :: j
complex(default) :: s
s = isign(1, j) * vm%coupl_cmplx(abs(j))
end function sgn_coupl_cmplx
elemental function sgn_coupl_cmplx2(vm, j, i) result (s)
class(vm_t), intent(in) :: vm
integer, intent(in) :: j, i
complex(default) :: s
if (i == 1) then
s = isign(1, j) * vm%coupl_cmplx2(i, abs(j))
else
s = isign(1, j) * vm%coupl_cmplx2(i, abs(j))
end if
end function sgn_coupl_cmplx2
elemental function int_to_log(i) result(yorn)
integer, intent(in) :: i
logical :: yorn
if (i /= 0) then
yorn = .true.
else
yorn = .false.
end if
end function
elemental function color_factor(num, den, pwr) result (cf)
integer, intent(in) :: num, den, pwr
real(kind=default) :: cf
if (pwr == 0) then
cf = (one * num) / den
else
cf = (one * num) / den * (N_**pwr)
end if
end function color_factor
@
\subsection{O'Mega Interface}
We want to keep the interface close to the native Fortran code but of
course one has to hand over the [[vm]] additionally
<<VM: TBP>>=
procedure :: number_particles_in => vm_number_particles_in
procedure :: number_particles_out => vm_number_particles_out
procedure :: number_color_indices => vm_number_color_indices
procedure :: reset_helicity_selection => vm_reset_helicity_selection
procedure :: new_event => vm_new_event
procedure :: color_sum => vm_color_sum
procedure :: spin_states => vm_spin_states
procedure :: number_spin_states => vm_number_spin_states
procedure :: number_color_flows => vm_number_color_flows
procedure :: flavor_states => vm_flavor_states
procedure :: number_flavor_states => vm_number_flavor_states
procedure :: color_flows => vm_color_flows
procedure :: color_factors => vm_color_factors
procedure :: number_color_factors => vm_number_color_factors
procedure :: is_allowed => vm_is_allowed
procedure :: get_amplitude => vm_get_amplitude
@
<<OVM Procedure Implementations>>=
elemental function vm_number_particles_in (vm) result (n)
class(vm_t), intent(in) :: vm
integer :: n
n = vm%N_prt_in
end function vm_number_particles_in
elemental function vm_number_particles_out (vm) result (n)
class(vm_t), intent(in) :: vm
integer :: n
n = vm%N_prt_out
end function vm_number_particles_out
elemental function vm_number_spin_states (vm) result (n)
class(vm_t), intent(in) :: vm
integer :: n
n = vm%N_helicities
end function vm_number_spin_states
pure subroutine vm_spin_states (vm, a)
class(vm_t), intent(in) :: vm
integer, dimension(:,:), intent(out) :: a
a = vm%table_spin
end subroutine vm_spin_states
elemental function vm_number_flavor_states (vm) result (n)
class(vm_t), intent(in) :: vm
integer :: n
n = vm%N_flavors
end function vm_number_flavor_states
pure subroutine vm_flavor_states (vm, a)
class(vm_t), intent(in) :: vm
integer, dimension(:,:), intent(out) :: a
a = vm%table_flavor
end subroutine vm_flavor_states
elemental function vm_number_color_indices (vm) result (n)
class(vm_t), intent(in) :: vm
integer :: n
n = vm%N_col_indices
end function vm_number_color_indices
elemental function vm_number_color_flows (vm) result (n)
class(vm_t), intent(in) :: vm
integer :: n
n = vm%N_col_flows
end function vm_number_color_flows
pure subroutine vm_color_flows (vm, a, g)
class(vm_t), intent(in) :: vm
integer, dimension(:,:,:), intent(out) :: a
logical, dimension(:,:), intent(out) :: g
a = vm%table_color_flows
g = vm%table_ghost_flags
end subroutine vm_color_flows
elemental function vm_number_color_factors (vm) result (n)
class(vm_t), intent(in) :: vm
integer :: n
n = vm%N_col_factors
end function vm_number_color_factors
pure subroutine vm_color_factors (vm, cf)
class(vm_t), intent(in) :: vm
type(OCF), dimension(:), intent(out) :: cf
cf = vm%table_color_factors
end subroutine vm_color_factors
! pure & ! pure unless OpenMp
function vm_color_sum (vm, flv, hel) result (amp2)
class(vm_t), intent(in) :: vm
integer, intent(in) :: flv, hel
real(default) :: amp2
amp2 = ovm_color_sum (flv, hel, vm%table_amplitudes, vm%table_color_factors)
end function vm_color_sum
subroutine vm_new_event (vm, p)
class(vm_t), intent(inout) :: vm
real(default), dimension(0:3,*), intent(in) :: p
logical :: mask_dirty
integer :: hel
call vm%run (p)
if ((vm%hel_threshold .gt. 0) .and. (vm%hel_count .le. vm%hel_cutoff)) then
call omega_update_helicity_selection (vm%hel_count, vm%table_amplitudes, &
vm%hel_max_abs, vm%hel_sum_abs, vm%hel_is_allowed, vm%hel_threshold, &
vm%hel_cutoff, mask_dirty)
if (mask_dirty) then
vm%hel_finite = 0
do hel = 1, vm%N_helicities
if (vm%hel_is_allowed(hel)) then
vm%hel_finite = vm%hel_finite + 1
vm%hel_map(vm%hel_finite) = hel
end if
end do
end if
end if
end subroutine vm_new_event
pure subroutine vm_reset_helicity_selection (vm, threshold, cutoff)
class(vm_t), intent(inout) :: vm
real(kind=default), intent(in) :: threshold
integer, intent(in) :: cutoff
integer :: i
vm%hel_is_allowed = .True.
vm%hel_max_abs = 0
vm%hel_sum_abs = 0
vm%hel_count = 0
vm%hel_threshold = threshold
vm%hel_cutoff = cutoff
vm%hel_map = (/(i, i = 1, vm%N_helicities)/)
vm%hel_finite = vm%N_helicities
end subroutine vm_reset_helicity_selection
pure function vm_is_allowed (vm, flv, hel, col) result (yorn)
class(vm_t), intent(in) :: vm
logical :: yorn
integer, intent(in) :: flv, hel, col
yorn = vm%table_flv_col_is_allowed(flv,col) .and. vm%hel_is_allowed(hel)
end function vm_is_allowed
pure function vm_get_amplitude (vm, flv, hel, col) result (amp_result)
class(vm_t), intent(in) :: vm
complex(kind=default) :: amp_result
integer, intent(in) :: flv, hel, col
amp_result = vm%table_amplitudes(flv, col, hel)
end function vm_get_amplitude
@
@ %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
<<Copyleft>>=
! omegalib.nw --
!
! Copyright (C) 1999-2020 by
! Wolfgang Kilian <kilian@physik.uni-siegen.de>
! Thorsten Ohl <ohl@physik.uni-wuerzburg.de>
! Juergen Reuter <juergen.reuter@desy.de>
! with contributions from
! Fabian Bach <fabian.bach@t-online.de>
! Bijan Chokoufe Nejad <bijan.chokoufe@desy.de>
! Christian Speckner <cnspeckn@googlemail.com>
!
! WHIZARD is free software; you can redistribute it and/or modify it
! under the terms of the GNU General Public License as published by
! the Free Software Foundation; either version 2, or (at your option)
! any later version.
!
! WHIZARD is distributed in the hope that it will be useful, but
! WITHOUT ANY WARRANTY; without even the implied warranty of
! MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
! GNU General Public License for more details.
!
! You should have received a copy of the GNU General Public License
! along with this program; if not, write to the Free Software
! Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
!
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
@ %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
Index: trunk/share/tests/functional_tests/ref-output/user_prc_threshold_1.ref
===================================================================
--- trunk/share/tests/functional_tests/ref-output/user_prc_threshold_1.ref (revision 8482)
+++ trunk/share/tests/functional_tests/ref-output/user_prc_threshold_1.ref (revision 8483)
@@ -1,498 +1,491 @@
?openmp_logging = false
?vis_history = false
?integration_timer = false
?pacify = true
+?use_vamp_equivalences = false
openmp_num_threads = 1
| Switching to model 'SM_tt_threshold'
SM_tt_threshold.sqrtsmin => 3.50000E+02
SM_tt_threshold.sqrtsmax => 3.50000E+02
SM_tt_threshold.sqrtsstepsize => 0.00000E+00
SM_tt_threshold.m1S => 1.72000E+02
SM_tt_threshold.mZ => 9.11880E+01
SM_tt_threshold.mW => 8.04190E+01
SM_tt_threshold.mb => 4.20000E+00
SM_tt_threshold.alphas => 1.18000E-01
SM_tt_threshold.alpha_em_i => 1.25924E+02
SM_tt_threshold.m1S => 1.72000E+02
phs_t_channel = 0
SM_tt_threshold.nrqcd_order => 1.00000E+00
SM_tt_threshold.sh => 1.00000E+00
SM_tt_threshold.sf => 1.00000E+00
SM_tt_threshold.Vtb => 1.00000E+00
SM_tt_threshold.FF => 1.00000E+00
SM_tt_threshold.mpole_fixed => 1.00000E+00
SM_tt_threshold.offshell_strategy => 4.00000E+00
SM_tt_threshold.me => 0.00000E+00
sqrts = 3.50000E+02
[user variable] num_diff = 1.00000E-03
seed = 0
$restrictions = "3+5~t && 4+6~tbar"
| Process library 'user_prc_threshold_1_lib': recorded process 'user_prc_threshold_1_p1'
| Integrate: current process library needs compilation
| Process library 'user_prc_threshold_1_lib': compiling ...
| Process library 'user_prc_threshold_1_lib': writing makefile
| Process library 'user_prc_threshold_1_lib': removing old files
| Process library 'user_prc_threshold_1_lib': writing driver
| Process library 'user_prc_threshold_1_lib': creating source code
| Process library 'user_prc_threshold_1_lib': compiling sources
| Process library 'user_prc_threshold_1_lib': linking
| Process library 'user_prc_threshold_1_lib': loading
| Process library 'user_prc_threshold_1_lib': ... success.
| Integrate: compilation done
| RNG: Initializing TAO random-number generator
| RNG: Setting seed for random-number generator to 0
| Initializing integration for process user_prc_threshold_1_p1:
|
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
| Initialize e+e- => ttbar threshold resummation:
| Use analytic (LL) or TOPPIK (NLL) form factors for ttA/ttZ vector
| and axial vector couplings (S/P-wave) in the threshold region.
| Cf. threshold shapes from A. Hoang et al.: [arXiv:hep-ph/0107144],
| [arXiv:1309.6323].
| Numerical NLL solutions calculated with TOPPIK [arXiv:hep-ph/9904468]
| by M. Jezabek, T. Teubner.
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
|
| Scanning from 350.000 GeV to 350.000 GeV in steps of 0.000 GeV
| 100.0%
| Beam structure: [any particles]
| Beam data (collision):
| e+ (mass = 0.0000000E+00 GeV)
| e- (mass = 0.0000000E+00 GeV)
| sqrts = 3.500000000000E+02 GeV
| Phase space: generating configuration ...
| Phase space: ... success.
| Phase space: writing configuration file 'user_prc_threshold_1_p1.i1.phs'
| ------------------------------------------------------------------------
| Process [scattering]: 'user_prc_threshold_1_p1'
| Library name = 'user_prc_threshold_1_lib'
| Process index = 1
| Process components:
| 1: 'user_prc_threshold_1_p1_i1': e+, e- => W+, W-, b, bbar [omega]
| ------------------------------------------------------------------------
| Phase space: 15 channels, 8 dimensions
| Phase space: found 15 channels, collected in 6 groves.
-| Phase space: Using 15 equivalences between channels.
+| Phase space: no equivalences between channels used.
| Phase space: wood
Warning: No cuts have been defined.
| Starting integration for process 'user_prc_threshold_1_p1'
| Integrate: iterations = 1:200
| Integrator: 6 chains, 15 channels, 8 dimensions
-| Integrator: Using VAMP channel equivalences
| Integrator: 200 initial calls, 20 bins, stratified = T
| Integrator: VAMP
|=============================================================================|
| It Calls Integral[fb] Error[fb] Err[%] Acc Eff[%] Chi2 N[It] |
|=============================================================================|
1 195 7.811E+02 1.52E+02 19.42 2.71 28.7
|-----------------------------------------------------------------------------|
1 195 7.811E+02 1.52E+02 19.42 2.71 28.7
|=============================================================================|
seed = 0
| Process library 'user_prc_threshold_1_lib': unloading
| Process library 'user_prc_threshold_1_lib': open
| Process library 'user_prc_threshold_1_lib': recorded process 'user_prc_threshold_1_p2'
| Integrate: current process library needs compilation
| Process library 'user_prc_threshold_1_lib': compiling ...
| Process library 'user_prc_threshold_1_lib': writing makefile
| Process library 'user_prc_threshold_1_lib': removing old files
| Process library 'user_prc_threshold_1_lib': writing driver
| Process library 'user_prc_threshold_1_lib': creating source code
| Process library 'user_prc_threshold_1_lib': compiling sources
| Process library 'user_prc_threshold_1_lib': linking
| Process library 'user_prc_threshold_1_lib': loading
| Process library 'user_prc_threshold_1_lib': ... success.
| Integrate: compilation done
| RNG: Initializing TAO random-number generator
| RNG: Setting seed for random-number generator to 0
| Initializing integration for process user_prc_threshold_1_p2:
|
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
| Initialize e+e- => ttbar threshold resummation:
| Use analytic (LL) or TOPPIK (NLL) form factors for ttA/ttZ vector
| and axial vector couplings (S/P-wave) in the threshold region.
| Cf. threshold shapes from A. Hoang et al.: [arXiv:hep-ph/0107144],
| [arXiv:1309.6323].
| Numerical NLL solutions calculated with TOPPIK [arXiv:hep-ph/9904468]
| by M. Jezabek, T. Teubner.
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
|
| Opening grid file: SM_tt_threshold.grid
| Threshold setup unchanged: reusing existing threshold grid.
| Beam structure: [any particles]
| Beam data (collision):
| e+ (mass = 0.0000000E+00 GeV)
| e- (mass = 0.0000000E+00 GeV)
| sqrts = 3.500000000000E+02 GeV
| Phase space: generating configuration ...
| Phase space: ... success.
| Phase space: writing configuration file 'user_prc_threshold_1_p2.i1.phs'
| ------------------------------------------------------------------------
| Process [scattering]: 'user_prc_threshold_1_p2'
| Library name = 'user_prc_threshold_1_lib'
| Process index = 2
| Process components:
| 1: 'user_prc_threshold_1_p2_i1': e+, e- => t, tbar [omega]
| ------------------------------------------------------------------------
| Phase space: 1 channels, 2 dimensions
| Phase space: found 1 channel, collected in 1 grove.
-| Phase space: Using 1 equivalence between channels.
+| Phase space: no equivalences between channels used.
| Phase space: wood
Warning: No cuts have been defined.
| Starting integration for process 'user_prc_threshold_1_p2'
| Integrate: iterations = 1:200
| Integrator: 1 chains, 1 channels, 2 dimensions
-| Integrator: Using VAMP channel equivalences
| Integrator: 200 initial calls, 20 bins, stratified = T
| Integrator: VAMP
|=============================================================================|
| It Calls Integral[fb] Error[fb] Err[%] Acc Eff[%] Chi2 N[It] |
|=============================================================================|
1 200 5.568E+02 4.28E-01 0.08 0.01 80.9
|-----------------------------------------------------------------------------|
1 200 5.568E+02 4.28E-01 0.08 0.01 80.9
|=============================================================================|
seed = 0
$method = "threshold"
| Process library 'user_prc_threshold_1_lib': unloading
| Process library 'user_prc_threshold_1_lib': open
| Process library 'user_prc_threshold_1_lib': recorded process 'user_prc_threshold_1_p5'
| Integrate: current process library needs compilation
| Process library 'user_prc_threshold_1_lib': compiling ...
| Process library 'user_prc_threshold_1_lib': writing makefile
| Process library 'user_prc_threshold_1_lib': removing old files
| Process library 'user_prc_threshold_1_lib': writing driver
| Process library 'user_prc_threshold_1_lib': creating source code
| Process library 'user_prc_threshold_1_lib': compiling sources
| Process library 'user_prc_threshold_1_lib': linking
| Process library 'user_prc_threshold_1_lib': loading
| Loaded extra threshold functions
| Process library 'user_prc_threshold_1_lib': ... success.
| Integrate: compilation done
| RNG: Initializing TAO random-number generator
| RNG: Setting seed for random-number generator to 0
| Initializing integration for process user_prc_threshold_1_p5:
|
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
| Initialize e+e- => ttbar threshold resummation:
| Use analytic (LL) or TOPPIK (NLL) form factors for ttA/ttZ vector
| and axial vector couplings (S/P-wave) in the threshold region.
| Cf. threshold shapes from A. Hoang et al.: [arXiv:hep-ph/0107144],
| [arXiv:1309.6323].
| Numerical NLL solutions calculated with TOPPIK [arXiv:hep-ph/9904468]
| by M. Jezabek, T. Teubner.
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
|
| Opening grid file: SM_tt_threshold.grid
| Threshold setup unchanged: reusing existing threshold grid.
| Beam structure: [any particles]
| Beam data (collision):
| e+ (mass = 0.0000000E+00 GeV)
| e- (mass = 0.0000000E+00 GeV)
| sqrts = 3.500000000000E+02 GeV
| Phase space: generating configuration ...
| Phase space: ... success.
| Phase space: writing configuration file 'user_prc_threshold_1_p5.i1.phs'
| ------------------------------------------------------------------------
| Process [scattering]: 'user_prc_threshold_1_p5'
| Library name = 'user_prc_threshold_1_lib'
| Process index = 3
| Process components:
| 1: 'user_prc_threshold_1_p5_i1': e+, e- => t, tbar [threshold]
| ------------------------------------------------------------------------
| Phase space: 1 channels, 2 dimensions
| Phase space: found 1 channel, collected in 1 grove.
-| Phase space: Using 1 equivalence between channels.
+| Phase space: no equivalences between channels used.
| Phase space: wood
Warning: No cuts have been defined.
| Starting integration for process 'user_prc_threshold_1_p5'
| Integrate: iterations = 1:200
| Integrator: 1 chains, 1 channels, 2 dimensions
-| Integrator: Using VAMP channel equivalences
| Integrator: 200 initial calls, 20 bins, stratified = T
| Integrator: VAMP
|=============================================================================|
| It Calls Integral[fb] Error[fb] Err[%] Acc Eff[%] Chi2 N[It] |
|=============================================================================|
1 200 5.568E+02 4.28E-01 0.08 0.01 80.9
|-----------------------------------------------------------------------------|
1 200 5.568E+02 4.28E-01 0.08 0.01 80.9
|=============================================================================|
tolerance = 1.00000E-04
| expect: success
seed = 0
$born_me_method = "threshold"
$loop_me_method = "threshold"
$correlation_me_method = "threshold"
$real_tree_me_method = "threshold"
$restrictions = "3+5~t && 4+6~tbar"
-Warning: You have not disabled VAMP equivalences.
- Note that they are automatically switched off
- for NLO calculations.
| Process library 'user_prc_threshold_1_lib': unloading
| Process library 'user_prc_threshold_1_lib': open
| Process library 'user_prc_threshold_1_lib': recorded process 'user_prc_threshold_1_p6'
| Integrate: current process library needs compilation
| Process library 'user_prc_threshold_1_lib': compiling ...
| Process library 'user_prc_threshold_1_lib': writing makefile
| Process library 'user_prc_threshold_1_lib': removing old files
| Process library 'user_prc_threshold_1_lib': writing driver
| Process library 'user_prc_threshold_1_lib': creating source code
| Process library 'user_prc_threshold_1_lib': compiling sources
| Process library 'user_prc_threshold_1_lib': linking
| Process library 'user_prc_threshold_1_lib': loading
| Loaded extra threshold functions
| Loaded extra threshold functions
| Loaded extra threshold functions
| Loaded extra threshold functions
| Process library 'user_prc_threshold_1_lib': ... success.
| Integrate: compilation done
| RNG: Initializing TAO random-number generator
| RNG: Setting seed for random-number generator to 0
| Initializing integration for process user_prc_threshold_1_p6:
|
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
| Initialize e+e- => ttbar threshold resummation:
| Use analytic (LL) or TOPPIK (NLL) form factors for ttA/ttZ vector
| and axial vector couplings (S/P-wave) in the threshold region.
| Cf. threshold shapes from A. Hoang et al.: [arXiv:hep-ph/0107144],
| [arXiv:1309.6323].
| Numerical NLL solutions calculated with TOPPIK [arXiv:hep-ph/9904468]
| by M. Jezabek, T. Teubner.
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
|
| Opening grid file: SM_tt_threshold.grid
| Threshold setup unchanged: reusing existing threshold grid.
|
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
| Initialize e+e- => ttbar threshold resummation:
| Use analytic (LL) or TOPPIK (NLL) form factors for ttA/ttZ vector
| and axial vector couplings (S/P-wave) in the threshold region.
| Cf. threshold shapes from A. Hoang et al.: [arXiv:hep-ph/0107144],
| [arXiv:1309.6323].
| Numerical NLL solutions calculated with TOPPIK [arXiv:hep-ph/9904468]
| by M. Jezabek, T. Teubner.
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
|
| Opening grid file: SM_tt_threshold.grid
| Threshold setup unchanged: reusing existing threshold grid.
|
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
| Initialize e+e- => ttbar threshold resummation:
| Use analytic (LL) or TOPPIK (NLL) form factors for ttA/ttZ vector
| and axial vector couplings (S/P-wave) in the threshold region.
| Cf. threshold shapes from A. Hoang et al.: [arXiv:hep-ph/0107144],
| [arXiv:1309.6323].
| Numerical NLL solutions calculated with TOPPIK [arXiv:hep-ph/9904468]
| by M. Jezabek, T. Teubner.
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
|
| Opening grid file: SM_tt_threshold.grid
| Threshold setup unchanged: reusing existing threshold grid.
| Beam structure: [any particles]
| Beam data (collision):
| e+ (mass = 0.0000000E+00 GeV)
| e- (mass = 0.0000000E+00 GeV)
| sqrts = 3.500000000000E+02 GeV
| Phase space: generating configuration ...
| Phase space: ... success.
| Phase space: writing configuration file 'user_prc_threshold_1_p6.i1.phs'
| Phase space: generating configuration ...
| Phase space: ... success.
| Phase space: writing configuration file 'user_prc_threshold_1_p6.i3.phs'
| ------------------------------------------------------------------------
| Process [scattering]: 'user_prc_threshold_1_p6'
| Library name = 'user_prc_threshold_1_lib'
| Process index = 4
| Process components:
| 1: 'user_prc_threshold_1_p6_i1': e+, e- => W+, W-, b, bbar [threshold]
| 2: 'user_prc_threshold_1_p6_i2': e+, e- => W+, W-, b, bbar, gl [inactive], [real]
| 3: 'user_prc_threshold_1_p6_i3': e+, e- => W+, W-, b, bbar [inactive], [virtual]
| 4: 'user_prc_threshold_1_p6_i4': e+, e- => W+, W-, b, bbar [inactive], [subtraction]
| ------------------------------------------------------------------------
| Phase space: 15 channels, 8 dimensions
| Phase space: found 15 channels, collected in 6 groves.
-| Phase space: Using 15 equivalences between channels.
+| Phase space: no equivalences between channels used.
| Phase space: wood
| Phase space: 15 channels, 11 dimensions
| Phase space: found 15 channels, collected in 6 groves.
| Phase space: no equivalences between channels used.
| Phase space: wood
| Phase space: 15 channels, 8 dimensions
| Phase space: found 15 channels, collected in 6 groves.
-| Phase space: Using 15 equivalences between channels.
+| Phase space: no equivalences between channels used.
| Phase space: wood
Warning: No cuts have been defined.
| Starting integration for process 'user_prc_threshold_1_p6' part 'born'
| Integrate: iterations = 1:200
| Integrator: 6 chains, 15 channels, 8 dimensions
| Integrator: 200 initial calls, 20 bins, stratified = T
| Integrator: VAMP
|=============================================================================|
| It Calls Integral[fb] Error[fb] Err[%] Acc Eff[%] Chi2 N[It] |
|=============================================================================|
1 195 7.811E+02 1.52E+02 19.42 2.71 28.7
|-----------------------------------------------------------------------------|
1 195 7.811E+02 1.52E+02 19.42 2.71 28.7
|=============================================================================|
| Integrate: sum of all components
|=============================================================================|
| It Calls Integral[fb] Error[fb] Err[%] Acc Eff[%] Chi2 N[It] |
|=============================================================================|
1 0 7.811E+02 1.52E+02 19.42 0.00 28.7
| NLO Correction: [O(alpha_s+1)/O(alpha_s)]
| ( 0.0000 +- 0.00000 ) %
|=============================================================================|
tolerance = 1.00000E-04
| expect: success
$method = "threshold"
seed = 0
| Process library 'user_prc_threshold_1_lib': unloading
| Process library 'user_prc_threshold_1_lib': open
| Process library 'user_prc_threshold_1_lib': recorded process 'user_prc_threshold_1_sig_thr'
SM_tt_threshold.offshell_strategy => 0.00000E+00
| Integrate: current process library needs compilation
| Process library 'user_prc_threshold_1_lib': compiling ...
| Process library 'user_prc_threshold_1_lib': writing makefile
| Process library 'user_prc_threshold_1_lib': removing old files
| Process library 'user_prc_threshold_1_lib': writing driver
| Process library 'user_prc_threshold_1_lib': creating source code
| Process library 'user_prc_threshold_1_lib': compiling sources
| Process library 'user_prc_threshold_1_lib': linking
| Process library 'user_prc_threshold_1_lib': loading
| Loaded extra threshold functions
| Loaded extra threshold functions
| Loaded extra threshold functions
| Loaded extra threshold functions
| Loaded extra threshold functions
| Process library 'user_prc_threshold_1_lib': ... success.
| Integrate: compilation done
| RNG: Initializing TAO random-number generator
| RNG: Setting seed for random-number generator to 0
| Initializing integration for process user_prc_threshold_1_sig_thr:
|
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
| Initialize e+e- => ttbar threshold resummation:
| Use analytic (LL) or TOPPIK (NLL) form factors for ttA/ttZ vector
| and axial vector couplings (S/P-wave) in the threshold region.
| Cf. threshold shapes from A. Hoang et al.: [arXiv:hep-ph/0107144],
| [arXiv:1309.6323].
| Numerical NLL solutions calculated with TOPPIK [arXiv:hep-ph/9904468]
| by M. Jezabek, T. Teubner.
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
|
| Opening grid file: SM_tt_threshold.grid
| Threshold setup unchanged: reusing existing threshold grid.
| Beam structure: [any particles]
| Beam data (collision):
| e+ (mass = 0.0000000E+00 GeV)
| e- (mass = 0.0000000E+00 GeV)
| sqrts = 3.500000000000E+02 GeV
| Phase space: generating configuration ...
| Phase space: ... success.
| Phase space: writing configuration file 'user_prc_threshold_1_sig_thr.i1.phs'
| ------------------------------------------------------------------------
| Process [scattering]: 'user_prc_threshold_1_sig_thr'
| Library name = 'user_prc_threshold_1_lib'
| Process index = 5
| Process components:
| 1: 'user_prc_threshold_1_sig_thr_i1': e+, e- => W+, W-, b, bbar [threshold]
| ------------------------------------------------------------------------
| Phase space: 15 channels, 8 dimensions
| Phase space: found 15 channels, collected in 6 groves.
-| Phase space: Using 15 equivalences between channels.
+| Phase space: no equivalences between channels used.
| Phase space: wood
Warning: No cuts have been defined.
| Starting integration for process 'user_prc_threshold_1_sig_thr'
| Integrate: iterations = 1:200
| Integrator: 6 chains, 15 channels, 8 dimensions
-| Integrator: Using VAMP channel equivalences
| Integrator: 200 initial calls, 20 bins, stratified = T
| Integrator: VAMP
|=============================================================================|
| It Calls Integral[fb] Error[fb] Err[%] Acc Eff[%] Chi2 N[It] |
|=============================================================================|
1 195 7.811E+02 1.52E+02 19.42 2.71 28.7
|-----------------------------------------------------------------------------|
1 195 7.811E+02 1.52E+02 19.42 2.71 28.7
|=============================================================================|
tolerance = 1.00000E-03
| expect: success
seed = 0
| Process library 'user_prc_threshold_1_lib': unloading
| Process library 'user_prc_threshold_1_lib': open
| Process library 'user_prc_threshold_1_lib': recorded process 'user_prc_threshold_1_factorized'
SM_tt_threshold.offshell_strategy => 2.00000E+00
| Integrate: current process library needs compilation
| Process library 'user_prc_threshold_1_lib': compiling ...
| Process library 'user_prc_threshold_1_lib': writing makefile
| Process library 'user_prc_threshold_1_lib': removing old files
| Process library 'user_prc_threshold_1_lib': writing driver
| Process library 'user_prc_threshold_1_lib': creating source code
| Process library 'user_prc_threshold_1_lib': compiling sources
| Process library 'user_prc_threshold_1_lib': linking
| Process library 'user_prc_threshold_1_lib': loading
| Loaded extra threshold functions
| Loaded extra threshold functions
| Loaded extra threshold functions
| Loaded extra threshold functions
| Loaded extra threshold functions
| Loaded extra threshold functions
| Process library 'user_prc_threshold_1_lib': ... success.
| Integrate: compilation done
| RNG: Initializing TAO random-number generator
| RNG: Setting seed for random-number generator to 0
| Initializing integration for process user_prc_threshold_1_factorized:
|
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
| Initialize e+e- => ttbar threshold resummation:
| Use analytic (LL) or TOPPIK (NLL) form factors for ttA/ttZ vector
| and axial vector couplings (S/P-wave) in the threshold region.
| Cf. threshold shapes from A. Hoang et al.: [arXiv:hep-ph/0107144],
| [arXiv:1309.6323].
| Numerical NLL solutions calculated with TOPPIK [arXiv:hep-ph/9904468]
| by M. Jezabek, T. Teubner.
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
|
| Opening grid file: SM_tt_threshold.grid
| Threshold setup unchanged: reusing existing threshold grid.
| Beam structure: [any particles]
| Beam data (collision):
| e+ (mass = 0.0000000E+00 GeV)
| e- (mass = 0.0000000E+00 GeV)
| sqrts = 3.500000000000E+02 GeV
| Phase space: generating configuration ...
| Phase space: ... success.
| Phase space: writing configuration file 'user_prc_threshold_1_factorized.i1.phs'
| ------------------------------------------------------------------------
| Process [scattering]: 'user_prc_threshold_1_factorized'
| Library name = 'user_prc_threshold_1_lib'
| Process index = 6
| Process components:
| 1: 'user_prc_threshold_1_factorized_i1': e+, e- => W+, W-, b, bbar [threshold]
| ------------------------------------------------------------------------
| Phase space: 15 channels, 8 dimensions
| Phase space: found 15 channels, collected in 6 groves.
-| Phase space: Using 15 equivalences between channels.
+| Phase space: no equivalences between channels used.
| Phase space: wood
Warning: No cuts have been defined.
| Starting integration for process 'user_prc_threshold_1_factorized'
| Integrate: iterations = 1:200
| Integrator: 6 chains, 15 channels, 8 dimensions
-| Integrator: Using VAMP channel equivalences
| Integrator: 200 initial calls, 20 bins, stratified = T
| Integrator: VAMP
|=============================================================================|
| It Calls Integral[fb] Error[fb] Err[%] Acc Eff[%] Chi2 N[It] |
|=============================================================================|
1 195 7.681E+02 1.49E+02 19.44 2.72 28.8
|-----------------------------------------------------------------------------|
1 195 7.681E+02 1.49E+02 19.44 2.72 28.8
|=============================================================================|
tolerance = 2.79506E+01
| expect: success
| Summary of value checks:
| Failures: 0 / Total: 4
-| There were no errors and 7 warning(s).
+| There were no errors and 6 warning(s).
| WHIZARD run finished.
|=============================================================================|
Index: trunk/share/tests/functional_tests/ref-output/openloops_4.ref
===================================================================
--- trunk/share/tests/functional_tests/ref-output/openloops_4.ref (revision 8482)
+++ trunk/share/tests/functional_tests/ref-output/openloops_4.ref (revision 8483)
@@ -1,739 +1,722 @@
?openmp_logging = false
?vis_history = false
?integration_timer = false
?pacify = true
openmp_num_threads = 1
+?use_vamp_equivalences = false
?openloops_use_cms = false
SM.mW => 7.00000E+01
SM.mZ => 9.00000E+01
SM.GF => 1.50000E-05
SM.wZ => 1.00000E+00
SM.wW => 3.00000E+00
alpha_em 0.0130713
[user variable] alpha_em_inverse = 7.65037E+01
SM.mmu => 0.00000E+00
SM.me => 0.00000E+00
SM.mc => 0.00000E+00
SM.ms => 0.00000E+00
?alphas_is_fixed = true
?alphas_from_mz = false
?alphas_from_lambda_qcd = false
SM.alphas => 2.00000E-01
alpha_power = 2
alphas_power = 0
$loop_me_method = "openloops"
sqrts = 5.00000E+02
tolerance = 1.00000E-03
$born_me_method = "omega"
$real_tree_me_method = "omega"
$correlation_me_method = "omega"
-Warning: You have not disabled VAMP equivalences.
- Note that they are automatically switched off
- for NLO calculations.
| Process library 'openloops_4_lib': recorded process 'openloops_4_omomom'
seed = 0
| Integrate: current process library needs compilation
| Process library 'openloops_4_lib': compiling ...
| Process library 'openloops_4_lib': writing makefile
| Process library 'openloops_4_lib': removing old files
| Process library 'openloops_4_lib': writing driver
| Process library 'openloops_4_lib': creating source code
| Process library 'openloops_4_lib': compiling sources
| Process library 'openloops_4_lib': linking
| Process library 'openloops_4_lib': loading
| Process library 'openloops_4_lib': ... success.
| Integrate: compilation done
| RNG: Initializing TAO random-number generator
| RNG: Setting seed for random-number generator to 0
| Initializing integration for process openloops_4_omomom:
| Beam structure: [any particles]
| Beam data (collision):
| e+ (mass = 0.0000000E+00 GeV)
| e- (mass = 0.0000000E+00 GeV)
| sqrts = 5.000000000000E+02 GeV
| Phase space: generating configuration ...
| Phase space: ... success.
| Phase space: writing configuration file 'openloops_4_omomom.i1.phs'
| Phase space: generating configuration ...
| Phase space: ... success.
| Phase space: writing configuration file 'openloops_4_omomom.i3.phs'
| One-Loop-Provider: Using OpenLoops
| Loading library: [...]
| One-Loop-Provider: Using OpenLoops
| Loading library: [...]
| ------------------------------------------------------------------------
| Process [scattering]: 'openloops_4_omomom'
| Library name = 'openloops_4_lib'
| Process index = 1
| Process components:
| 1: 'openloops_4_omomom_i1': e+, e- => u, ubar [omega]
| 2: 'openloops_4_omomom_i2': e+, e- => u, ubar, gl [omega], [real]
| 3: 'openloops_4_omomom_i3': e+, e- => u, ubar [openloops], [virtual]
| 4: 'openloops_4_omomom_i4': e+, e- => u, ubar [inactive], [subtraction]
| ------------------------------------------------------------------------
| Phase space: 2 channels, 2 dimensions
| Phase space: found 2 channels, collected in 2 groves.
-| Phase space: Using 2 equivalences between channels.
+| Phase space: no equivalences between channels used.
| Phase space: wood
| Phase space: 2 channels, 5 dimensions
| Phase space: found 2 channels, collected in 2 groves.
| Phase space: no equivalences between channels used.
| Phase space: wood
| Phase space: 2 channels, 2 dimensions
| Phase space: found 2 channels, collected in 2 groves.
-| Phase space: Using 2 equivalences between channels.
+| Phase space: no equivalences between channels used.
| Phase space: wood
Warning: No cuts have been defined.
| Using user-defined general scale.
| Starting integration for process 'openloops_4_omomom' part 'born'
| Integrate: iterations = 1:100:"gw"
| Integrator: 2 chains, 2 channels, 2 dimensions
| Integrator: 100 initial calls, 20 bins, stratified = T
| Integrator: VAMP
|=============================================================================|
| It Calls Integral[fb] Error[fb] Err[%] Acc Eff[%] Chi2 N[It] |
|=============================================================================|
1 100 1.792E+03 1.08E+02 6.02 0.60 41.2
|-----------------------------------------------------------------------------|
1 100 1.792E+03 1.08E+02 6.02 0.60 41.2
|=============================================================================|
| Starting integration for process 'openloops_4_omomom' part 'real'
| Integrate: iterations = 1:100:"gw"
| Integrator: 2 chains, 2 channels, 5 dimensions
| Integrator: 100 initial calls, 20 bins, stratified = T
| Integrator: VAMP
|=============================================================================|
| It Calls Integral[fb] Error[fb] Err[%] Acc Eff[%] Chi2 N[It] |
|=============================================================================|
1 100 2.253E+02 2.07E+01 9.18 0.92 20.0
|-----------------------------------------------------------------------------|
1 100 2.253E+02 2.07E+01 9.18 0.92 20.0
|=============================================================================|
| Starting integration for process 'openloops_4_omomom' part 'virtual'
| Integrate: iterations = 1:100:"gw"
| Integrator: 2 chains, 2 channels, 2 dimensions
| Integrator: 100 initial calls, 20 bins, stratified = T
| Integrator: VAMP
|=============================================================================|
| It Calls Integral[fb] Error[fb] Err[%] Acc Eff[%] Chi2 N[It] |
|=============================================================================|
1 100 -1.152E+02 6.79E+00 5.89 0.59 39.6
|-----------------------------------------------------------------------------|
1 100 -1.152E+02 6.79E+00 5.89 0.59 39.6
|=============================================================================|
| Integrate: sum of all components
|=============================================================================|
| It Calls Integral[fb] Error[fb] Err[%] Acc Eff[%] Chi2 N[It] |
|=============================================================================|
1 0 1.902E+03 1.10E+02 5.79 0.00 34.7
| NLO Correction: [O(alpha_s+1)/O(alpha_s)]
| ( 6.1438 +- 1.27004 ) %
|=============================================================================|
integral(openloops_4_omomom) = 1.90204E+03
error(openloops_4_omomom) = 1.10105E+02
[user variable] reference_integral = 1.90204E+03
$born_me_method = "openloops"
$real_tree_me_method = "omega"
$correlation_me_method = "omega"
-Warning: You have not disabled VAMP equivalences.
- Note that they are automatically switched off
- for NLO calculations.
| Process library 'openloops_4_lib': unloading
| Process library 'openloops_4_lib': open
| Process library 'openloops_4_lib': recorded process 'openloops_4_olomom'
seed = 0
| Integrate: current process library needs compilation
| Process library 'openloops_4_lib': compiling ...
| Process library 'openloops_4_lib': writing makefile
| Process library 'openloops_4_lib': removing old files
| Process library 'openloops_4_lib': writing driver
| Process library 'openloops_4_lib': creating source code
| Process library 'openloops_4_lib': compiling sources
| Process library 'openloops_4_lib': linking
| Process library 'openloops_4_lib': loading
| Process library 'openloops_4_lib': ... success.
| Integrate: compilation done
| RNG: Initializing TAO random-number generator
| RNG: Setting seed for random-number generator to 0
| Initializing integration for process openloops_4_olomom:
| Beam structure: [any particles]
| Beam data (collision):
| e+ (mass = 0.0000000E+00 GeV)
| e- (mass = 0.0000000E+00 GeV)
| sqrts = 5.000000000000E+02 GeV
| Phase space: generating configuration ...
| Phase space: ... success.
| Phase space: writing configuration file 'openloops_4_olomom.i1.phs'
| Phase space: generating configuration ...
| Phase space: ... success.
| Phase space: writing configuration file 'openloops_4_olomom.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_4_olomom'
| Library name = 'openloops_4_lib'
| Process index = 2
| Process components:
| 1: 'openloops_4_olomom_i1': e+, e- => u, ubar [openloops]
| 2: 'openloops_4_olomom_i2': e+, e- => u, ubar, gl [omega], [real]
| 3: 'openloops_4_olomom_i3': e+, e- => u, ubar [openloops], [virtual]
| 4: 'openloops_4_olomom_i4': e+, e- => u, ubar [inactive], [subtraction]
| ------------------------------------------------------------------------
| Phase space: 2 channels, 2 dimensions
| Phase space: found 2 channels, collected in 2 groves.
-| Phase space: Using 2 equivalences between channels.
+| Phase space: no equivalences between channels used.
| Phase space: wood
| Phase space: 2 channels, 5 dimensions
| Phase space: found 2 channels, collected in 2 groves.
| Phase space: no equivalences between channels used.
| Phase space: wood
| Phase space: 2 channels, 2 dimensions
| Phase space: found 2 channels, collected in 2 groves.
-| Phase space: Using 2 equivalences between channels.
+| Phase space: no equivalences between channels used.
| Phase space: wood
Warning: No cuts have been defined.
| Using user-defined general scale.
| Starting integration for process 'openloops_4_olomom' part 'born'
| Integrate: iterations = 1:100:"gw"
| Integrator: 2 chains, 2 channels, 2 dimensions
| Integrator: 100 initial calls, 20 bins, stratified = T
| Integrator: VAMP
|=============================================================================|
| It Calls Integral[fb] Error[fb] Err[%] Acc Eff[%] Chi2 N[It] |
|=============================================================================|
1 100 1.792E+03 1.08E+02 6.02 0.60 41.2
|-----------------------------------------------------------------------------|
1 100 1.792E+03 1.08E+02 6.02 0.60 41.2
|=============================================================================|
| Starting integration for process 'openloops_4_olomom' part 'real'
| Integrate: iterations = 1:100:"gw"
| Integrator: 2 chains, 2 channels, 5 dimensions
| Integrator: 100 initial calls, 20 bins, stratified = T
| Integrator: VAMP
|=============================================================================|
| It Calls Integral[fb] Error[fb] Err[%] Acc Eff[%] Chi2 N[It] |
|=============================================================================|
1 100 2.253E+02 2.07E+01 9.18 0.92 20.0
|-----------------------------------------------------------------------------|
1 100 2.253E+02 2.07E+01 9.18 0.92 20.0
|=============================================================================|
| Starting integration for process 'openloops_4_olomom' part 'virtual'
| Integrate: iterations = 1:100:"gw"
| Integrator: 2 chains, 2 channels, 2 dimensions
| Integrator: 100 initial calls, 20 bins, stratified = T
| Integrator: VAMP
|=============================================================================|
| It Calls Integral[fb] Error[fb] Err[%] Acc Eff[%] Chi2 N[It] |
|=============================================================================|
1 100 -1.152E+02 6.79E+00 5.89 0.59 39.6
|-----------------------------------------------------------------------------|
1 100 -1.152E+02 6.79E+00 5.89 0.59 39.6
|=============================================================================|
| Integrate: sum of all components
|=============================================================================|
| It Calls Integral[fb] Error[fb] Err[%] Acc Eff[%] Chi2 N[It] |
|=============================================================================|
1 0 1.902E+03 1.10E+02 5.79 0.00 34.7
| NLO Correction: [O(alpha_s+1)/O(alpha_s)]
| ( 6.1438 +- 1.27004 ) %
|=============================================================================|
integral(openloops_4_olomom) = 1.90204E+03
error(openloops_4_olomom) = 1.10105E+02
| expect: success
$born_me_method = "omega"
$real_tree_me_method = "openloops"
$correlation_me_method = "omega"
-Warning: You have not disabled VAMP equivalences.
- Note that they are automatically switched off
- for NLO calculations.
| Process library 'openloops_4_lib': unloading
| Process library 'openloops_4_lib': open
| Process library 'openloops_4_lib': recorded process 'openloops_4_omolom'
seed = 0
| Integrate: current process library needs compilation
| Process library 'openloops_4_lib': compiling ...
| Process library 'openloops_4_lib': writing makefile
| Process library 'openloops_4_lib': removing old files
| Process library 'openloops_4_lib': writing driver
| Process library 'openloops_4_lib': creating source code
| Process library 'openloops_4_lib': compiling sources
| Process library 'openloops_4_lib': linking
| Process library 'openloops_4_lib': loading
| Process library 'openloops_4_lib': ... success.
| Integrate: compilation done
| RNG: Initializing TAO random-number generator
| RNG: Setting seed for random-number generator to 0
| Initializing integration for process openloops_4_omolom:
| Beam structure: [any particles]
| Beam data (collision):
| e+ (mass = 0.0000000E+00 GeV)
| e- (mass = 0.0000000E+00 GeV)
| sqrts = 5.000000000000E+02 GeV
| Phase space: generating configuration ...
| Phase space: ... success.
| Phase space: writing configuration file 'openloops_4_omolom.i1.phs'
| Phase space: generating configuration ...
| Phase space: ... success.
| Phase space: writing configuration file 'openloops_4_omolom.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_4_omolom'
| Library name = 'openloops_4_lib'
| Process index = 3
| Process components:
| 1: 'openloops_4_omolom_i1': e+, e- => u, ubar [omega]
| 2: 'openloops_4_omolom_i2': e+, e- => u, ubar, gl [openloops], [real]
| 3: 'openloops_4_omolom_i3': e+, e- => u, ubar [openloops], [virtual]
| 4: 'openloops_4_omolom_i4': e+, e- => u, ubar [inactive], [subtraction]
| ------------------------------------------------------------------------
| Phase space: 2 channels, 2 dimensions
| Phase space: found 2 channels, collected in 2 groves.
-| Phase space: Using 2 equivalences between channels.
+| Phase space: no equivalences between channels used.
| Phase space: wood
| Phase space: 2 channels, 5 dimensions
| Phase space: found 2 channels, collected in 2 groves.
| Phase space: no equivalences between channels used.
| Phase space: wood
| Phase space: 2 channels, 2 dimensions
| Phase space: found 2 channels, collected in 2 groves.
-| Phase space: Using 2 equivalences between channels.
+| Phase space: no equivalences between channels used.
| Phase space: wood
Warning: No cuts have been defined.
| Using user-defined general scale.
| Starting integration for process 'openloops_4_omolom' part 'born'
| Integrate: iterations = 1:100:"gw"
| Integrator: 2 chains, 2 channels, 2 dimensions
| Integrator: 100 initial calls, 20 bins, stratified = T
| Integrator: VAMP
|=============================================================================|
| It Calls Integral[fb] Error[fb] Err[%] Acc Eff[%] Chi2 N[It] |
|=============================================================================|
1 100 1.792E+03 1.08E+02 6.02 0.60 41.2
|-----------------------------------------------------------------------------|
1 100 1.792E+03 1.08E+02 6.02 0.60 41.2
|=============================================================================|
| Starting integration for process 'openloops_4_omolom' part 'real'
| Integrate: iterations = 1:100:"gw"
| Integrator: 2 chains, 2 channels, 5 dimensions
| Integrator: 100 initial calls, 20 bins, stratified = T
| Integrator: VAMP
|=============================================================================|
| It Calls Integral[fb] Error[fb] Err[%] Acc Eff[%] Chi2 N[It] |
|=============================================================================|
1 100 2.253E+02 2.07E+01 9.18 0.92 20.0
|-----------------------------------------------------------------------------|
1 100 2.253E+02 2.07E+01 9.18 0.92 20.0
|=============================================================================|
| Starting integration for process 'openloops_4_omolom' part 'virtual'
| Integrate: iterations = 1:100:"gw"
| Integrator: 2 chains, 2 channels, 2 dimensions
| Integrator: 100 initial calls, 20 bins, stratified = T
| Integrator: VAMP
|=============================================================================|
| It Calls Integral[fb] Error[fb] Err[%] Acc Eff[%] Chi2 N[It] |
|=============================================================================|
1 100 -1.152E+02 6.79E+00 5.89 0.59 39.6
|-----------------------------------------------------------------------------|
1 100 -1.152E+02 6.79E+00 5.89 0.59 39.6
|=============================================================================|
| Integrate: sum of all components
|=============================================================================|
| It Calls Integral[fb] Error[fb] Err[%] Acc Eff[%] Chi2 N[It] |
|=============================================================================|
1 0 1.902E+03 1.10E+02 5.79 0.00 34.7
| NLO Correction: [O(alpha_s+1)/O(alpha_s)]
| ( 6.1438 +- 1.27004 ) %
|=============================================================================|
integral(openloops_4_omolom) = 1.90204E+03
error(openloops_4_omolom) = 1.10105E+02
| expect: success
$born_me_method = "omega"
$real_tree_me_method = "omega"
$correlation_me_method = "openloops"
-Warning: You have not disabled VAMP equivalences.
- Note that they are automatically switched off
- for NLO calculations.
| Process library 'openloops_4_lib': unloading
| Process library 'openloops_4_lib': open
| Process library 'openloops_4_lib': recorded process 'openloops_4_omomol'
seed = 0
| Integrate: current process library needs compilation
| Process library 'openloops_4_lib': compiling ...
| Process library 'openloops_4_lib': writing makefile
| Process library 'openloops_4_lib': removing old files
| Process library 'openloops_4_lib': writing driver
| Process library 'openloops_4_lib': creating source code
| Process library 'openloops_4_lib': compiling sources
| Process library 'openloops_4_lib': linking
| Process library 'openloops_4_lib': loading
| Process library 'openloops_4_lib': ... success.
| Integrate: compilation done
| RNG: Initializing TAO random-number generator
| RNG: Setting seed for random-number generator to 0
| Initializing integration for process openloops_4_omomol:
| Beam structure: [any particles]
| Beam data (collision):
| e+ (mass = 0.0000000E+00 GeV)
| e- (mass = 0.0000000E+00 GeV)
| sqrts = 5.000000000000E+02 GeV
| Phase space: generating configuration ...
| Phase space: ... success.
| Phase space: writing configuration file 'openloops_4_omomol.i1.phs'
| Phase space: generating configuration ...
| Phase space: ... success.
| Phase space: writing configuration file 'openloops_4_omomol.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_4_omomol'
| Library name = 'openloops_4_lib'
| Process index = 4
| Process components:
| 1: 'openloops_4_omomol_i1': e+, e- => u, ubar [omega]
| 2: 'openloops_4_omomol_i2': e+, e- => u, ubar, gl [omega], [real]
| 3: 'openloops_4_omomol_i3': e+, e- => u, ubar [openloops], [virtual]
| 4: 'openloops_4_omomol_i4': e+, e- => u, ubar [inactive], [subtraction]
| ------------------------------------------------------------------------
| Phase space: 2 channels, 2 dimensions
| Phase space: found 2 channels, collected in 2 groves.
-| Phase space: Using 2 equivalences between channels.
+| Phase space: no equivalences between channels used.
| Phase space: wood
| Phase space: 2 channels, 5 dimensions
| Phase space: found 2 channels, collected in 2 groves.
| Phase space: no equivalences between channels used.
| Phase space: wood
| Phase space: 2 channels, 2 dimensions
| Phase space: found 2 channels, collected in 2 groves.
-| Phase space: Using 2 equivalences between channels.
+| Phase space: no equivalences between channels used.
| Phase space: wood
Warning: No cuts have been defined.
| Using user-defined general scale.
| Starting integration for process 'openloops_4_omomol' part 'born'
| Integrate: iterations = 1:100:"gw"
| Integrator: 2 chains, 2 channels, 2 dimensions
| Integrator: 100 initial calls, 20 bins, stratified = T
| Integrator: VAMP
|=============================================================================|
| It Calls Integral[fb] Error[fb] Err[%] Acc Eff[%] Chi2 N[It] |
|=============================================================================|
1 100 1.792E+03 1.08E+02 6.02 0.60 41.2
|-----------------------------------------------------------------------------|
1 100 1.792E+03 1.08E+02 6.02 0.60 41.2
|=============================================================================|
| Starting integration for process 'openloops_4_omomol' part 'real'
| Integrate: iterations = 1:100:"gw"
| Integrator: 2 chains, 2 channels, 5 dimensions
| Integrator: 100 initial calls, 20 bins, stratified = T
| Integrator: VAMP
|=============================================================================|
| It Calls Integral[fb] Error[fb] Err[%] Acc Eff[%] Chi2 N[It] |
|=============================================================================|
1 100 2.253E+02 2.07E+01 9.18 0.92 20.0
|-----------------------------------------------------------------------------|
1 100 2.253E+02 2.07E+01 9.18 0.92 20.0
|=============================================================================|
| Starting integration for process 'openloops_4_omomol' part 'virtual'
| Integrate: iterations = 1:100:"gw"
| Integrator: 2 chains, 2 channels, 2 dimensions
| Integrator: 100 initial calls, 20 bins, stratified = T
| Integrator: VAMP
|=============================================================================|
| It Calls Integral[fb] Error[fb] Err[%] Acc Eff[%] Chi2 N[It] |
|=============================================================================|
1 100 -1.152E+02 6.79E+00 5.89 0.59 39.6
|-----------------------------------------------------------------------------|
1 100 -1.152E+02 6.79E+00 5.89 0.59 39.6
|=============================================================================|
| Integrate: sum of all components
|=============================================================================|
| It Calls Integral[fb] Error[fb] Err[%] Acc Eff[%] Chi2 N[It] |
|=============================================================================|
1 0 1.902E+03 1.10E+02 5.79 0.00 34.7
| NLO Correction: [O(alpha_s+1)/O(alpha_s)]
| ( 6.1438 +- 1.27004 ) %
|=============================================================================|
integral(openloops_4_omomol) = 1.90204E+03
error(openloops_4_omomol) = 1.10105E+02
| expect: success
$born_me_method = "openloops"
$real_tree_me_method = "openloops"
$correlation_me_method = "openloops"
-Warning: You have not disabled VAMP equivalences.
- Note that they are automatically switched off
- for NLO calculations.
| Process library 'openloops_4_lib': unloading
| Process library 'openloops_4_lib': open
| Process library 'openloops_4_lib': recorded process 'openloops_4_ololol'
seed = 0
| Integrate: current process library needs compilation
| Process library 'openloops_4_lib': compiling ...
| Process library 'openloops_4_lib': writing makefile
| Process library 'openloops_4_lib': removing old files
| Process library 'openloops_4_lib': writing driver
| Process library 'openloops_4_lib': creating source code
| Process library 'openloops_4_lib': compiling sources
| Process library 'openloops_4_lib': linking
| Process library 'openloops_4_lib': loading
| Process library 'openloops_4_lib': ... success.
| Integrate: compilation done
| RNG: Initializing TAO random-number generator
| RNG: Setting seed for random-number generator to 0
| Initializing integration for process openloops_4_ololol:
| Beam structure: [any particles]
| Beam data (collision):
| e+ (mass = 0.0000000E+00 GeV)
| e- (mass = 0.0000000E+00 GeV)
| sqrts = 5.000000000000E+02 GeV
| Phase space: generating configuration ...
| Phase space: ... success.
| Phase space: writing configuration file 'openloops_4_ololol.i1.phs'
| Phase space: generating configuration ...
| Phase space: ... success.
| Phase space: writing configuration file 'openloops_4_ololol.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: [...]
| 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_4_ololol'
| Library name = 'openloops_4_lib'
| Process index = 5
| Process components:
| 1: 'openloops_4_ololol_i1': e+, e- => u, ubar [openloops]
| 2: 'openloops_4_ololol_i2': e+, e- => u, ubar, gl [openloops], [real]
| 3: 'openloops_4_ololol_i3': e+, e- => u, ubar [openloops], [virtual]
| 4: 'openloops_4_ololol_i4': e+, e- => u, ubar [inactive], [subtraction]
| ------------------------------------------------------------------------
| Phase space: 2 channels, 2 dimensions
| Phase space: found 2 channels, collected in 2 groves.
-| Phase space: Using 2 equivalences between channels.
+| Phase space: no equivalences between channels used.
| Phase space: wood
| Phase space: 2 channels, 5 dimensions
| Phase space: found 2 channels, collected in 2 groves.
| Phase space: no equivalences between channels used.
| Phase space: wood
| Phase space: 2 channels, 2 dimensions
| Phase space: found 2 channels, collected in 2 groves.
-| Phase space: Using 2 equivalences between channels.
+| Phase space: no equivalences between channels used.
| Phase space: wood
Warning: No cuts have been defined.
| Using user-defined general scale.
| Starting integration for process 'openloops_4_ololol' part 'born'
| Integrate: iterations = 1:100:"gw"
| Integrator: 2 chains, 2 channels, 2 dimensions
| Integrator: 100 initial calls, 20 bins, stratified = T
| Integrator: VAMP
|=============================================================================|
| It Calls Integral[fb] Error[fb] Err[%] Acc Eff[%] Chi2 N[It] |
|=============================================================================|
1 100 1.792E+03 1.08E+02 6.02 0.60 41.2
|-----------------------------------------------------------------------------|
1 100 1.792E+03 1.08E+02 6.02 0.60 41.2
|=============================================================================|
| Starting integration for process 'openloops_4_ololol' part 'real'
| Integrate: iterations = 1:100:"gw"
| Integrator: 2 chains, 2 channels, 5 dimensions
| Integrator: 100 initial calls, 20 bins, stratified = T
| Integrator: VAMP
|=============================================================================|
| It Calls Integral[fb] Error[fb] Err[%] Acc Eff[%] Chi2 N[It] |
|=============================================================================|
1 100 2.253E+02 2.07E+01 9.18 0.92 20.0
|-----------------------------------------------------------------------------|
1 100 2.253E+02 2.07E+01 9.18 0.92 20.0
|=============================================================================|
| Starting integration for process 'openloops_4_ololol' part 'virtual'
| Integrate: iterations = 1:100:"gw"
| Integrator: 2 chains, 2 channels, 2 dimensions
| Integrator: 100 initial calls, 20 bins, stratified = T
| Integrator: VAMP
|=============================================================================|
| It Calls Integral[fb] Error[fb] Err[%] Acc Eff[%] Chi2 N[It] |
|=============================================================================|
1 100 -1.152E+02 6.79E+00 5.89 0.59 39.6
|-----------------------------------------------------------------------------|
1 100 -1.152E+02 6.79E+00 5.89 0.59 39.6
|=============================================================================|
| Integrate: sum of all components
|=============================================================================|
| It Calls Integral[fb] Error[fb] Err[%] Acc Eff[%] Chi2 N[It] |
|=============================================================================|
1 0 1.902E+03 1.10E+02 5.79 0.00 34.7
| NLO Correction: [O(alpha_s+1)/O(alpha_s)]
| ( 6.1438 +- 1.27004 ) %
|=============================================================================|
integral(openloops_4_ololol) = 1.90204E+03
error(openloops_4_ololol) = 1.10105E+02
| expect: success
| Switching to model 'SM_tt_threshold'
SM_tt_threshold.sqrtsstepsize => 1.00000E-01
SM_tt_threshold.sqrtsmin => 4.99900E+02
SM_tt_threshold.sqrtsmax => 5.00100E+02
SM_tt_threshold.mW => 7.00000E+01
SM_tt_threshold.mZ => 9.00000E+01
SM_tt_threshold.wZ => 1.00000E+00
SM_tt_threshold.wW => 3.00000E+00
SM_tt_threshold.alpha_em_i => 7.65037E+01
SM_tt_threshold.mmu => 0.00000E+00
SM_tt_threshold.me => 0.00000E+00
SM_tt_threshold.mc => 0.00000E+00
SM_tt_threshold.ms => 0.00000E+00
?alphas_is_fixed = true
?alphas_from_mz = false
?alphas_from_lambda_qcd = false
SM_tt_threshold.alphas => 2.00000E-01
-Warning: You have not disabled VAMP equivalences.
- Note that they are automatically switched off
- for NLO calculations.
| Process library 'openloops_4_lib': unloading
| Process library 'openloops_4_lib': open
| Process library 'openloops_4_lib': recorded process 'openloops_4_threshold'
seed = 0
| Integrate: current process library needs compilation
| Process library 'openloops_4_lib': compiling ...
| Process library 'openloops_4_lib': writing makefile
| Process library 'openloops_4_lib': removing old files
| Process library 'openloops_4_lib': writing driver
| Process library 'openloops_4_lib': creating source code
| Process library 'openloops_4_lib': compiling sources
| Process library 'openloops_4_lib': linking
| Process library 'openloops_4_lib': loading
| Process library 'openloops_4_lib': ... success.
| Integrate: compilation done
| RNG: Initializing TAO random-number generator
| RNG: Setting seed for random-number generator to 0
| Initializing integration for process openloops_4_threshold:
| Beam structure: [any particles]
| Beam data (collision):
| e+ (mass = 0.0000000E+00 GeV)
| e- (mass = 0.0000000E+00 GeV)
| sqrts = 5.000000000000E+02 GeV
| Phase space: generating configuration ...
| Phase space: ... success.
| Phase space: writing configuration file 'openloops_4_threshold.i1.phs'
| Phase space: generating configuration ...
| Phase space: ... success.
| Phase space: writing configuration file 'openloops_4_threshold.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: [...]
| 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_4_threshold'
| Library name = 'openloops_4_lib'
| Process index = 6
| Process components:
| 1: 'openloops_4_threshold_i1': e+, e- => u, ubar [openloops]
| 2: 'openloops_4_threshold_i2': e+, e- => u, ubar, gl [openloops], [real]
| 3: 'openloops_4_threshold_i3': e+, e- => u, ubar [openloops], [virtual]
| 4: 'openloops_4_threshold_i4': e+, e- => u, ubar [inactive], [subtraction]
| ------------------------------------------------------------------------
| Phase space: 2 channels, 2 dimensions
| Phase space: found 2 channels, collected in 2 groves.
-| Phase space: Using 2 equivalences between channels.
+| Phase space: no equivalences between channels used.
| Phase space: wood
| Phase space: 2 channels, 5 dimensions
| Phase space: found 2 channels, collected in 2 groves.
| Phase space: no equivalences between channels used.
| Phase space: wood
| Phase space: 2 channels, 2 dimensions
| Phase space: found 2 channels, collected in 2 groves.
-| Phase space: Using 2 equivalences between channels.
+| Phase space: no equivalences between channels used.
| Phase space: wood
Warning: No cuts have been defined.
| Using user-defined general scale.
| Starting integration for process 'openloops_4_threshold' part 'born'
| Integrate: iterations = 1:100:"gw"
| Integrator: 2 chains, 2 channels, 2 dimensions
| Integrator: 100 initial calls, 20 bins, stratified = T
| Integrator: VAMP
|=============================================================================|
| It Calls Integral[fb] Error[fb] Err[%] Acc Eff[%] Chi2 N[It] |
|=============================================================================|
1 100 1.792E+03 1.08E+02 6.02 0.60 41.2
|-----------------------------------------------------------------------------|
1 100 1.792E+03 1.08E+02 6.02 0.60 41.2
|=============================================================================|
| Starting integration for process 'openloops_4_threshold' part 'real'
| Integrate: iterations = 1:100:"gw"
| Integrator: 2 chains, 2 channels, 5 dimensions
| Integrator: 100 initial calls, 20 bins, stratified = T
| Integrator: VAMP
|=============================================================================|
| It Calls Integral[fb] Error[fb] Err[%] Acc Eff[%] Chi2 N[It] |
|=============================================================================|
1 100 2.253E+02 2.07E+01 9.18 0.92 20.0
|-----------------------------------------------------------------------------|
1 100 2.253E+02 2.07E+01 9.18 0.92 20.0
|=============================================================================|
| Starting integration for process 'openloops_4_threshold' part 'virtual'
| Integrate: iterations = 1:100:"gw"
| Integrator: 2 chains, 2 channels, 2 dimensions
| Integrator: 100 initial calls, 20 bins, stratified = T
| Integrator: VAMP
|=============================================================================|
| It Calls Integral[fb] Error[fb] Err[%] Acc Eff[%] Chi2 N[It] |
|=============================================================================|
1 100 -1.152E+02 6.79E+00 5.89 0.59 39.6
|-----------------------------------------------------------------------------|
1 100 -1.152E+02 6.79E+00 5.89 0.59 39.6
|=============================================================================|
| Integrate: sum of all components
|=============================================================================|
| It Calls Integral[fb] Error[fb] Err[%] Acc Eff[%] Chi2 N[It] |
|=============================================================================|
1 0 1.902E+03 1.10E+02 5.79 0.00 34.7
| NLO Correction: [O(alpha_s+1)/O(alpha_s)]
| ( 6.1438 +- 1.27004 ) %
|=============================================================================|
integral(openloops_4_threshold) = 1.90204E+03
error(openloops_4_threshold) = 1.10105E+02
| expect: success
| Summary of value checks:
| Failures: 0 / Total: 5
-| There were no errors and 12 warning(s).
+| There were no errors and 6 warning(s).
| WHIZARD run finished.
|=============================================================================|
Index: trunk/share/tests/functional_tests/ref-output/user_prc_threshold_2.ref
===================================================================
--- trunk/share/tests/functional_tests/ref-output/user_prc_threshold_2.ref (revision 8482)
+++ trunk/share/tests/functional_tests/ref-output/user_prc_threshold_2.ref (revision 8483)
@@ -1,173 +1,171 @@
?openmp_logging = false
?vis_history = false
?integration_timer = false
?pacify = true
+?use_vamp_equivalences = false
openmp_num_threads = 1
| Switching to model 'SM_tt_threshold'
SM_tt_threshold.sqrtsmin => 3.50000E+02
SM_tt_threshold.sqrtsmax => 3.50000E+02
SM_tt_threshold.sqrtsstepsize => 0.00000E+00
SM_tt_threshold.me => 0.00000E+00
SM_tt_threshold.mZ => 9.11880E+01
SM_tt_threshold.mW => 8.04190E+01
SM_tt_threshold.mb => 4.20000E+00
SM_tt_threshold.alphas => 1.18000E-01
SM_tt_threshold.alpha_em_i => 1.25924E+02
SM_tt_threshold.m1S => 1.72000E+02
SM_tt_threshold.mpole_fixed => 1.00000E+00
SM_tt_threshold.nrqcd_order => 1.00000E+00
SM_tt_threshold.sh => 1.00000E+00
SM_tt_threshold.sf => 1.00000E+00
SM_tt_threshold.Vtb => 1.00000E+00
SM_tt_threshold.FF => 9.00000E+00
$method = "threshold"
$born_me_method = "threshold"
$loop_me_method = "threshold"
$correlation_me_method = "threshold"
$real_tree_me_method = "threshold"
alpha_power = 4
alphas_power = 0
SM_tt_threshold.alphas => 1.18000E-01
?alphas_is_fixed = false
?alphas_from_mz = true
?alphas_from_lambda_qcd = false
-Warning: You have not disabled VAMP equivalences.
- Note that they are automatically switched off
- for NLO calculations.
| Process library 'user_prc_threshold_2_lib': recorded process 'user_prc_threshold_2_p1'
SM_tt_threshold.top_helicity_selection => 3.00000E+00
seed = 0
SM_tt_threshold.offshell_strategy => 5.55000E+02
sqrts = 3.43000E+02
| Integrate: current process library needs compilation
| Process library 'user_prc_threshold_2_lib': compiling ...
| Process library 'user_prc_threshold_2_lib': writing makefile
| Process library 'user_prc_threshold_2_lib': removing old files
| Process library 'user_prc_threshold_2_lib': writing driver
| Process library 'user_prc_threshold_2_lib': creating source code
| Process library 'user_prc_threshold_2_lib': compiling sources
| Process library 'user_prc_threshold_2_lib': linking
| Process library 'user_prc_threshold_2_lib': loading
| Loaded extra threshold functions
| Loaded extra threshold functions
| Loaded extra threshold functions
| Process library 'user_prc_threshold_2_lib': ... success.
| Integrate: compilation done
| QCD alpha: using a running strong coupling
| RNG: Initializing TAO random-number generator
| RNG: Setting seed for random-number generator to 0
| Initializing integration for process user_prc_threshold_2_p1:
| Beam structure: [any particles]
| Beam data (collision):
| e+ (mass = 0.0000000E+00 GeV)
| e- (mass = 0.0000000E+00 GeV)
| sqrts = 3.430000000000E+02 GeV
| Phase space: generating configuration ...
| Phase space: ... success.
| Phase space: writing configuration file 'user_prc_threshold_2_p1.i1.phs'
| Phase space: generating configuration ...
| Phase space: ... success.
| Phase space: writing configuration file 'user_prc_threshold_2_p1.i3.phs'
| ------------------------------------------------------------------------
| Process [scattering]: 'user_prc_threshold_2_p1'
| Library name = 'user_prc_threshold_2_lib'
| Process index = 1
| Process components:
| 1: 'user_prc_threshold_2_p1_i1': e+, e- => W+, W-, b, bbar [inactive]
| 2: 'user_prc_threshold_2_p1_i2': e+, e- => W+, W-, b, bbar, gl [threshold], [real]
| 3: 'user_prc_threshold_2_p1_i3': e+, e- => W+, W-, b, bbar [inactive], [virtual]
| 4: 'user_prc_threshold_2_p1_i4': e+, e- => W+, W-, b, bbar [inactive], [subtraction]
| ------------------------------------------------------------------------
| Phase space: 60 channels, 8 dimensions
| Phase space: found 60 channels, collected in 24 groves.
-| Phase space: Using 70 equivalences between channels.
+| Phase space: no equivalences between channels used.
| Phase space: wood
| Phase space: 60 channels, 11 dimensions
| Phase space: found 60 channels, collected in 24 groves.
| Phase space: no equivalences between channels used.
| Phase space: wood
| Phase space: 60 channels, 8 dimensions
| Phase space: found 60 channels, collected in 24 groves.
-| Phase space: Using 70 equivalences between channels.
+| Phase space: no equivalences between channels used.
| Phase space: wood
Warning: No cuts have been defined.
| Using user-defined general scale.
| Starting integration for process 'user_prc_threshold_2_p1' part 'real'
| Integrate: iterations = 1:700
| Integrator: 24 chains, 60 channels, 11 dimensions
| Integrator: 700 initial calls, 20 bins, stratified = T
| Integrator: VAMP
|=============================================================================|
| It Calls Integral[fb] Error[fb] Err[%] Acc Eff[%] Chi2 N[It] |
|=============================================================================|
1 660 -5.983E+00 3.61E+00 60.41 15.52 11.2
|-----------------------------------------------------------------------------|
1 660 -5.983E+00 3.61E+00 60.41 15.52 11.2
|=============================================================================|
| Integrate: sum of all components
|=============================================================================|
| It Calls Integral[fb] Error[fb] Err[%] Acc Eff[%] Chi2 N[It] |
|=============================================================================|
1 0 -5.983E+00 3.61E+00 60.41 0.00 0.0
|=============================================================================|
sqrts = 3.45000E+02
| QCD alpha: using a running strong coupling
| RNG: Initializing TAO random-number generator
| RNG: Setting seed for random-number generator to 1
| Initializing integration for process user_prc_threshold_2_p1:
| Beam structure: [any particles]
| Beam data (collision):
| e+ (mass = 0.0000000E+00 GeV)
| e- (mass = 0.0000000E+00 GeV)
| sqrts = 3.450000000000E+02 GeV
| Phase space: generating configuration ...
| Phase space: ... success.
| Phase space: writing configuration file 'user_prc_threshold_2_p1.i1.phs'
| Phase space: generating configuration ...
| Phase space: ... success.
| Phase space: writing configuration file 'user_prc_threshold_2_p1.i3.phs'
| ------------------------------------------------------------------------
| Process [scattering]: 'user_prc_threshold_2_p1'
| Library name = 'user_prc_threshold_2_lib'
| Process index = 1
| Process components:
| 1: 'user_prc_threshold_2_p1_i1': e+, e- => W+, W-, b, bbar [inactive]
| 2: 'user_prc_threshold_2_p1_i2': e+, e- => W+, W-, b, bbar, gl [threshold], [real]
| 3: 'user_prc_threshold_2_p1_i3': e+, e- => W+, W-, b, bbar [inactive], [virtual]
| 4: 'user_prc_threshold_2_p1_i4': e+, e- => W+, W-, b, bbar [inactive], [subtraction]
| ------------------------------------------------------------------------
| Phase space: 61 channels, 8 dimensions
| Phase space: found 61 channels, collected in 25 groves.
-| Phase space: Using 71 equivalences between channels.
+| Phase space: no equivalences between channels used.
| Phase space: wood
| Phase space: 61 channels, 11 dimensions
| Phase space: found 61 channels, collected in 25 groves.
| Phase space: no equivalences between channels used.
| Phase space: wood
| Phase space: 61 channels, 8 dimensions
| Phase space: found 61 channels, collected in 25 groves.
-| Phase space: Using 71 equivalences between channels.
+| Phase space: no equivalences between channels used.
| Phase space: wood
Warning: No cuts have been defined.
| Using user-defined general scale.
| Starting integration for process 'user_prc_threshold_2_p1' part 'real'
| Integrate: iterations = 1:700
| Integrator: 25 chains, 61 channels, 11 dimensions
| Integrator: 700 initial calls, 20 bins, stratified = T
| Integrator: VAMP
|=============================================================================|
| It Calls Integral[fb] Error[fb] Err[%] Acc Eff[%] Chi2 N[It] |
|=============================================================================|
1 671 -9.432E+00 2.26E+00 24.00 6.22 25.3
|-----------------------------------------------------------------------------|
1 671 -9.432E+00 2.26E+00 24.00 6.22 25.3
|=============================================================================|
| Integrate: sum of all components
|=============================================================================|
| It Calls Integral[fb] Error[fb] Err[%] Acc Eff[%] Chi2 N[It] |
|=============================================================================|
1 0 -9.432E+00 2.26E+00 24.00 0.00 0.0
|=============================================================================|
-| There were no errors and 3 warning(s).
+| There were no errors and 2 warning(s).
| WHIZARD run finished.
|=============================================================================|
Index: trunk/share/tests/functional_tests/user_prc_threshold_1.sin
===================================================================
--- trunk/share/tests/functional_tests/user_prc_threshold_1.sin (revision 8482)
+++ trunk/share/tests/functional_tests/user_prc_threshold_1.sin (revision 8483)
@@ -1,87 +1,88 @@
# SINDARIN file for WHIZARD self test
# Input file for testing user defined amplitudes
?logging = true
?openmp_logging = false
?vis_history = false
?integration_timer = false
?pacify = true
+?use_vamp_equivalences = false
!!! Tests should be run single-threaded
openmp_num_threads = 1
model = SM_tt_threshold
sqrtsmin = 350 GeV
sqrtsmax = 350 GeV
sqrtsstepsize = 0.0 GeV
m1S = 172 GeV
mZ = 91.188
mW = 80.419
mb = 4.2
alphas = 0.118 ! (Z pole, NLL running to mu_h)
alpha_em_i = 125.924 ! (not running)
m1S = 172.0
phs_t_channel = 0
nrqcd_order = 1 # NLL
sh = 1.
sf = 1.
Vtb = 1.
FF = 1 # NRQCD resummed
mpole_fixed = 1
offshell_strategy = 4
me = 0
sqrts = 350 GeV
iterations = 1:200
real num_diff = 0.001
seed = 0
process user_prc_threshold_1_p1 = E1, e1 => Wp, Wm, b, B { $restrictions = "3+5~t && 4+6~tbar" }
integrate (user_prc_threshold_1_p1)
seed = 0
process user_prc_threshold_1_p2 = E1, e1 => t, T
integrate (user_prc_threshold_1_p2)
seed = 0
process user_prc_threshold_1_p5 = E1, e1 => t, T { $method = "threshold" }
integrate (user_prc_threshold_1_p5)
expect (integral(user_prc_threshold_1_p5) == integral(user_prc_threshold_1_p2)) { tolerance = 0.0001 }
seed = 0
$born_me_method = "threshold"
$loop_me_method = "threshold"
$correlation_me_method = "threshold"
$real_tree_me_method = "threshold"
process user_prc_threshold_1_p6 = E1, e1 => Wp, Wm, b, B {
$restrictions = "3+5~t && 4+6~tbar" nlo_calculation = born }
integrate (user_prc_threshold_1_p6)
expect (integral(user_prc_threshold_1_p6) == integral(user_prc_threshold_1_p1)) { tolerance = 0.0001 }
$method = "threshold"
! FF = 10 !!! tree
! bits for offshell strategy :
! NLO|factorization|interference|onshellprojection|LOwidthinsignal
!!! We can also compute the signal diagram in the signal component (in threshold.f90)
seed = 0
process user_prc_threshold_1_sig_thr = E1, e1 => Wp, Wm, b, B
offshell_strategy = 0+0+0+0+0
integrate (user_prc_threshold_1_sig_thr)
expect (integral (user_prc_threshold_1_sig_thr) ==
integral (user_prc_threshold_1_p6)) {tolerance = num_diff}
!!! tree level result from amp_blob, i.e. with factorized onshell LO decays
seed = 0
process user_prc_threshold_1_factorized = E1, e1 => Wp, Wm, b, B
offshell_strategy = 0+2+0+0+0 ! activate factorization
integrate (user_prc_threshold_1_factorized)
!!! Differences of O(Gamma/M) are ok
expect (integral (user_prc_threshold_1_p6) ==
integral (user_prc_threshold_1_factorized)) {tolerance =
4 * wtop / mtpole * integral (user_prc_threshold_1_p6)}
Index: trunk/share/tests/functional_tests/openloops_4.sin
===================================================================
--- trunk/share/tests/functional_tests/openloops_4.sin (revision 8482)
+++ trunk/share/tests/functional_tests/openloops_4.sin (revision 8483)
@@ -1,115 +1,115 @@
!!! Tests functionality of NLO-setups using all possible combinations of
!!! omega and openloops for Born-, Real- and correlation-matrix-elements.
model = SM ("GF_MW_MZ")
$blha_ew_scheme = "alpha_internal"
?logging = true
?openmp_logging = false
?vis_history = false
?integration_timer = false
?pacify = true
openmp_num_threads = 1
-
+?use_vamp_equivalences = false
### We compare with standard Omega, so the CMS is disabled
?openloops_use_cms = false
!!! Use non default values to easily spot differences
mW = 70
mZ = 90
GF = 1.5E-005
wZ = 1.0
wW = 3.0
printf " alpha_em %g" (1/alpha_em_i)
real alpha_em_inverse = alpha_em_i
mmu = 0
me = 0
mc = 0
ms = 0
!!! The expected value for (NLO-LO)/LO is alpha_s / pi
?alphas_is_fixed = true
?alphas_from_mz = false
?alphas_from_lambda_qcd = false
alphas = 0.2
alpha_power = 2
alphas_power = 0
scale = 200 GeV
$loop_me_method = "openloops" !!! Needs OpenLoops library ppllj
sqrts = 500 GeV
iterations = 1:100:"gw"
tolerance = 0.001
$born_me_method = "omega"
$real_tree_me_method = "omega"
$correlation_me_method = "omega"
process openloops_4_omomom = E1, e1 => u, U { nlo_calculation = full }
integrate (openloops_4_omomom) { seed = 0 }
show (integral(openloops_4_omomom))
show (error(openloops_4_omomom))
real reference_integral = integral(openloops_4_omomom)
$born_me_method = "openloops"
$real_tree_me_method = "omega"
$correlation_me_method = "omega"
process openloops_4_olomom = E1, e1 => u, U { nlo_calculation = full }
integrate (openloops_4_olomom) { seed = 0 }
show (integral(openloops_4_olomom))
show (error(openloops_4_olomom))
expect (integral (openloops_4_olomom) == reference_integral)
$born_me_method = "omega"
$real_tree_me_method = "openloops"
$correlation_me_method = "omega"
process openloops_4_omolom = E1, e1 => u, U { nlo_calculation = full }
integrate (openloops_4_omolom) { seed = 0 }
show (integral(openloops_4_omolom))
show (error(openloops_4_omolom))
expect (integral (openloops_4_omolom) == reference_integral)
$born_me_method = "omega"
$real_tree_me_method = "omega"
$correlation_me_method = "openloops"
process openloops_4_omomol = E1, e1 => u, U { nlo_calculation = full }
integrate (openloops_4_omomol) { seed = 0 }
show (integral(openloops_4_omomol))
show (error(openloops_4_omomol))
expect (integral (openloops_4_omomol) == reference_integral)
$born_me_method = "openloops"
$real_tree_me_method = "openloops"
$correlation_me_method = "openloops"
process openloops_4_ololol = E1, e1 => u, U { nlo_calculation = full }
integrate (openloops_4_ololol) { seed = 0 }
show (integral(openloops_4_ololol))
show (error(openloops_4_ololol))
expect (integral (openloops_4_ololol) == reference_integral)
model = SM_tt_threshold
sqrtsstepsize = 0.1 GeV
sqrtsmin = sqrts - sqrtsstepsize
sqrtsmax = sqrts + sqrtsstepsize
mW = 70
mZ = 90
wZ = 1.0
wW = 3.0
alpha_em_i = alpha_em_inverse
mmu = 0
me = 0
mc = 0
ms = 0
?alphas_is_fixed = true
?alphas_from_mz = false
?alphas_from_lambda_qcd = false
alphas = 0.2
scale = 200 GeV
process openloops_4_threshold = E1, e1 => u, U { nlo_calculation = full }
integrate (openloops_4_threshold) { seed = 0 }
show (integral(openloops_4_threshold))
show (error(openloops_4_threshold))
expect (integral (openloops_4_threshold) == reference_integral)
Index: trunk/share/tests/functional_tests/user_prc_threshold_2.sin
===================================================================
--- trunk/share/tests/functional_tests/user_prc_threshold_2.sin (revision 8482)
+++ trunk/share/tests/functional_tests/user_prc_threshold_2.sin (revision 8483)
@@ -1,60 +1,61 @@
# SINDARIN file for WHIZARD self test
# Testing factorized NLO calculation at top threshold
?logging = true
?openmp_logging = false
?vis_history = false
?integration_timer = false
?pacify = true
+?use_vamp_equivalences = false
!!! Tests should be run single-threaded
openmp_num_threads = 1
model = SM_tt_threshold
sqrtsmin = 350 GeV
sqrtsmax = 350 GeV
sqrtsstepsize = 0.0 GeV
me = 0
mZ = 91.188
mW = 80.419
mb = 4.2
alphas = 0.118 ! (Z pole, NLL running to mu_h)
alpha_em_i = 125.924 ! (not running)
m1S = 172.0
scale = m1S
mpole_fixed = 1
nrqcd_order = 1 # NLL
sh = 1.
sf = 1.
Vtb = 1.
FF = 9
$method = "threshold"
$born_me_method = "threshold"
$loop_me_method = "threshold"
$correlation_me_method = "threshold"
$real_tree_me_method = "threshold"
alpha_power = 4
alphas_power = 0
alphas = 0.118
?alphas_is_fixed = false
?alphas_from_mz = true
?alphas_from_lambda_qcd = false
process user_prc_threshold_2_p1 = E1, e1 => Wp, Wm, b, B { nlo_calculation = real }
top_helicity_selection = 3
seed = 0
!!! offshell_strategy: Factorized, NLO, on-shell proj., helicity approx., Boosted Decay
offshell_strategy = 1 + 2 + 8 + 32 + 512
!!! Below threshold
sqrts = 343 GeV
iterations = 1:700
integrate (user_prc_threshold_2_p1)
!!! Above threshold
sqrts = 345 GeV
integrate (user_prc_threshold_2_p1)
Index: trunk/share/tests/ext_tests_nlo/nlo_ppzj_sim_1.sin
===================================================================
--- trunk/share/tests/ext_tests_nlo/nlo_ppzj_sim_1.sin (revision 8482)
+++ trunk/share/tests/ext_tests_nlo/nlo_ppzj_sim_1.sin (revision 8483)
@@ -1,76 +1,75 @@
# SINDARIN input for WHIZARD self-test
# Testing NLO calculation of the real component of
# of pp -> Zj and the simulation of events.
model = "SM"
?logging = true
?openmp_logging = false
?vis_history = false
?integration_timer = false
?pacify = true
!!! Tests should be run single-threaded
openmp_num_threads = 1
mZ = 91.188
wZ = 0.0
ms = 0
alias pr = u:U:d:D:s:S:gl
alias jet = u:U:d:D:s:S:gl
alias elec = e1:E1
$exclude_gauge_splittings = "c:b:t"
jet_algorithm = antikt_algorithm
jet_r = 0.5
$method = "openloops"
alpha_power = 1
alphas_power = 1
$rng_method = "rng_stream"
$integration_method = "vamp2"
beams = p, p => pdf_builtin
sqrts = 13000 GeV
cuts = let subevt @clustered_jets = cluster [jet] in
let subevt @pt_selected = select if Pt > 350 GeV [@clustered_jets] in
let subevt @eta_selected = select if abs(Eta) < 4 [@pt_selected] in
count [@eta_selected] >= 1
scale = let int njet = count [jet] in
if njet == 1 then
(sqrt (eval Pt [extract index 1 [Z]]**2 + eval M [extract index 1 [Z]]**2)
+eval Pt [extract index 1 [jet]]) / 2
elsif njet == 2 then
(sqrt (eval Pt [extract index 1 [Z]]**2 + eval M [extract index 1 [Z]]**2)
+eval Pt [extract index 1 [jet]]
+eval Pt [extract index 2 [jet]]) / 2
else
sqrts
endif
?combined_nlo_integration = false
-?use_vamp_equivalences = false
seed = 3992
process nlo_ppzj_sim_1_p1 = pr, pr => Z, jet { nlo_calculation = real $restrictions="!W+:W-" }
integrate (nlo_ppzj_sim_1_p1) { iterations = 1:100 }
n_events = 10
$sample_normalization = "sigma"
?unweighted = false
?negative_weights = true
?keep_failed_events = true
?fixed_order_nlo_events = true
sample_format = debug
?debug_decay = false
?debug_process = false
?debug_verbose = false
?sample_pacify = true
?write_raw = false
simulate(nlo_ppzj_sim_1_p1)
Index: trunk/share/tests/ext_tests_nlo/nlo_ppzj_sim_2.sin
===================================================================
--- trunk/share/tests/ext_tests_nlo/nlo_ppzj_sim_2.sin (revision 8482)
+++ trunk/share/tests/ext_tests_nlo/nlo_ppzj_sim_2.sin (revision 8483)
@@ -1,76 +1,75 @@
# SINDARIN input for WHIZARD self-test
# Testing NLO calculation of the virtual component of
# of pp -> Zj and the simulation of events.
model = "SM"
?logging = true
?openmp_logging = false
?vis_history = false
?integration_timer = false
?pacify = true
!!! Tests should be run single-threaded
openmp_num_threads = 1
mZ = 91.188
wZ = 0.0
ms = 0
alias pr = u:U:d:D:s:S:gl
alias jet = u:U:d:D:s:S:gl
alias elec = e1:E1
$exclude_gauge_splittings = "c:b:t"
jet_algorithm = antikt_algorithm
jet_r = 0.5
$method = "openloops"
alpha_power = 1
alphas_power = 1
$rng_method = "rng_stream"
$integration_method = "vamp2"
beams = p, p => pdf_builtin
sqrts = 13000 GeV
cuts = let subevt @clustered_jets = cluster [jet] in
let subevt @pt_selected = select if Pt > 350 GeV [@clustered_jets] in
let subevt @eta_selected = select if abs(Eta) < 4 [@pt_selected] in
count [@eta_selected] >= 1
scale = let int njet = count [jet] in
if njet == 1 then
(sqrt (eval Pt [extract index 1 [Z]]**2 + eval M [extract index 1 [Z]]**2)
+eval Pt [extract index 1 [jet]]) / 2
elsif njet == 2 then
(sqrt (eval Pt [extract index 1 [Z]]**2 + eval M [extract index 1 [Z]]**2)
+eval Pt [extract index 1 [jet]]
+eval Pt [extract index 2 [jet]]) / 2
else
sqrts
endif
?combined_nlo_integration = false
-?use_vamp_equivalences = false
seed = 3991
process nlo_ppzj_sim_2_p1 = pr, pr => Z, jet { nlo_calculation = virtual $restrictions="!W+:W-" }
integrate (nlo_ppzj_sim_2_p1) { iterations = 1:100 }
n_events = 2
$sample_normalization = "sigma"
?unweighted = false
?negative_weights = true
?keep_failed_events = true
?fixed_order_nlo_events = true
sample_format = debug
?debug_decay = false
?debug_process = false
?debug_verbose = false
?sample_pacify = true
?write_raw = false
simulate(nlo_ppzj_sim_2_p1)
Index: trunk/share/tests/ext_tests_nlo/nlo_ppzj_sim_3.sin
===================================================================
--- trunk/share/tests/ext_tests_nlo/nlo_ppzj_sim_3.sin (revision 8482)
+++ trunk/share/tests/ext_tests_nlo/nlo_ppzj_sim_3.sin (revision 8483)
@@ -1,76 +1,75 @@
# SINDARIN input for WHIZARD self-test
# Testing NLO calculation of the dglap component of
# of pp -> Zj and the simulation of events.
model = "SM"
?logging = true
?openmp_logging = false
?vis_history = false
?integration_timer = false
?pacify = true
!!! Tests should be run single-threaded
openmp_num_threads = 1
mZ = 91.188
wZ = 0.0
ms = 0
alias pr = u:U:d:D:s:S:gl
alias jet = u:U:d:D:s:S:gl
alias elec = e1:E1
$exclude_gauge_splittings = "c:b:t"
jet_algorithm = antikt_algorithm
jet_r = 0.5
$method = "openloops"
alpha_power = 1
alphas_power = 1
$rng_method = "rng_stream"
$integration_method = "vamp2"
beams = p, p => pdf_builtin
sqrts = 13000 GeV
cuts = let subevt @clustered_jets = cluster [jet] in
let subevt @pt_selected = select if Pt > 350 GeV [@clustered_jets] in
let subevt @eta_selected = select if abs(Eta) < 4 [@pt_selected] in
count [@eta_selected] >= 1
scale = let int njet = count [jet] in
if njet == 1 then
(sqrt (eval Pt [extract index 1 [Z]]**2 + eval M [extract index 1 [Z]]**2)
+eval Pt [extract index 1 [jet]]) / 2
elsif njet == 2 then
(sqrt (eval Pt [extract index 1 [Z]]**2 + eval M [extract index 1 [Z]]**2)
+eval Pt [extract index 1 [jet]]
+eval Pt [extract index 2 [jet]]) / 2
else
sqrts
endif
?combined_nlo_integration = false
-?use_vamp_equivalences = false
seed = 3991
process nlo_ppzj_sim_3_p1 = pr, pr => Z, jet { nlo_calculation = dglap $restrictions="!W+:W-" }
integrate (nlo_ppzj_sim_3_p1) { iterations = 1:100 }
n_events = 2
$sample_normalization = "sigma"
?unweighted = false
?negative_weights = true
?keep_failed_events = true
?fixed_order_nlo_events = true
sample_format = debug
?debug_decay = false
?debug_process = false
?debug_verbose = false
?sample_pacify = true
?write_raw = false
simulate(nlo_ppzj_sim_3_p1)
Index: trunk/share/tests/ext_tests_nlo/nlo_ppjjj.sin
===================================================================
--- trunk/share/tests/ext_tests_nlo/nlo_ppjjj.sin (revision 8482)
+++ trunk/share/tests/ext_tests_nlo/nlo_ppjjj.sin (revision 8483)
@@ -1,53 +1,52 @@
include("nlo_settings.sin")
alias pr = u:U:d:D:s:S:c:C:b:B:gl
!alias pr = u:U:d:D:gl
$exclude_gauge_splittings = "t"
!$exclude_gauge_splittings = "s:c:b:t"
!alias pr = u:U:gl
!alias jet = u:U:gl
beams = p, p => lhapdf
$lhapdf_file = "MSTW2008nlo68cl"
sqrts = 13000 GeV
!seed = 20190705
alpha_power = 0
alphas_power = 3
?alphas_from_mz = false
?alphas_from_lhapdf = true
!alphas = 0.120179
cuts = let subevt @clustered_jets = cluster [jet] in
let subevt @pt_selected = select if Pt > 80 GeV [@clustered_jets] in
let subevt @eta_selected = select if abs(Eta) < 4 [@pt_selected] in
let subevt @hardest_jets = select if Pt > 100 GeV [@eta_selected] in
count [@eta_selected] >= 3 and count [@hardest_jets] >= 1
!scale = (sqrt (eval Pt [extract index 1 [t]]**2 + eval M [extract index 1 [t]]**2)
! + sqrt (eval Pt [extract index 1 [T]]**2 + eval M [extract index 1 [T]]**2)
! + sqrt (eval Pt [extract index 1 [Z]]**2 + eval M [extract index 1 [Z]]**2)) / 2
scale = let subevt @clustered_jets = cluster [jet] in
let int njet = count [@clustered_jets] in
if njet == 3 then
( eval Pt [extract index 1 [@clustered_jets]]
+ eval Pt [extract index 2 [@clustered_jets]]
+ eval Pt [extract index 3 [@clustered_jets]]) / 2
elsif njet == 4 then
( eval Pt [extract index 1 [@clustered_jets]]
+ eval Pt [extract index 2 [@clustered_jets]]
+ eval Pt [extract index 3 [@clustered_jets]]
+ eval Pt [extract index 4 [@clustered_jets]]) / 2
else
sqrts
endif
?combined_nlo_integration = false
-?use_vamp_equivalences = false
mult_call_real = 5
relative_error_goal = 0.009
process ppjjj = pr, pr => jet, jet, jet { nlo_calculation = full $restrictions="!W+:W-" }
integrate (ppjjj) { iterations = 15:200000:"gw",5:100000 }
!integrate (ppjjj) { iterations = 4:1000:"gw" }
Index: trunk/share/tests/ext_tests_nlo/nlo_ppzj_sim_4.sin
===================================================================
--- trunk/share/tests/ext_tests_nlo/nlo_ppzj_sim_4.sin (revision 8482)
+++ trunk/share/tests/ext_tests_nlo/nlo_ppzj_sim_4.sin (revision 8483)
@@ -1,76 +1,75 @@
# SINDARIN input for WHIZARD self-test
# Testing the combined NLO calculation of all components of
# of pp -> Zj and the simulation of events.
model = "SM"
?logging = true
?openmp_logging = false
?vis_history = false
?integration_timer = false
?pacify = true
!!! Tests should be run single-threaded
openmp_num_threads = 1
mZ = 91.188
wZ = 0.0
ms = 0
alias pr = u:U:d:D:s:S:gl
alias jet = u:U:d:D:s:S:gl
alias elec = e1:E1
$exclude_gauge_splittings = "c:b:t"
jet_algorithm = antikt_algorithm
jet_r = 0.5
$method = "openloops"
alpha_power = 1
alphas_power = 1
$rng_method = "rng_stream"
$integration_method = "vamp2"
beams = p, p => pdf_builtin
sqrts = 13000 GeV
cuts = let subevt @clustered_jets = cluster [jet] in
let subevt @pt_selected = select if Pt > 360 GeV [@clustered_jets] in
let subevt @eta_selected = select if abs(Eta) < 4 [@pt_selected] in
count [@eta_selected] >= 1
scale = let int njet = count [jet] in
if njet == 1 then
(sqrt (eval Pt [extract index 1 [Z]]**2 + eval M [extract index 1 [Z]]**2)
+eval Pt [extract index 1 [jet]]) / 2
elsif njet == 2 then
(sqrt (eval Pt [extract index 1 [Z]]**2 + eval M [extract index 1 [Z]]**2)
+eval Pt [extract index 1 [jet]]
+eval Pt [extract index 2 [jet]]) / 2
else
sqrts
endif
?combined_nlo_integration = true
-?use_vamp_equivalences = false
seed = 4466
process nlo_ppzj_sim_4_p1 = pr, pr => Z, jet { nlo_calculation = full $restrictions="!W+:W-" }
integrate (nlo_ppzj_sim_4_p1) { iterations = 1:100 }
n_events = 10
$sample_normalization = "sigma"
?unweighted = false
?negative_weights = true
?keep_failed_events = true
?fixed_order_nlo_events = true
sample_format = debug
?debug_decay = false
?debug_process = false
?debug_verbose = false
?sample_pacify = true
?write_raw = false
simulate(nlo_ppzj_sim_4_p1)
Index: trunk/share/tests/ext_tests_nlo/nlo_pptttt.sin
===================================================================
--- trunk/share/tests/ext_tests_nlo/nlo_pptttt.sin (revision 8482)
+++ trunk/share/tests/ext_tests_nlo/nlo_pptttt.sin (revision 8483)
@@ -1,42 +1,41 @@
include("nlo_settings.sin")
alias pr = u:U:d:D:s:S:c:C:b:B:gl
$exclude_gauge_splittings = "t"
beams = p, p => lhapdf
$lhapdf_file = "MSTW2008nlo68cl"
sqrts = 13000 GeV
alpha_power = 0
alphas_power = 4
?alphas_from_mz = false
?alphas_from_lhapdf = true
scale = let subevt @clustered_jets = cluster [jet] in
let int njet = count [@clustered_jets] in
if njet == 0 then
(sqrt (eval Pt [extract index 1 [t]]**2 + eval M [extract index 1 [t]]**2)
+ sqrt (eval Pt [extract index 1 [T]]**2 + eval M [extract index 1 [T]]**2)
+ sqrt (eval Pt [extract index 2 [t]]**2 + eval M [extract index 2 [t]]**2)
+ sqrt (eval Pt [extract index 2 [T]]**2 + eval M [extract index 2 [T]]**2)) / 2
elsif njet == 1 then
(sqrt (eval Pt [extract index 1 [t]]**2 + eval M [extract index 1 [t]]**2)
+ sqrt (eval Pt [extract index 1 [T]]**2 + eval M [extract index 1 [T]]**2)
+ sqrt (eval Pt [extract index 2 [t]]**2 + eval M [extract index 2 [t]]**2)
+ sqrt (eval Pt [extract index 2 [T]]**2 + eval M [extract index 2 [T]]**2)
+ eval Pt [extract index 1 [@clustered_jets]]) / 2
else
sqrts
endif
?combined_nlo_integration = false
-?use_vamp_equivalences = false
!?nlo_use_real_partition = true
!real_partition_scale = 5 GeV
process nlo_pptttt_p1 = pr, pr => t, T, t, T { nlo_calculation = full }
integrate (nlo_pptttt_p1) { iterations = 1:2000:"gw" }
!mult_call_real = 5
!integrate (nlo_pptttt_p1) { iterations = 10:100000:"gw",5:60000 }
Index: trunk/share/tests/ext_tests_nlo/nlo_ppttj.sin
===================================================================
--- trunk/share/tests/ext_tests_nlo/nlo_ppttj.sin (revision 8482)
+++ trunk/share/tests/ext_tests_nlo/nlo_ppttj.sin (revision 8483)
@@ -1,54 +1,53 @@
include("nlo_settings.sin")
alias pr = u:U:d:D:s:S:c:C:b:B:gl
!alias pr = u:U:gl
$exclude_gauge_splittings = "t"
!$exclude_gauge_splittings = "d:s:c:b:t"
!alias pr = u:U:gl
!alias jet = u:U:gl
beams = p, p => lhapdf
$lhapdf_file = "MSTW2008nlo68cl"
sqrts = 13000 GeV
!seed = 20190705
alpha_power = 0
alphas_power = 3
?alphas_from_mz = false
?alphas_from_lhapdf = true
!alphas = 0.120179
cuts = let subevt @clustered_jets = cluster [jet] in
let subevt @pt_selected = select if Pt > 30 GeV [@clustered_jets] in
let subevt @eta_selected = select if abs(Eta) < 4 [@pt_selected] in
count [@eta_selected] >= 1
!scale = (sqrt (eval Pt [extract index 1 [t]]**2 + eval M [extract index 1 [t]]**2)
! + sqrt (eval Pt [extract index 1 [T]]**2 + eval M [extract index 1 [T]]**2)
! + sqrt (eval Pt [extract index 1 [Z]]**2 + eval M [extract index 1 [Z]]**2)) / 2
scale = let subevt @clustered_jets = cluster [jet] in
let int njet = count [@clustered_jets] in
if njet == 1 then
(sqrt (eval Pt [extract index 1 [t]]**2 + eval M [extract index 1 [t]]**2)
+ sqrt (eval Pt [extract index 1 [T]]**2 + eval M [extract index 1 [T]]**2)
+ eval Pt [extract index 1 [@clustered_jets]]) / 2
elsif njet == 2 then
(sqrt (eval Pt [extract index 1 [t]]**2 + eval M [extract index 1 [t]]**2)
+ sqrt (eval Pt [extract index 1 [T]]**2 + eval M [extract index 1 [T]]**2)
+ eval Pt [extract index 1 [@clustered_jets]]
+ eval Pt [extract index 2 [@clustered_jets]]) / 2
else
sqrts
endif
?combined_nlo_integration = false
-?use_vamp_equivalences = false
!?nlo_use_real_partition = true
!real_partition_scale = 5 GeV
mult_call_real = 10
mult_call_virt = 1
relative_error_goal = 0.001
process ppttj = pr, pr => t, T, jet { nlo_calculation = full $restrictions="!W+:W-" }
integrate (ppttj) { iterations = 10:100000:"gw",5:60000 }
!integrate (ppttj) { iterations = 4:1000:"gw" }
Index: trunk/share/tests/ext_tests_nlo/nlo_ppjj.sin
===================================================================
--- trunk/share/tests/ext_tests_nlo/nlo_ppjj.sin (revision 8482)
+++ trunk/share/tests/ext_tests_nlo/nlo_ppjj.sin (revision 8483)
@@ -1,52 +1,51 @@
include("nlo_settings.sin")
alias pr = u:U:d:D:s:S:c:C:b:B:gl
!alias pr = u:U:d:D:gl
$exclude_gauge_splittings = "t"
!$exclude_gauge_splittings = "s:c:b:t"
!alias pr = u:U:gl
!alias jet = u:U:gl
beams = p, p => lhapdf
$lhapdf_file = "MSTW2008nlo68cl"
sqrts = 13000 GeV
!seed = 20190705
alpha_power = 0
alphas_power = 2
?alphas_from_mz = false
?alphas_from_lhapdf = true
!alphas = 0.120179
cuts = let subevt @clustered_jets = cluster [jet] in
let subevt @pt_selected = select if Pt > 80 GeV [@clustered_jets] in
let subevt @eta_selected = select if abs(Eta) < 4 [@pt_selected] in
let subevt @hardest_jets = select if Pt > 100 GeV [@eta_selected] in
count [@eta_selected] >= 2 and count [@hardest_jets] >= 1
!scale = (sqrt (eval Pt [extract index 1 [t]]**2 + eval M [extract index 1 [t]]**2)
! + sqrt (eval Pt [extract index 1 [T]]**2 + eval M [extract index 1 [T]]**2)
! + sqrt (eval Pt [extract index 1 [Z]]**2 + eval M [extract index 1 [Z]]**2)) / 2
scale = let subevt @clustered_jets = cluster [jet] in
let int njet = count [@clustered_jets] in
if njet == 2 then
( eval Pt [extract index 1 [@clustered_jets]]
+ eval Pt [extract index 2 [@clustered_jets]]) / 2
elsif njet == 3 then
( eval Pt [extract index 1 [@clustered_jets]]
+ eval Pt [extract index 2 [@clustered_jets]]
+ eval Pt [extract index 3 [@clustered_jets]]) / 2
else
sqrts
endif
?combined_nlo_integration = false
-?use_vamp_equivalences = false
mult_call_real = 10
mult_call_virt = 6
relative_error_goal = 0.009
process ppjj = pr, pr => jet, jet { nlo_calculation = full $restrictions="!W+:W-" }
integrate (ppjj) { iterations = 15:100000:"gw",5:60000 }
!integrate (ppjj) { iterations = 4:1000:"gw" }
Index: trunk/share/tests/ext_tests_nlo/ref-output/nlo_ppz.ref
===================================================================
--- trunk/share/tests/ext_tests_nlo/ref-output/nlo_ppz.ref (revision 8482)
+++ trunk/share/tests/ext_tests_nlo/ref-output/nlo_ppz.ref (revision 8483)
@@ -1,196 +1,199 @@
?openmp_logging = false
?vis_history = false
?integration_timer = false
openmp_num_threads = 1
?debug_decay = false
?debug_process = false
?debug_verbose = false
?write_raw = false
| Switching to model 'SM', scheme 'GF_MW_MZ'
$blha_ew_scheme = "alpha_qed"
SM.mZ => 9.118800000000E+01
SM.mW => 8.041900200000E+01
SM.mH => 1.250000000000E+02
SM.GF => 1.166390000000E-05
SM.wZ => 0.000000000000E+00
SM.wtop => 0.000000000000E+00
SM.wW => 0.000000000000E+00
SM.wH => 0.000000000000E+00
SM.ms => 0.000000000000E+00
SM.mc => 0.000000000000E+00
SM.mb => 0.000000000000E+00
SM.mtop => 1.732000000000E+02
SM.me => 0.000000000000E+00
SM.mmu => 0.000000000000E+00
SM.mtau => 1.777000000000E+00
SM.alphas => 1.180000000000E-01
?alphas_is_fixed = false
?alphas_from_mz = true
?alphas_from_lambda_qcd = false
alphas_nf = 5
alphas_order = 2
[user variable] jet = PDG(2, -2, 1, -1, 3, -3, 4, -4, 5, -5, 21)
$exclude_gauge_splittings = "t"
$method = "openloops"
seed = 8131
sqrts = 1.000000000000E+03
jet_algorithm = 2
jet_r = 5.000000000000E-01
-?use_vamp_equivalences = false
$integration_method = "vamp2"
$rng_method = "rng_stream"
| End of included 'nlo_settings.sin'
[user variable] pr = PDG(2, -2, 1, -1, 3, -3, 4, -4, 5, -5, 21)
$exclude_gauge_splittings = "t"
$lhapdf_file = "MSTW2008nlo68cl"
sqrts = 1.300000000000E+04
alpha_power = 1
alphas_power = 0
?alphas_from_mz = false
?alphas_from_lhapdf = true
?combined_nlo_integration = false
relative_error_goal = 4.000000000000E-03
| Process library 'nlo_ppz_lib': recorded process 'ppz'
| Integrate: current process library needs compilation
| Process library 'nlo_ppz_lib': compiling ...
| Process library 'nlo_ppz_lib': writing makefile
| Process library 'nlo_ppz_lib': removing old files
| Process library 'nlo_ppz_lib': writing driver
| Process library 'nlo_ppz_lib': creating source code
| Process library 'nlo_ppz_lib': compiling sources
| Process library 'nlo_ppz_lib': linking
| Process library 'nlo_ppz_lib': loading
| Process library 'nlo_ppz_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 8131
| Initializing integration for process ppz:
| Beam structure: p, p => lhapdf
| Beam data (collision):
| p (mass = 0.0000000E+00 GeV)
| p (mass = 0.0000000E+00 GeV)
| sqrts = 1.300000000000E+04 GeV
| Phase space: generating configuration ...
| Phase space: ... success.
| Phase space: writing configuration file 'ppz.i1.phs'
| Phase space: generating configuration ...
| Phase space: ... success.
| Phase space: writing configuration file 'ppz.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: [...]
| 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: [...]
| One-Loop-Provider: Using OpenLoops
| Loading library: [...]
| One-Loop-Provider: Using OpenLoops
| Loading library: [...]
| ------------------------------------------------------------------------
| Process [scattering]: 'ppz'
| Library name = 'nlo_ppz_lib'
| Process index = 1
| Process components:
| 1: 'ppz_i1': u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl, u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl => Z [openloops]
| 2: 'ppz_i2': dbar:d:ubar:u:sbar:s:cbar:c:bbar:b:gl, dbar:d:ubar:u:sbar:s:cbar:c:bbar:b:gl => Z, d:dbar:u:ubar:s:sbar:c:cbar:b:bbar:gl [openloops], [real]
| 3: 'ppz_i3': u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl, u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl => Z [openloops], [virtual]
| 4: 'ppz_i4': u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl, u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl => Z [inactive], [subtraction]
| 5: 'ppz_i5': u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl, u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl => Z [openloops], [dglap]
| ------------------------------------------------------------------------
| Phase space: 1 channels, 0 dimensions
| Phase space: found 1 channel, collected in 1 grove.
-| Phase space: no equivalences between channels used.
+| Phase space: Using 1 equivalence between channels.
| Phase space: wood
| Phase space: 1 channels, 3 dimensions
| Phase space: found 1 channel, collected in 1 grove.
-| Phase space: no equivalences between channels used.
+| Phase space: Using 1 equivalence between channels.
| Phase space: wood
| Phase space: 1 channels, 0 dimensions
| Phase space: found 1 channel, collected in 1 grove.
-| Phase space: no equivalences between channels used.
+| Phase space: Using 1 equivalence between channels.
| Phase space: wood
| Phase space: 1 channels, 1 dimensions
| Phase space: found 1 channel, collected in 1 grove.
-| Phase space: no equivalences between channels used.
+| Phase space: Using 1 equivalence between channels.
| Phase space: wood
| Beam structure: lhapdf, none => none, lhapdf
| Beam structure: 1 channels, 2 dimensions
| Applying user-defined cuts.
| Using user-defined general scale.
| Starting integration for process 'ppz' part 'born'
| Integrate: iterations = 1:100:"gw"
| Integrator: 1 chains, 1 channels, 2 dimensions
+| Integrator: Using VAMP2 channel equivalences
| 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 'ppz.m1.vg2'.
| VAMP2: set chain: use chained weights.
1 98 4.2228581E+07 6.40E+05 1.52 0.15* 69.02
|-----------------------------------------------------------------------------|
1 98 4.2228581E+07 6.40E+05 1.52 0.15 69.02
|=============================================================================|
| Starting integration for process 'ppz' part 'real'
| Integrate: iterations = 1:100:"gw"
| Integrator: 1 chains, 1 channels, 5 dimensions
+| Integrator: Using VAMP2 channel equivalences
| 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 'ppz.m2.vg2'.
| VAMP2: set chain: use chained weights.
1 96 3.2494859E+06 5.20E+05 16.01 1.57* 29.99
|-----------------------------------------------------------------------------|
1 96 3.2494859E+06 5.20E+05 16.01 1.57 29.99
|=============================================================================|
| Starting integration for process 'ppz' part 'virtual'
| Integrate: iterations = 1:100:"gw"
| Integrator: 1 chains, 1 channels, 2 dimensions
+| Integrator: Using VAMP2 channel equivalences
| 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 'ppz.m3.vg2'.
| VAMP2: set chain: use chained weights.
1 98 3.3188407E+06 5.09E+04 1.53 0.15* 69.37
|-----------------------------------------------------------------------------|
1 98 3.3188407E+06 5.09E+04 1.53 0.15 69.37
|=============================================================================|
| Starting integration for process 'ppz' part 'dglap'
| Integrate: iterations = 1:100:"gw"
| Integrator: 1 chains, 1 channels, 3 dimensions
+| Integrator: Using VAMP2 channel equivalences
| 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 'ppz.m4.vg2'.
| VAMP2: set chain: use chained weights.
1 81 7.2848842E+06 1.05E+06 14.43 1.30* 22.84
|-----------------------------------------------------------------------------|
1 81 7.2848842E+06 1.05E+06 14.43 1.30 22.84
|=============================================================================|
| Integrate: sum of all components
|=============================================================================|
| It Calls Integral[fb] Error[fb] Err[%] Acc Eff[%] Chi2 N[It] |
|=============================================================================|
1 0 5.6081792E+07 1.34E+06 2.38 0.00* 51.60
| NLO Correction: [O(alpha_s+1)/O(alpha_s)]
| ( 32.8053 +- 2.82358 ) %
|=============================================================================|
| WHIZARD run finished.
|=============================================================================|
Index: trunk/share/tests/ext_tests_nlo/ref-output/nlo_eetth.ref
===================================================================
--- trunk/share/tests/ext_tests_nlo/ref-output/nlo_eetth.ref (revision 8482)
+++ trunk/share/tests/ext_tests_nlo/ref-output/nlo_eetth.ref (revision 8483)
@@ -1,164 +1,166 @@
?openmp_logging = false
?vis_history = false
?integration_timer = false
openmp_num_threads = 1
?debug_decay = false
?debug_process = false
?debug_verbose = false
?write_raw = false
| Switching to model 'SM', scheme 'GF_MW_MZ'
$blha_ew_scheme = "alpha_qed"
SM.mZ => 9.118800000000E+01
SM.mW => 8.041900200000E+01
SM.mH => 1.250000000000E+02
SM.GF => 1.166390000000E-05
SM.wZ => 0.000000000000E+00
SM.wtop => 0.000000000000E+00
SM.wW => 0.000000000000E+00
SM.wH => 0.000000000000E+00
SM.ms => 0.000000000000E+00
SM.mc => 0.000000000000E+00
SM.mb => 0.000000000000E+00
SM.mtop => 1.732000000000E+02
SM.me => 0.000000000000E+00
SM.mmu => 0.000000000000E+00
SM.mtau => 1.777000000000E+00
SM.alphas => 1.180000000000E-01
?alphas_is_fixed = false
?alphas_from_mz = true
?alphas_from_lambda_qcd = false
alphas_nf = 5
alphas_order = 2
[user variable] jet = PDG(2, -2, 1, -1, 3, -3, 4, -4, 5, -5, 21)
$exclude_gauge_splittings = "t"
$method = "openloops"
seed = 8131
sqrts = 1.000000000000E+03
jet_algorithm = 2
jet_r = 5.000000000000E-01
-?use_vamp_equivalences = false
$integration_method = "vamp2"
$rng_method = "rng_stream"
| End of included 'nlo_settings.sin'
alpha_power = 3
alphas_power = 0
| Process library 'nlo_eetth_lib': recorded process 'nlo_eetth_p1'
| Integrate: current process library needs compilation
| Process library 'nlo_eetth_lib': compiling ...
| Process library 'nlo_eetth_lib': writing makefile
| Process library 'nlo_eetth_lib': removing old files
| Process library 'nlo_eetth_lib': writing driver
| Process library 'nlo_eetth_lib': creating source code
| Process library 'nlo_eetth_lib': compiling sources
| Process library 'nlo_eetth_lib': linking
| Process library 'nlo_eetth_lib': loading
| Process library 'nlo_eetth_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 8131
| Initializing integration for process nlo_eetth_p1:
| Beam structure: [any particles]
| Beam data (collision):
| e- (mass = 0.0000000E+00 GeV)
| e+ (mass = 0.0000000E+00 GeV)
| sqrts = 1.000000000000E+03 GeV
| Phase space: generating configuration ...
| Phase space: ... success.
| Phase space: writing configuration file 'nlo_eetth_p1.i1.phs'
| Phase space: generating configuration ...
| Phase space: ... success.
| Phase space: writing configuration file 'nlo_eetth_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: [...]
| 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]: 'nlo_eetth_p1'
| Library name = 'nlo_eetth_lib'
| Process index = 1
| Process components:
| 1: 'nlo_eetth_p1_i1': e-, e+ => t, tbar, H [openloops]
| 2: 'nlo_eetth_p1_i2': e-, e+ => t, tbar, H, gl [openloops], [real]
| 3: 'nlo_eetth_p1_i3': e-, e+ => t, tbar, H [openloops], [virtual]
| 4: 'nlo_eetth_p1_i4': e-, e+ => t, tbar, H [inactive], [subtraction]
| ------------------------------------------------------------------------
| Phase space: 3 channels, 5 dimensions
| Phase space: found 3 channels, collected in 1 grove.
-| Phase space: no equivalences between channels used.
+| Phase space: Using 3 equivalences between channels.
| Phase space: wood
| Phase space: 3 channels, 8 dimensions
| Phase space: found 3 channels, collected in 1 grove.
-| Phase space: no equivalences between channels used.
+| Phase space: Using 3 equivalences between channels.
| Phase space: wood
| Phase space: 3 channels, 5 dimensions
| Phase space: found 3 channels, collected in 1 grove.
-| Phase space: no equivalences between channels used.
+| Phase space: Using 3 equivalences between channels.
| Phase space: wood
Warning: No cuts have been defined.
| Using user-defined general scale.
| Starting integration for process 'nlo_eetth_p1' part 'born'
| Integrate: iterations = 1:100:"gw"
| Integrator: 1 chains, 3 channels, 5 dimensions
+| Integrator: Using VAMP2 channel equivalences
| 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 'nlo_eetth_p1.m1.vg2'.
| VAMP2: set chain: use chained weights.
1 99 2.0104544E+00 1.47E-01 7.33 0.73* 30.49
|-----------------------------------------------------------------------------|
1 99 2.0104544E+00 1.47E-01 7.33 0.73 30.49
|=============================================================================|
| Starting integration for process 'nlo_eetth_p1' part 'real'
| Integrate: iterations = 1:100:"gw"
| Integrator: 1 chains, 3 channels, 8 dimensions
+| Integrator: Using VAMP2 channel equivalences
| 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 'nlo_eetth_p1.m2.vg2'.
| VAMP2: set chain: use chained weights.
1 99 -4.0829431E-01 4.05E-02 9.92 0.99* 23.34
|-----------------------------------------------------------------------------|
1 99 -4.0829431E-01 4.05E-02 9.92 0.99 23.34
|=============================================================================|
| Starting integration for process 'nlo_eetth_p1' part 'virtual'
| Integrate: iterations = 1:100:"gw"
| Integrator: 1 chains, 3 channels, 5 dimensions
+| Integrator: Using VAMP2 channel equivalences
| 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 'nlo_eetth_p1.m3.vg2'.
| VAMP2: set chain: use chained weights.
1 99 3.0647296E-01 1.98E-02 6.46 0.64* 34.90
|-----------------------------------------------------------------------------|
1 99 3.0647296E-01 1.98E-02 6.46 0.64 34.90
|=============================================================================|
| Integrate: sum of all components
|=============================================================================|
| It Calls Integral[fb] Error[fb] Err[%] Acc Eff[%] Chi2 N[It] |
|=============================================================================|
1 0 1.9086331E+00 1.54E-01 8.07 0.00* 25.54
| NLO Correction: [O(alpha_s+1)/O(alpha_s)]
| ( -5.0646 +- 2.27315 ) %
|=============================================================================|
| There were no errors and 1 warning(s).
| WHIZARD run finished.
|=============================================================================|
Index: trunk/share/tests/ext_tests_nlo/ref-output/nlo_ppzj_sim_1.ref
===================================================================
--- trunk/share/tests/ext_tests_nlo/ref-output/nlo_ppzj_sim_1.ref (revision 8482)
+++ trunk/share/tests/ext_tests_nlo/ref-output/nlo_ppzj_sim_1.ref (revision 8483)
@@ -1,21734 +1,21734 @@
?openmp_logging = false
?vis_history = false
?integration_timer = false
?pacify = true
openmp_num_threads = 1
SM.mZ => 9.11880E+01
SM.wZ => 0.00000E+00
SM.ms => 0.00000E+00
[user variable] pr = PDG(2, -2, 1, -1, 3, -3, 21)
[user variable] jet = PDG(2, -2, 1, -1, 3, -3, 21)
[user variable] elec = PDG(11, -11)
$exclude_gauge_splittings = "c:b:t"
jet_algorithm = 2
jet_r = 5.00000E-01
$method = "openloops"
alpha_power = 1
alphas_power = 1
$rng_method = "rng_stream"
$integration_method = "vamp2"
sqrts = 1.30000E+04
?combined_nlo_integration = false
-?use_vamp_equivalences = false
seed = 3992
$restrictions = "!W+:W-"
| Process library 'nlo_ppzj_sim_1_lib': recorded process 'nlo_ppzj_sim_1_p1'
| Integrate: current process library needs compilation
| Process library 'nlo_ppzj_sim_1_lib': compiling ...
| Process library 'nlo_ppzj_sim_1_lib': writing makefile
| Process library 'nlo_ppzj_sim_1_lib': removing old files
| Process library 'nlo_ppzj_sim_1_lib': writing driver
| Process library 'nlo_ppzj_sim_1_lib': creating source code
| Process library 'nlo_ppzj_sim_1_lib': compiling sources
| Process library 'nlo_ppzj_sim_1_lib': linking
| Process library 'nlo_ppzj_sim_1_lib': loading
| Process library 'nlo_ppzj_sim_1_lib': ... success.
| Integrate: compilation done
| RNG: Initializing RNG Stream random-number generator
| RNG: Setting seed for random-number generator to 3992
| Initializing integration for process nlo_ppzj_sim_1_p1:
| Beam structure: p, p => pdf_builtin
| Beam data (collision):
| p (mass = 0.0000000E+00 GeV)
| p (mass = 0.0000000E+00 GeV)
| sqrts = 1.300000000000E+04 GeV
| Initialized builtin PDF CTEQ6L
| Phase space: generating configuration ...
| Phase space: ... success.
| Phase space: writing configuration file 'nlo_ppzj_sim_1_p1.i1.phs'
| Phase space: generating configuration ...
| Phase space: ... success.
| Phase space: writing configuration file 'nlo_ppzj_sim_1_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]: 'nlo_ppzj_sim_1_p1'
| Library name = 'nlo_ppzj_sim_1_lib'
| Process index = 1
| Process components:
| 1: 'nlo_ppzj_sim_1_p1_i1': u:ubar:d:dbar:s:sbar:gl, u:ubar:d:dbar:s:sbar:gl => Z, u:ubar:d:dbar:s:sbar:gl [inactive]
| 2: 'nlo_ppzj_sim_1_p1_i2': dbar:d:ubar:u:sbar:s:gl, dbar:d:ubar:u:sbar:s:gl => Z, d:dbar:u:ubar:s:sbar:gl, d:dbar:u:ubar:s:sbar:gl [openloops], [real]
| 3: 'nlo_ppzj_sim_1_p1_i3': u:ubar:d:dbar:s:sbar:gl, u:ubar:d:dbar:s:sbar:gl => Z, u:ubar:d:dbar:s:sbar:gl [inactive], [virtual]
| 4: 'nlo_ppzj_sim_1_p1_i4': u:ubar:d:dbar:s:sbar:gl, u:ubar:d:dbar:s:sbar:gl => Z, u:ubar:d:dbar:s:sbar:gl [inactive], [subtraction]
| 5: 'nlo_ppzj_sim_1_p1_i5': u:ubar:d:dbar:s:sbar:gl, u:ubar:d:dbar:s:sbar:gl => Z, u:ubar:d:dbar:s:sbar:gl [inactive], [dglap]
| ------------------------------------------------------------------------
| Phase space: 5 channels, 2 dimensions
| Phase space: found 5 channels, collected in 2 groves.
-| Phase space: no equivalences between channels used.
+| Phase space: Using 9 equivalences between channels.
| Phase space: wood
| Phase space: 5 channels, 5 dimensions
| Phase space: found 5 channels, collected in 2 groves.
-| Phase space: no equivalences between channels used.
+| Phase space: Using 9 equivalences between channels.
| Phase space: wood
| Phase space: 5 channels, 2 dimensions
| Phase space: found 5 channels, collected in 2 groves.
-| Phase space: no equivalences between channels used.
+| Phase space: Using 9 equivalences between channels.
| Phase space: wood
| Phase space: 5 channels, 3 dimensions
| Phase space: found 5 channels, collected in 2 groves.
-| Phase space: no equivalences between channels used.
+| Phase space: Using 9 equivalences between channels.
| Phase space: wood
| Beam structure: pdf_builtin, none => none, pdf_builtin
| Beam structure: 1 channels, 2 dimensions
| Applying user-defined cuts.
| Using user-defined general scale.
| Starting integration for process 'nlo_ppzj_sim_1_p1' part 'real'
| Integrate: iterations = 1:100
| Integrator: 2 chains, 5 channels, 7 dimensions
+| Integrator: Using VAMP2 channel equivalences
| 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 'nlo_ppzj_sim_1_p1.m2.vg2'.
| VAMP2: set chain: use chained weights.
1 100 3.332E+02 2.22E+02 66.61 6.66 6.1
|-----------------------------------------------------------------------------|
1 100 3.332E+02 2.22E+02 66.61 6.66 6.1
|=============================================================================|
| Integrate: sum of all components
|=============================================================================|
| It Calls Integral[fb] Error[fb] Err[%] Acc Eff[%] Chi2 N[It] |
|=============================================================================|
1 0 3.332E+02 2.22E+02 66.61 0.00 6.1
|=============================================================================|
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 'nlo_ppzj_sim_1_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
| RNG: Initializing RNG Stream random-number generator
| RNG: Setting seed for random-number generator to 3993
| Events: writing to ASCII file 'nlo_ppzj_sim_1_p1.debug'
| Events: generating 50 weighted, unpolarized NLO events ...
| Events: event normalization mode 'sigma'
| ... event sample complete.
| Events: closing ASCII file 'nlo_ppzj_sim_1_p1.debug'
| WHIZARD run finished.
|=============================================================================|
Total number of regions: 150
alr || flst_real || i_real || em || mul || nreg || ftuples || flst_born || i_born
1 || [ -2, -2, 23, -2, -2] || 1 || 2 || 2 || 4 || {(1,4),(1,5),(2,4),(2,5)} || [ -2, 21, 23, -2] || 2
2 || [ -2, -2, 23, -2, -2] || 1 || 1 || 2 || 4 || {(1,4),(1,5),(2,4),(2,5)} || [ 21, -2, 23, -2] || 13
3 || [ -2, 2, 23, -2, 2] || 2 || 4 || 1 || 3 || {(1,4),(2,5),(4,5)} || [ -2, 2, 23, 21] || 1
4 || [ -2, 2, 23, -2, 2] || 2 || 2 || 1 || 3 || {(1,4),(2,5),(4,5)} || [ -2, 21, 23, -2] || 2
5 || [ -2, 2, 23, 2, -2] || 3 || 1 || 1 || 3 || {(1,5),(2,4),(4,5)} || [ 21, 2, 23, 2] || 14
6 || [ -2, 2, 23, -3, 3] || 4 || 4 || 1 || 1 || {(4,5)} || [ -2, 2, 23, 21] || 1
7 || [ -2, 2, 23, -1, 1] || 5 || 4 || 1 || 1 || {(4,5)} || [ -2, 2, 23, 21] || 1
8 || [ -2, 2, 23, 21, 21] || 6 || 4 || 1 || 3 || {(0,4),(0,5),(4,5)} || [ -2, 2, 23, 21] || 1
9 || [ -2, 2, 23, 21, 21] || 6 || 0 || 2 || 3 || {(0,4),(0,5),(4,5)} || [ -2, 2, 23, 21] || 1
10 || [ -2, -3, 23, -2, -3] || 7 || 2 || 1 || 2 || {(1,4),(2,5)} || [ -2, 21, 23, -2] || 2
11 || [ -2, -3, 23, -3, -2] || 8 || 1 || 1 || 2 || {(1,5),(2,4)} || [ 21, -3, 23, -3] || 15
12 || [ -2, -1, 23, -2, -1] || 9 || 2 || 1 || 2 || {(1,4),(2,5)} || [ -2, 21, 23, -2] || 2
13 || [ -2, -1, 23, -1, -2] || 10 || 1 || 1 || 2 || {(1,5),(2,4)} || [ 21, -1, 23, -1] || 16
14 || [ -2, 1, 23, -2, 1] || 11 || 2 || 1 || 2 || {(1,4),(2,5)} || [ -2, 21, 23, -2] || 2
15 || [ -2, 1, 23, 1, -2] || 12 || 1 || 1 || 2 || {(1,5),(2,4)} || [ 21, 1, 23, 1] || 17
16 || [ -2, 3, 23, -2, 3] || 13 || 2 || 1 || 2 || {(1,4),(2,5)} || [ -2, 21, 23, -2] || 2
17 || [ -2, 3, 23, 3, -2] || 14 || 1 || 1 || 2 || {(1,5),(2,4)} || [ 21, 3, 23, 3] || 18
18 || [ -2, 21, 23, 21, -2] || 15 || 2 || 1 || 3 || {(0,4),(2,5),(4,5)} || [ -2, 2, 23, 21] || 1
19 || [ -2, 21, 23, -2, 21] || 16 || 4 || 1 || 3 || {(0,5),(2,4),(4,5)} || [ -2, 21, 23, -2] || 2
20 || [ -2, 21, 23, -2, 21] || 16 || 0 || 1 || 3 || {(0,5),(2,4),(4,5)} || [ -2, 21, 23, -2] || 2
21 || [ 2, -2, 23, -2, 2] || 17 || 4 || 1 || 3 || {(1,5),(2,4),(4,5)} || [ 2, -2, 23, 21] || 3
22 || [ 2, -2, 23, 2, -2] || 18 || 2 || 1 || 3 || {(1,4),(2,5),(4,5)} || [ 2, 21, 23, 2] || 4
23 || [ 2, -2, 23, -2, 2] || 17 || 1 || 1 || 3 || {(1,5),(2,4),(4,5)} || [ 21, -2, 23, -2] || 13
24 || [ 2, -2, 23, -3, 3] || 19 || 4 || 1 || 1 || {(4,5)} || [ 2, -2, 23, 21] || 3
25 || [ 2, -2, 23, -1, 1] || 20 || 4 || 1 || 1 || {(4,5)} || [ 2, -2, 23, 21] || 3
26 || [ 2, -2, 23, 21, 21] || 21 || 4 || 1 || 3 || {(0,4),(0,5),(4,5)} || [ 2, -2, 23, 21] || 3
27 || [ 2, -2, 23, 21, 21] || 21 || 0 || 2 || 3 || {(0,4),(0,5),(4,5)} || [ 2, -2, 23, 21] || 3
28 || [ 2, 2, 23, 2, 2] || 22 || 2 || 2 || 4 || {(1,4),(1,5),(2,4),(2,5)} || [ 2, 21, 23, 2] || 4
29 || [ 2, 2, 23, 2, 2] || 22 || 1 || 2 || 4 || {(1,4),(1,5),(2,4),(2,5)} || [ 21, 2, 23, 2] || 14
30 || [ 2, -3, 23, 2, -3] || 23 || 2 || 1 || 2 || {(1,4),(2,5)} || [ 2, 21, 23, 2] || 4
31 || [ 2, -3, 23, -3, 2] || 24 || 1 || 1 || 2 || {(1,5),(2,4)} || [ 21, -3, 23, -3] || 15
32 || [ 2, -1, 23, 2, -1] || 25 || 2 || 1 || 2 || {(1,4),(2,5)} || [ 2, 21, 23, 2] || 4
33 || [ 2, -1, 23, -1, 2] || 26 || 1 || 1 || 2 || {(1,5),(2,4)} || [ 21, -1, 23, -1] || 16
34 || [ 2, 1, 23, 2, 1] || 27 || 2 || 1 || 2 || {(1,4),(2,5)} || [ 2, 21, 23, 2] || 4
35 || [ 2, 1, 23, 1, 2] || 28 || 1 || 1 || 2 || {(1,5),(2,4)} || [ 21, 1, 23, 1] || 17
36 || [ 2, 3, 23, 2, 3] || 29 || 2 || 1 || 2 || {(1,4),(2,5)} || [ 2, 21, 23, 2] || 4
37 || [ 2, 3, 23, 3, 2] || 30 || 1 || 1 || 2 || {(1,5),(2,4)} || [ 21, 3, 23, 3] || 18
38 || [ 2, 21, 23, 21, 2] || 31 || 2 || 1 || 3 || {(0,4),(2,5),(4,5)} || [ 2, -2, 23, 21] || 3
39 || [ 2, 21, 23, 2, 21] || 32 || 4 || 1 || 3 || {(0,5),(2,4),(4,5)} || [ 2, 21, 23, 2] || 4
40 || [ 2, 21, 23, 2, 21] || 32 || 0 || 1 || 3 || {(0,5),(2,4),(4,5)} || [ 2, 21, 23, 2] || 4
41 || [ -3, -2, 23, -3, -2] || 33 || 2 || 1 || 2 || {(1,4),(2,5)} || [ -3, 21, 23, -3] || 6
42 || [ -3, -2, 23, -2, -3] || 34 || 1 || 1 || 2 || {(1,5),(2,4)} || [ 21, -2, 23, -2] || 13
43 || [ -3, 2, 23, -3, 2] || 35 || 2 || 1 || 2 || {(1,4),(2,5)} || [ -3, 21, 23, -3] || 6
44 || [ -3, 2, 23, 2, -3] || 36 || 1 || 1 || 2 || {(1,5),(2,4)} || [ 21, 2, 23, 2] || 14
45 || [ -3, -3, 23, -3, -3] || 37 || 2 || 2 || 4 || {(1,4),(1,5),(2,4),(2,5)} || [ -3, 21, 23, -3] || 6
46 || [ -3, -3, 23, -3, -3] || 37 || 1 || 2 || 4 || {(1,4),(1,5),(2,4),(2,5)} || [ 21, -3, 23, -3] || 15
47 || [ -3, -1, 23, -3, -1] || 38 || 2 || 1 || 2 || {(1,4),(2,5)} || [ -3, 21, 23, -3] || 6
48 || [ -3, -1, 23, -1, -3] || 39 || 1 || 1 || 2 || {(1,5),(2,4)} || [ 21, -1, 23, -1] || 16
49 || [ -3, 1, 23, -3, 1] || 40 || 2 || 1 || 2 || {(1,4),(2,5)} || [ -3, 21, 23, -3] || 6
50 || [ -3, 1, 23, 1, -3] || 41 || 1 || 1 || 2 || {(1,5),(2,4)} || [ 21, 1, 23, 1] || 17
51 || [ -3, 3, 23, -2, 2] || 42 || 4 || 1 || 1 || {(4,5)} || [ -3, 3, 23, 21] || 5
52 || [ -3, 3, 23, -3, 3] || 43 || 4 || 1 || 3 || {(1,4),(2,5),(4,5)} || [ -3, 3, 23, 21] || 5
53 || [ -3, 3, 23, -3, 3] || 43 || 2 || 1 || 3 || {(1,4),(2,5),(4,5)} || [ -3, 21, 23, -3] || 6
54 || [ -3, 3, 23, 3, -3] || 44 || 1 || 1 || 3 || {(1,5),(2,4),(4,5)} || [ 21, 3, 23, 3] || 18
55 || [ -3, 3, 23, -1, 1] || 45 || 4 || 1 || 1 || {(4,5)} || [ -3, 3, 23, 21] || 5
56 || [ -3, 3, 23, 21, 21] || 46 || 4 || 1 || 3 || {(0,4),(0,5),(4,5)} || [ -3, 3, 23, 21] || 5
57 || [ -3, 3, 23, 21, 21] || 46 || 0 || 2 || 3 || {(0,4),(0,5),(4,5)} || [ -3, 3, 23, 21] || 5
58 || [ -3, 21, 23, 21, -3] || 47 || 2 || 1 || 3 || {(0,4),(2,5),(4,5)} || [ -3, 3, 23, 21] || 5
59 || [ -3, 21, 23, -3, 21] || 48 || 4 || 1 || 3 || {(0,5),(2,4),(4,5)} || [ -3, 21, 23, -3] || 6
60 || [ -3, 21, 23, -3, 21] || 48 || 0 || 1 || 3 || {(0,5),(2,4),(4,5)} || [ -3, 21, 23, -3] || 6
61 || [ -1, -2, 23, -1, -2] || 49 || 2 || 1 || 2 || {(1,4),(2,5)} || [ -1, 21, 23, -1] || 8
62 || [ -1, -2, 23, -2, -1] || 50 || 1 || 1 || 2 || {(1,5),(2,4)} || [ 21, -2, 23, -2] || 13
63 || [ -1, 2, 23, -1, 2] || 51 || 2 || 1 || 2 || {(1,4),(2,5)} || [ -1, 21, 23, -1] || 8
64 || [ -1, 2, 23, 2, -1] || 52 || 1 || 1 || 2 || {(1,5),(2,4)} || [ 21, 2, 23, 2] || 14
65 || [ -1, -3, 23, -1, -3] || 53 || 2 || 1 || 2 || {(1,4),(2,5)} || [ -1, 21, 23, -1] || 8
66 || [ -1, -3, 23, -3, -1] || 54 || 1 || 1 || 2 || {(1,5),(2,4)} || [ 21, -3, 23, -3] || 15
67 || [ -1, -1, 23, -1, -1] || 55 || 2 || 2 || 4 || {(1,4),(1,5),(2,4),(2,5)} || [ -1, 21, 23, -1] || 8
68 || [ -1, -1, 23, -1, -1] || 55 || 1 || 2 || 4 || {(1,4),(1,5),(2,4),(2,5)} || [ 21, -1, 23, -1] || 16
69 || [ -1, 1, 23, -2, 2] || 56 || 4 || 1 || 1 || {(4,5)} || [ -1, 1, 23, 21] || 7
70 || [ -1, 1, 23, -3, 3] || 57 || 4 || 1 || 1 || {(4,5)} || [ -1, 1, 23, 21] || 7
71 || [ -1, 1, 23, -1, 1] || 58 || 4 || 1 || 3 || {(1,4),(2,5),(4,5)} || [ -1, 1, 23, 21] || 7
72 || [ -1, 1, 23, -1, 1] || 58 || 2 || 1 || 3 || {(1,4),(2,5),(4,5)} || [ -1, 21, 23, -1] || 8
73 || [ -1, 1, 23, 1, -1] || 59 || 1 || 1 || 3 || {(1,5),(2,4),(4,5)} || [ 21, 1, 23, 1] || 17
74 || [ -1, 1, 23, 21, 21] || 60 || 4 || 1 || 3 || {(0,4),(0,5),(4,5)} || [ -1, 1, 23, 21] || 7
75 || [ -1, 1, 23, 21, 21] || 60 || 0 || 2 || 3 || {(0,4),(0,5),(4,5)} || [ -1, 1, 23, 21] || 7
76 || [ -1, 3, 23, -1, 3] || 61 || 2 || 1 || 2 || {(1,4),(2,5)} || [ -1, 21, 23, -1] || 8
77 || [ -1, 3, 23, 3, -1] || 62 || 1 || 1 || 2 || {(1,5),(2,4)} || [ 21, 3, 23, 3] || 18
78 || [ -1, 21, 23, 21, -1] || 63 || 2 || 1 || 3 || {(0,4),(2,5),(4,5)} || [ -1, 1, 23, 21] || 7
79 || [ -1, 21, 23, -1, 21] || 64 || 4 || 1 || 3 || {(0,5),(2,4),(4,5)} || [ -1, 21, 23, -1] || 8
80 || [ -1, 21, 23, -1, 21] || 64 || 0 || 1 || 3 || {(0,5),(2,4),(4,5)} || [ -1, 21, 23, -1] || 8
81 || [ 1, -2, 23, 1, -2] || 65 || 2 || 1 || 2 || {(1,4),(2,5)} || [ 1, 21, 23, 1] || 10
82 || [ 1, -2, 23, -2, 1] || 66 || 1 || 1 || 2 || {(1,5),(2,4)} || [ 21, -2, 23, -2] || 13
83 || [ 1, 2, 23, 1, 2] || 67 || 2 || 1 || 2 || {(1,4),(2,5)} || [ 1, 21, 23, 1] || 10
84 || [ 1, 2, 23, 2, 1] || 68 || 1 || 1 || 2 || {(1,5),(2,4)} || [ 21, 2, 23, 2] || 14
85 || [ 1, -3, 23, 1, -3] || 69 || 2 || 1 || 2 || {(1,4),(2,5)} || [ 1, 21, 23, 1] || 10
86 || [ 1, -3, 23, -3, 1] || 70 || 1 || 1 || 2 || {(1,5),(2,4)} || [ 21, -3, 23, -3] || 15
87 || [ 1, -1, 23, -2, 2] || 71 || 4 || 1 || 1 || {(4,5)} || [ 1, -1, 23, 21] || 9
88 || [ 1, -1, 23, -3, 3] || 72 || 4 || 1 || 1 || {(4,5)} || [ 1, -1, 23, 21] || 9
89 || [ 1, -1, 23, -1, 1] || 73 || 4 || 1 || 3 || {(1,5),(2,4),(4,5)} || [ 1, -1, 23, 21] || 9
90 || [ 1, -1, 23, 1, -1] || 74 || 2 || 1 || 3 || {(1,4),(2,5),(4,5)} || [ 1, 21, 23, 1] || 10
91 || [ 1, -1, 23, -1, 1] || 73 || 1 || 1 || 3 || {(1,5),(2,4),(4,5)} || [ 21, -1, 23, -1] || 16
92 || [ 1, -1, 23, 21, 21] || 75 || 4 || 1 || 3 || {(0,4),(0,5),(4,5)} || [ 1, -1, 23, 21] || 9
93 || [ 1, -1, 23, 21, 21] || 75 || 0 || 2 || 3 || {(0,4),(0,5),(4,5)} || [ 1, -1, 23, 21] || 9
94 || [ 1, 1, 23, 1, 1] || 76 || 2 || 2 || 4 || {(1,4),(1,5),(2,4),(2,5)} || [ 1, 21, 23, 1] || 10
95 || [ 1, 1, 23, 1, 1] || 76 || 1 || 2 || 4 || {(1,4),(1,5),(2,4),(2,5)} || [ 21, 1, 23, 1] || 17
96 || [ 1, 3, 23, 1, 3] || 77 || 2 || 1 || 2 || {(1,4),(2,5)} || [ 1, 21, 23, 1] || 10
97 || [ 1, 3, 23, 3, 1] || 78 || 1 || 1 || 2 || {(1,5),(2,4)} || [ 21, 3, 23, 3] || 18
98 || [ 1, 21, 23, 21, 1] || 79 || 2 || 1 || 3 || {(0,4),(2,5),(4,5)} || [ 1, -1, 23, 21] || 9
99 || [ 1, 21, 23, 1, 21] || 80 || 4 || 1 || 3 || {(0,5),(2,4),(4,5)} || [ 1, 21, 23, 1] || 10
100 || [ 1, 21, 23, 1, 21] || 80 || 0 || 1 || 3 || {(0,5),(2,4),(4,5)} || [ 1, 21, 23, 1] || 10
101 || [ 3, -2, 23, 3, -2] || 81 || 2 || 1 || 2 || {(1,4),(2,5)} || [ 3, 21, 23, 3] || 12
102 || [ 3, -2, 23, -2, 3] || 82 || 1 || 1 || 2 || {(1,5),(2,4)} || [ 21, -2, 23, -2] || 13
103 || [ 3, 2, 23, 3, 2] || 83 || 2 || 1 || 2 || {(1,4),(2,5)} || [ 3, 21, 23, 3] || 12
104 || [ 3, 2, 23, 2, 3] || 84 || 1 || 1 || 2 || {(1,5),(2,4)} || [ 21, 2, 23, 2] || 14
105 || [ 3, -3, 23, -2, 2] || 85 || 4 || 1 || 1 || {(4,5)} || [ 3, -3, 23, 21] || 11
106 || [ 3, -3, 23, -3, 3] || 86 || 4 || 1 || 3 || {(1,5),(2,4),(4,5)} || [ 3, -3, 23, 21] || 11
107 || [ 3, -3, 23, 3, -3] || 87 || 2 || 1 || 3 || {(1,4),(2,5),(4,5)} || [ 3, 21, 23, 3] || 12
108 || [ 3, -3, 23, -3, 3] || 86 || 1 || 1 || 3 || {(1,5),(2,4),(4,5)} || [ 21, -3, 23, -3] || 15
109 || [ 3, -3, 23, -1, 1] || 88 || 4 || 1 || 1 || {(4,5)} || [ 3, -3, 23, 21] || 11
110 || [ 3, -3, 23, 21, 21] || 89 || 4 || 1 || 3 || {(0,4),(0,5),(4,5)} || [ 3, -3, 23, 21] || 11
111 || [ 3, -3, 23, 21, 21] || 89 || 0 || 2 || 3 || {(0,4),(0,5),(4,5)} || [ 3, -3, 23, 21] || 11
112 || [ 3, -1, 23, 3, -1] || 90 || 2 || 1 || 2 || {(1,4),(2,5)} || [ 3, 21, 23, 3] || 12
113 || [ 3, -1, 23, -1, 3] || 91 || 1 || 1 || 2 || {(1,5),(2,4)} || [ 21, -1, 23, -1] || 16
114 || [ 3, 1, 23, 3, 1] || 92 || 2 || 1 || 2 || {(1,4),(2,5)} || [ 3, 21, 23, 3] || 12
115 || [ 3, 1, 23, 1, 3] || 93 || 1 || 1 || 2 || {(1,5),(2,4)} || [ 21, 1, 23, 1] || 17
116 || [ 3, 3, 23, 3, 3] || 94 || 2 || 2 || 4 || {(1,4),(1,5),(2,4),(2,5)} || [ 3, 21, 23, 3] || 12
117 || [ 3, 3, 23, 3, 3] || 94 || 1 || 2 || 4 || {(1,4),(1,5),(2,4),(2,5)} || [ 21, 3, 23, 3] || 18
118 || [ 3, 21, 23, 21, 3] || 95 || 2 || 1 || 3 || {(0,4),(2,5),(4,5)} || [ 3, -3, 23, 21] || 11
119 || [ 3, 21, 23, 3, 21] || 96 || 4 || 1 || 3 || {(0,5),(2,4),(4,5)} || [ 3, 21, 23, 3] || 12
120 || [ 3, 21, 23, 3, 21] || 96 || 0 || 1 || 3 || {(0,5),(2,4),(4,5)} || [ 3, 21, 23, 3] || 12
121 || [ 21, -2, 23, 21, -2] || 97 || 1 || 1 || 3 || {(0,4),(1,5),(4,5)} || [ 2, -2, 23, 21] || 3
122 || [ 21, -2, 23, -2, 21] || 98 || 4 || 1 || 3 || {(0,5),(1,4),(4,5)} || [ 21, -2, 23, -2] || 13
123 || [ 21, -2, 23, -2, 21] || 98 || 0 || 1 || 3 || {(0,5),(1,4),(4,5)} || [ 21, -2, 23, -2] || 13
124 || [ 21, 2, 23, 21, 2] || 99 || 1 || 1 || 3 || {(0,4),(1,5),(4,5)} || [ -2, 2, 23, 21] || 1
125 || [ 21, 2, 23, 2, 21] || 100 || 4 || 1 || 3 || {(0,5),(1,4),(4,5)} || [ 21, 2, 23, 2] || 14
126 || [ 21, 2, 23, 2, 21] || 100 || 0 || 1 || 3 || {(0,5),(1,4),(4,5)} || [ 21, 2, 23, 2] || 14
127 || [ 21, -3, 23, 21, -3] || 101 || 1 || 1 || 3 || {(0,4),(1,5),(4,5)} || [ 3, -3, 23, 21] || 11
128 || [ 21, -3, 23, -3, 21] || 102 || 4 || 1 || 3 || {(0,5),(1,4),(4,5)} || [ 21, -3, 23, -3] || 15
129 || [ 21, -3, 23, -3, 21] || 102 || 0 || 1 || 3 || {(0,5),(1,4),(4,5)} || [ 21, -3, 23, -3] || 15
130 || [ 21, -1, 23, 21, -1] || 103 || 1 || 1 || 3 || {(0,4),(1,5),(4,5)} || [ 1, -1, 23, 21] || 9
131 || [ 21, -1, 23, -1, 21] || 104 || 4 || 1 || 3 || {(0,5),(1,4),(4,5)} || [ 21, -1, 23, -1] || 16
132 || [ 21, -1, 23, -1, 21] || 104 || 0 || 1 || 3 || {(0,5),(1,4),(4,5)} || [ 21, -1, 23, -1] || 16
133 || [ 21, 1, 23, 21, 1] || 105 || 1 || 1 || 3 || {(0,4),(1,5),(4,5)} || [ -1, 1, 23, 21] || 7
134 || [ 21, 1, 23, 1, 21] || 106 || 4 || 1 || 3 || {(0,5),(1,4),(4,5)} || [ 21, 1, 23, 1] || 17
135 || [ 21, 1, 23, 1, 21] || 106 || 0 || 1 || 3 || {(0,5),(1,4),(4,5)} || [ 21, 1, 23, 1] || 17
136 || [ 21, 3, 23, 21, 3] || 107 || 1 || 1 || 3 || {(0,4),(1,5),(4,5)} || [ -3, 3, 23, 21] || 5
137 || [ 21, 3, 23, 3, 21] || 108 || 4 || 1 || 3 || {(0,5),(1,4),(4,5)} || [ 21, 3, 23, 3] || 18
138 || [ 21, 3, 23, 3, 21] || 108 || 0 || 1 || 3 || {(0,5),(1,4),(4,5)} || [ 21, 3, 23, 3] || 18
139 || [ 21, 21, 23, -2, 2] || 109 || 1 || 1 || 4 || {(1,4),(1,5),(2,4),(2,5)} || [ -2, 21, 23, -2] || 2
140 || [ 21, 21, 23, 2, -2] || 110 || 1 || 1 || 4 || {(1,4),(1,5),(2,4),(2,5)} || [ 2, 21, 23, 2] || 4
141 || [ 21, 21, 23, -2, 2] || 109 || 2 || 1 || 4 || {(1,4),(1,5),(2,4),(2,5)} || [ 21, -2, 23, -2] || 13
142 || [ 21, 21, 23, 2, -2] || 110 || 2 || 1 || 4 || {(1,4),(1,5),(2,4),(2,5)} || [ 21, 2, 23, 2] || 14
143 || [ 21, 21, 23, -3, 3] || 111 || 1 || 1 || 4 || {(1,4),(1,5),(2,4),(2,5)} || [ -3, 21, 23, -3] || 6
144 || [ 21, 21, 23, 3, -3] || 112 || 1 || 1 || 4 || {(1,4),(1,5),(2,4),(2,5)} || [ 3, 21, 23, 3] || 12
145 || [ 21, 21, 23, -3, 3] || 111 || 2 || 1 || 4 || {(1,4),(1,5),(2,4),(2,5)} || [ 21, -3, 23, -3] || 15
146 || [ 21, 21, 23, 3, -3] || 112 || 2 || 1 || 4 || {(1,4),(1,5),(2,4),(2,5)} || [ 21, 3, 23, 3] || 18
147 || [ 21, 21, 23, -1, 1] || 113 || 1 || 1 || 4 || {(1,4),(1,5),(2,4),(2,5)} || [ -1, 21, 23, -1] || 8
148 || [ 21, 21, 23, 1, -1] || 114 || 1 || 1 || 4 || {(1,4),(1,5),(2,4),(2,5)} || [ 1, 21, 23, 1] || 10
149 || [ 21, 21, 23, -1, 1] || 113 || 2 || 1 || 4 || {(1,4),(1,5),(2,4),(2,5)} || [ 21, -1, 23, -1] || 16
150 || [ 21, 21, 23, 1, -1] || 114 || 2 || 1 || 4 || {(1,4),(1,5),(2,4),(2,5)} || [ 21, 1, 23, 1] || 17
------------------------------------------------------------------------
Contents of nlo_ppzj_sim_1_p1.debug:
========================================================================
Event #1
------------------------------------------------------------------------
Unweighted = F
Normalization = 'sigma'
Helicity handling = drop
Keep correlations = F
------------------------------------------------------------------------
Squared matrix el. (ref) = 6.23269E-05
Squared matrix el. (prc) = -1.50152E-03
Event weight (ref) = 6.43591E-06
Event weight (prc) = 0.00000E+00
------------------------------------------------------------------------
Selected MCI group = 2
Selected term = 6
Selected channel = 4
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
4015284228.0, 1428895961.0, 2071492269.0,
3117534565.0, 2289027307.0, 4233842702.0,
]
Beginning substream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Initial stream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 6.289731E+03
P = 0.000000E+00 0.000000E+00 6.289731E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(-2)
E = 1.633504E+03
P = 0.000000E+00 0.000000E+00 -1.633504E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(-92*)
E = 2.102692E+02
P = 0.000000E+00 0.000000E+00 2.102692E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 4.866496E+03
P = 0.000000E+00 0.000000E+00 -4.866496E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.634990E+03
P = 4.276637E+01 -6.814158E+00 -1.631870E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 6.288246E+03
P = -4.276637E+01 6.814158E+00 6.288096E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
3639474729.0, 1047239815.0, 4115866610.0,
2318295613.0, 4202845922.0, 2012988632.0,
]
Beginning substream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Initial stream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 6.346155E+03
P = 0.000000E+00 0.000000E+00 6.346155E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 1.636520E+03
P = 0.000000E+00 0.000000E+00 -1.636520E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 1.538455E+02
P = 0.000000E+00 0.000000E+00 1.538455E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 4.863480E+03
P = 0.000000E+00 0.000000E+00 -4.863480E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.635092E+03
P = 4.885535E+01 4.684648E+00 -1.631810E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 6.288208E+03
P = -3.667996E+01 1.830811E+01 6.288074E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 5.937394E+01
P = -1.217539E+01 -2.299276E+01 5.337001E+01
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 1.672101149E-04
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 6.289731E+03
P = 0.000000E+00 0.000000E+00 6.289731E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 1.633504E+03
P = 0.000000E+00 0.000000E+00 -1.633504E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 2.102692E+02
P = 0.000000E+00 0.000000E+00 2.102692E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 4.866496E+03
P = 0.000000E+00 0.000000E+00 -4.866496E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.634990E+03
P = 4.276637E+01 -6.814158E+00 -1.631870E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 6.288246E+03
P = -4.276637E+01 6.814158E+00 6.288096E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 6.346155E+03
P = 0.000000E+00 0.000000E+00 6.346155E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 1.636520E+03
P = 0.000000E+00 0.000000E+00 -1.636520E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 1.538455E+02
P = 0.000000E+00 0.000000E+00 1.538455E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 4.863480E+03
P = 0.000000E+00 0.000000E+00 -4.863480E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.635092E+03
P = 4.885535E+01 4.684648E+00 -1.631810E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 6.288208E+03
P = -3.667996E+01 1.830811E+01 6.288074E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 5.937394E+01
P = -1.217539E+01 -2.299276E+01 5.337001E+01
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 6.346155E+03
P = 0.000000E+00 0.000000E+00 6.346155E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 1.636520E+03
P = 0.000000E+00 0.000000E+00 -1.636520E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 1.538455E+02
P = 0.000000E+00 0.000000E+00 1.538455E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 4.863480E+03
P = 0.000000E+00 0.000000E+00 -4.863480E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.635092E+03
P = 4.885535E+01 4.684648E+00 -1.631810E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 6.288208E+03
P = -3.667996E+01 1.830811E+01 6.288074E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 5.937394E+01
P = -1.217539E+01 -2.299276E+01 5.337001E+01
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-1)
E = 6.289731E+03
P = 0.000000E+00 0.000000E+00 6.289731E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(1)
E = 1.633504E+03
P = 0.000000E+00 0.000000E+00 -1.633504E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 2.102692E+02
P = 0.000000E+00 0.000000E+00 2.102692E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 4.866496E+03
P = 0.000000E+00 0.000000E+00 -4.866496E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.576471E+03
P = 4.123264E+01 -6.569783E+00 -1.573278E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-1)
E = 4.744229E+03
P = 4.645959E+02 1.745310E+02 4.718199E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(1)
E = 1.602534E+03
P = -5.058286E+02 -1.679612E+02 1.511305E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 6.346155E+03
P = 0.000000E+00 0.000000E+00 6.346155E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 1.636520E+03
P = 0.000000E+00 0.000000E+00 -1.636520E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 1.538455E+02
P = 0.000000E+00 0.000000E+00 1.538455E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 4.863480E+03
P = 0.000000E+00 0.000000E+00 -4.863480E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.635092E+03
P = 4.885535E+01 4.684648E+00 -1.631810E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 6.288208E+03
P = -3.667996E+01 1.830811E+01 6.288074E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 5.937394E+01
P = -1.217539E+01 -2.299276E+01 5.337001E+01
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 6.41071E+03
n_in* => 2
n_out* => 4
n_tot* => 6
$process_id* => "nlo_ppzj_sim_1_p1"
process_num_id* => [unknown integer]
sqme* => -1.50152E-03
sqme_ref* => 6.23269E-05
event_index* => 1
event_weight* => 0.00000E+00
event_weight_ref* => 6.43591E-06
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:-2|-6.2897308E+03; 0.0000000E+00, 0.0000000E+00,-6.2897308E+03| 0.0000000E+00| 3)
4 prt(i:2|-1.6335044E+03; 0.0000000E+00, 0.0000000E+00, 1.6335044E+03| 0.0000000E+00| 4)
5 prt(o:92| 2.1026925E+02; 0.0000000E+00, 0.0000000E+00, 2.1026925E+02| 0.0000000E+00| 5)
6 prt(o:-92| 4.8664956E+03; 0.0000000E+00, 0.0000000E+00,-4.8664956E+03| 0.0000000E+00| 6)
7 prt(o:23| 1.6349895E+03; 4.2766367E+01,-6.8141582E+00,-1.6318701E+03| 8.3152513E+03| 7)
8 prt(o:21| 6.2882456E+03;-4.2766367E+01, 6.8141582E+00, 6.2880965E+03| 0.0000000E+00| 8)
========================================================================
========================================================================
Event #1
------------------------------------------------------------------------
Unweighted = F
Normalization = 'sigma'
Helicity handling = drop
Keep correlations = F
------------------------------------------------------------------------
Squared matrix el. (ref) = 6.23269E-05
Squared matrix el. (prc) = 3.89196E-02
Event weight (ref) = 6.43591E-06
Event weight (prc) = 0.00000E+00
------------------------------------------------------------------------
Selected MCI group = 2
Selected term = 6
Selected channel = 4
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
4015284228.0, 1428895961.0, 2071492269.0,
3117534565.0, 2289027307.0, 4233842702.0,
]
Beginning substream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Initial stream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 6.289731E+03
P = 0.000000E+00 0.000000E+00 6.289731E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(-2)
E = 1.633504E+03
P = 0.000000E+00 0.000000E+00 -1.633504E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(-92*)
E = 2.102692E+02
P = 0.000000E+00 0.000000E+00 2.102692E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 4.866496E+03
P = 0.000000E+00 0.000000E+00 -4.866496E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.634990E+03
P = 4.276637E+01 -6.814158E+00 -1.631870E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 6.288246E+03
P = -4.276637E+01 6.814158E+00 6.288096E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
3639474729.0, 1047239815.0, 4115866610.0,
2318295613.0, 4202845922.0, 2012988632.0,
]
Beginning substream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Initial stream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 6.346155E+03
P = 0.000000E+00 0.000000E+00 6.346155E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 1.636520E+03
P = 0.000000E+00 0.000000E+00 -1.636520E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 1.538455E+02
P = 0.000000E+00 0.000000E+00 1.538455E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 4.863480E+03
P = 0.000000E+00 0.000000E+00 -4.863480E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.635092E+03
P = 4.885535E+01 4.684648E+00 -1.631810E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 6.288208E+03
P = -3.667996E+01 1.830811E+01 6.288074E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 5.937394E+01
P = -1.217539E+01 -2.299276E+01 5.337001E+01
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 1.672101149E-04
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 6.289731E+03
P = 0.000000E+00 0.000000E+00 6.289731E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 1.633504E+03
P = 0.000000E+00 0.000000E+00 -1.633504E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 2.102692E+02
P = 0.000000E+00 0.000000E+00 2.102692E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 4.866496E+03
P = 0.000000E+00 0.000000E+00 -4.866496E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.634990E+03
P = 4.276637E+01 -6.814158E+00 -1.631870E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 6.288246E+03
P = -4.276637E+01 6.814158E+00 6.288096E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 6.346155E+03
P = 0.000000E+00 0.000000E+00 6.346155E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 1.636520E+03
P = 0.000000E+00 0.000000E+00 -1.636520E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 1.538455E+02
P = 0.000000E+00 0.000000E+00 1.538455E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 4.863480E+03
P = 0.000000E+00 0.000000E+00 -4.863480E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.635092E+03
P = 4.885535E+01 4.684648E+00 -1.631810E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 6.288208E+03
P = -3.667996E+01 1.830811E+01 6.288074E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 5.937394E+01
P = -1.217539E+01 -2.299276E+01 5.337001E+01
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 6.346155E+03
P = 0.000000E+00 0.000000E+00 6.346155E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 1.636520E+03
P = 0.000000E+00 0.000000E+00 -1.636520E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 1.538455E+02
P = 0.000000E+00 0.000000E+00 1.538455E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 4.863480E+03
P = 0.000000E+00 0.000000E+00 -4.863480E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.635092E+03
P = 4.885535E+01 4.684648E+00 -1.631810E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 6.288208E+03
P = -3.667996E+01 1.830811E+01 6.288074E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 5.937394E+01
P = -1.217539E+01 -2.299276E+01 5.337001E+01
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-1)
E = 6.289731E+03
P = 0.000000E+00 0.000000E+00 6.289731E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(1)
E = 1.633504E+03
P = 0.000000E+00 0.000000E+00 -1.633504E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 2.102692E+02
P = 0.000000E+00 0.000000E+00 2.102692E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 4.866496E+03
P = 0.000000E+00 0.000000E+00 -4.866496E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.576471E+03
P = 4.123264E+01 -6.569783E+00 -1.573278E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-1)
E = 4.744229E+03
P = 4.645959E+02 1.745310E+02 4.718199E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(1)
E = 1.602534E+03
P = -5.058286E+02 -1.679612E+02 1.511305E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 6.346155E+03
P = 0.000000E+00 0.000000E+00 6.346155E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 1.636520E+03
P = 0.000000E+00 0.000000E+00 -1.636520E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 1.538455E+02
P = 0.000000E+00 0.000000E+00 1.538455E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 4.863480E+03
P = 0.000000E+00 0.000000E+00 -4.863480E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.635092E+03
P = 4.885535E+01 4.684648E+00 -1.631810E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 6.288208E+03
P = -3.667996E+01 1.830811E+01 6.288074E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 5.937394E+01
P = -1.217539E+01 -2.299276E+01 5.337001E+01
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 6.44534E+03
n_in* => 2
n_out* => 5
n_tot* => 7
$process_id* => "nlo_ppzj_sim_1_p1"
process_num_id* => [unknown integer]
sqme* => 3.89196E-02
sqme_ref* => 6.23269E-05
event_index* => 1
event_weight* => 0.00000E+00
event_weight_ref* => 6.43591E-06
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:-2|-6.3461545E+03; 0.0000000E+00, 0.0000000E+00,-6.3461545E+03| 0.0000000E+00| 3)
4 prt(i:-2|-1.6365198E+03; 0.0000000E+00, 0.0000000E+00, 1.6365198E+03| 0.0000000E+00| 4)
5 prt(o:92| 1.5384547E+02; 0.0000000E+00, 0.0000000E+00, 1.5384547E+02| 0.0000000E+00| 5)
6 prt(o:92| 4.8634802E+03; 0.0000000E+00, 0.0000000E+00,-4.8634802E+03| 0.0000000E+00| 6)
7 prt(o:23| 1.6350923E+03; 4.8855349E+01, 4.6846477E+00,-1.6318097E+03| 8.3152513E+03| 7)
8 prt(o:-2| 6.2882081E+03;-3.6679957E+01, 1.8308108E+01, 6.2880744E+03| 0.0000000E+00| 8)
9 prt(o:-2| 5.9373943E+01;-1.2175392E+01,-2.2992756E+01, 5.3370011E+01| 0.0000000E+00| 9)
========================================================================
========================================================================
Event #1
------------------------------------------------------------------------
Unweighted = F
Normalization = 'sigma'
Helicity handling = drop
Keep correlations = F
------------------------------------------------------------------------
Squared matrix el. (ref) = 6.23269E-05
Squared matrix el. (prc) = 6.90405E-02
Event weight (ref) = 6.43591E-06
Event weight (prc) = 0.00000E+00
------------------------------------------------------------------------
Selected MCI group = 2
Selected term = 6
Selected channel = 4
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
4015284228.0, 1428895961.0, 2071492269.0,
3117534565.0, 2289027307.0, 4233842702.0,
]
Beginning substream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Initial stream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 6.289731E+03
P = 0.000000E+00 0.000000E+00 6.289731E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(-2)
E = 1.633504E+03
P = 0.000000E+00 0.000000E+00 -1.633504E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(-92*)
E = 2.102692E+02
P = 0.000000E+00 0.000000E+00 2.102692E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 4.866496E+03
P = 0.000000E+00 0.000000E+00 -4.866496E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.634990E+03
P = 4.276637E+01 -6.814158E+00 -1.631870E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 6.288246E+03
P = -4.276637E+01 6.814158E+00 6.288096E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
3639474729.0, 1047239815.0, 4115866610.0,
2318295613.0, 4202845922.0, 2012988632.0,
]
Beginning substream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Initial stream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 6.346155E+03
P = 0.000000E+00 0.000000E+00 6.346155E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 1.636520E+03
P = 0.000000E+00 0.000000E+00 -1.636520E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 1.538455E+02
P = 0.000000E+00 0.000000E+00 1.538455E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 4.863480E+03
P = 0.000000E+00 0.000000E+00 -4.863480E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.635092E+03
P = 4.885535E+01 4.684648E+00 -1.631810E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 6.288208E+03
P = -3.667996E+01 1.830811E+01 6.288074E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 5.937394E+01
P = -1.217539E+01 -2.299276E+01 5.337001E+01
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 1.672101149E-04
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 6.289731E+03
P = 0.000000E+00 0.000000E+00 6.289731E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 1.633504E+03
P = 0.000000E+00 0.000000E+00 -1.633504E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 2.102692E+02
P = 0.000000E+00 0.000000E+00 2.102692E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 4.866496E+03
P = 0.000000E+00 0.000000E+00 -4.866496E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.634990E+03
P = 4.276637E+01 -6.814158E+00 -1.631870E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 6.288246E+03
P = -4.276637E+01 6.814158E+00 6.288096E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 6.346155E+03
P = 0.000000E+00 0.000000E+00 6.346155E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 1.636520E+03
P = 0.000000E+00 0.000000E+00 -1.636520E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 1.538455E+02
P = 0.000000E+00 0.000000E+00 1.538455E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 4.863480E+03
P = 0.000000E+00 0.000000E+00 -4.863480E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.635092E+03
P = 4.885535E+01 4.684648E+00 -1.631810E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 6.288208E+03
P = -3.667996E+01 1.830811E+01 6.288074E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 5.937394E+01
P = -1.217539E+01 -2.299276E+01 5.337001E+01
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 6.346155E+03
P = 0.000000E+00 0.000000E+00 6.346155E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 1.636520E+03
P = 0.000000E+00 0.000000E+00 -1.636520E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 1.538455E+02
P = 0.000000E+00 0.000000E+00 1.538455E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 4.863480E+03
P = 0.000000E+00 0.000000E+00 -4.863480E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.635092E+03
P = 4.885535E+01 4.684648E+00 -1.631810E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 6.288208E+03
P = -3.667996E+01 1.830811E+01 6.288074E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 5.937394E+01
P = -1.217539E+01 -2.299276E+01 5.337001E+01
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-1)
E = 6.289731E+03
P = 0.000000E+00 0.000000E+00 6.289731E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(1)
E = 1.633504E+03
P = 0.000000E+00 0.000000E+00 -1.633504E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 2.102692E+02
P = 0.000000E+00 0.000000E+00 2.102692E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 4.866496E+03
P = 0.000000E+00 0.000000E+00 -4.866496E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.576471E+03
P = 4.123264E+01 -6.569783E+00 -1.573278E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-1)
E = 4.744229E+03
P = 4.645959E+02 1.745310E+02 4.718199E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(1)
E = 1.602534E+03
P = -5.058286E+02 -1.679612E+02 1.511305E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 6.346155E+03
P = 0.000000E+00 0.000000E+00 6.346155E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 1.636520E+03
P = 0.000000E+00 0.000000E+00 -1.636520E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 1.538455E+02
P = 0.000000E+00 0.000000E+00 1.538455E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 4.863480E+03
P = 0.000000E+00 0.000000E+00 -4.863480E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.635092E+03
P = 4.885535E+01 4.684648E+00 -1.631810E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 6.288208E+03
P = -3.667996E+01 1.830811E+01 6.288074E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 5.937394E+01
P = -1.217539E+01 -2.299276E+01 5.337001E+01
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 6.44534E+03
n_in* => 2
n_out* => 5
n_tot* => 7
$process_id* => "nlo_ppzj_sim_1_p1"
process_num_id* => [unknown integer]
sqme* => 6.90405E-02
sqme_ref* => 6.23269E-05
event_index* => 1
event_weight* => 0.00000E+00
event_weight_ref* => 6.43591E-06
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:-2|-6.3461545E+03; 0.0000000E+00, 0.0000000E+00,-6.3461545E+03| 0.0000000E+00| 3)
4 prt(i:-2|-1.6365198E+03; 0.0000000E+00, 0.0000000E+00, 1.6365198E+03| 0.0000000E+00| 4)
5 prt(o:92| 1.5384547E+02; 0.0000000E+00, 0.0000000E+00, 1.5384547E+02| 0.0000000E+00| 5)
6 prt(o:92| 4.8634802E+03; 0.0000000E+00, 0.0000000E+00,-4.8634802E+03| 0.0000000E+00| 6)
7 prt(o:23| 1.6350923E+03; 4.8855349E+01, 4.6846477E+00,-1.6318097E+03| 8.3152513E+03| 7)
8 prt(o:-2| 6.2882081E+03;-3.6679957E+01, 1.8308108E+01, 6.2880744E+03| 0.0000000E+00| 8)
9 prt(o:-2| 5.9373943E+01;-1.2175392E+01,-2.2992756E+01, 5.3370011E+01| 0.0000000E+00| 9)
========================================================================
========================================================================
Event #1
------------------------------------------------------------------------
Unweighted = F
Normalization = 'sigma'
Helicity handling = drop
Keep correlations = F
------------------------------------------------------------------------
Squared matrix el. (ref) = 6.23269E-05
Squared matrix el. (prc) = 6.23269E-05
Event weight (ref) = 6.43591E-06
Event weight (prc) = 6.43591E-06
------------------------------------------------------------------------
Selected MCI group = 2
Selected term = 6
Selected channel = 4
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
4015284228.0, 1428895961.0, 2071492269.0,
3117534565.0, 2289027307.0, 4233842702.0,
]
Beginning substream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Initial stream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 6.289731E+03
P = 0.000000E+00 0.000000E+00 6.289731E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(-2)
E = 1.633504E+03
P = 0.000000E+00 0.000000E+00 -1.633504E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(-92*)
E = 2.102692E+02
P = 0.000000E+00 0.000000E+00 2.102692E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 4.866496E+03
P = 0.000000E+00 0.000000E+00 -4.866496E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.634990E+03
P = 4.276637E+01 -6.814158E+00 -1.631870E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 6.288246E+03
P = -4.276637E+01 6.814158E+00 6.288096E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
3639474729.0, 1047239815.0, 4115866610.0,
2318295613.0, 4202845922.0, 2012988632.0,
]
Beginning substream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Initial stream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 6.346155E+03
P = 0.000000E+00 0.000000E+00 6.346155E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 1.636520E+03
P = 0.000000E+00 0.000000E+00 -1.636520E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 1.538455E+02
P = 0.000000E+00 0.000000E+00 1.538455E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 4.863480E+03
P = 0.000000E+00 0.000000E+00 -4.863480E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.635092E+03
P = 4.885535E+01 4.684648E+00 -1.631810E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 6.288208E+03
P = -3.667996E+01 1.830811E+01 6.288074E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 5.937394E+01
P = -1.217539E+01 -2.299276E+01 5.337001E+01
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 1.672101149E-04
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 6.289731E+03
P = 0.000000E+00 0.000000E+00 6.289731E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 1.633504E+03
P = 0.000000E+00 0.000000E+00 -1.633504E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 2.102692E+02
P = 0.000000E+00 0.000000E+00 2.102692E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 4.866496E+03
P = 0.000000E+00 0.000000E+00 -4.866496E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.634990E+03
P = 4.276637E+01 -6.814158E+00 -1.631870E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 6.288246E+03
P = -4.276637E+01 6.814158E+00 6.288096E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 6.346155E+03
P = 0.000000E+00 0.000000E+00 6.346155E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 1.636520E+03
P = 0.000000E+00 0.000000E+00 -1.636520E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 1.538455E+02
P = 0.000000E+00 0.000000E+00 1.538455E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 4.863480E+03
P = 0.000000E+00 0.000000E+00 -4.863480E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.635092E+03
P = 4.885535E+01 4.684648E+00 -1.631810E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 6.288208E+03
P = -3.667996E+01 1.830811E+01 6.288074E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 5.937394E+01
P = -1.217539E+01 -2.299276E+01 5.337001E+01
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 6.346155E+03
P = 0.000000E+00 0.000000E+00 6.346155E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 1.636520E+03
P = 0.000000E+00 0.000000E+00 -1.636520E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 1.538455E+02
P = 0.000000E+00 0.000000E+00 1.538455E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 4.863480E+03
P = 0.000000E+00 0.000000E+00 -4.863480E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.635092E+03
P = 4.885535E+01 4.684648E+00 -1.631810E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 6.288208E+03
P = -3.667996E+01 1.830811E+01 6.288074E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 5.937394E+01
P = -1.217539E+01 -2.299276E+01 5.337001E+01
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-1)
E = 6.289731E+03
P = 0.000000E+00 0.000000E+00 6.289731E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(1)
E = 1.633504E+03
P = 0.000000E+00 0.000000E+00 -1.633504E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 2.102692E+02
P = 0.000000E+00 0.000000E+00 2.102692E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 4.866496E+03
P = 0.000000E+00 0.000000E+00 -4.866496E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.576471E+03
P = 4.123264E+01 -6.569783E+00 -1.573278E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-1)
E = 4.744229E+03
P = 4.645959E+02 1.745310E+02 4.718199E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(1)
E = 1.602534E+03
P = -5.058286E+02 -1.679612E+02 1.511305E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 6.346155E+03
P = 0.000000E+00 0.000000E+00 6.346155E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 1.636520E+03
P = 0.000000E+00 0.000000E+00 -1.636520E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 1.538455E+02
P = 0.000000E+00 0.000000E+00 1.538455E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 4.863480E+03
P = 0.000000E+00 0.000000E+00 -4.863480E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.635092E+03
P = 4.885535E+01 4.684648E+00 -1.631810E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 6.288208E+03
P = -3.667996E+01 1.830811E+01 6.288074E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 5.937394E+01
P = -1.217539E+01 -2.299276E+01 5.337001E+01
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 6.41071E+03
n_in* => 2
n_out* => 5
n_tot* => 7
$process_id* => "nlo_ppzj_sim_1_p1"
process_num_id* => [unknown integer]
sqme* => 6.23269E-05
sqme_ref* => 6.23269E-05
event_index* => 1
event_weight* => 6.43591E-06
event_weight_ref* => 6.43591E-06
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:-1|-6.2897308E+03; 0.0000000E+00, 0.0000000E+00,-6.2897308E+03| 0.0000000E+00| 3)
4 prt(i:1|-1.6335044E+03; 0.0000000E+00, 0.0000000E+00, 1.6335044E+03| 0.0000000E+00| 4)
5 prt(o:92| 2.1026925E+02; 0.0000000E+00, 0.0000000E+00, 2.1026925E+02| 0.0000000E+00| 5)
6 prt(o:-92| 4.8664956E+03; 0.0000000E+00, 0.0000000E+00,-4.8664956E+03| 0.0000000E+00| 6)
7 prt(o:23| 1.5764712E+03; 4.1232644E+01,-6.5697832E+00,-1.5732778E+03| 8.3152513E+03| 7)
8 prt(o:-1| 4.7442295E+03; 4.6459592E+02, 1.7453098E+02, 4.7181991E+03| 0.0000000E+00| 8)
9 prt(o:1| 1.6025344E+03;-5.0582856E+02,-1.6796120E+02, 1.5113051E+03| 0.0000000E+00| 9)
========================================================================
========================================================================
Event #1
------------------------------------------------------------------------
Unweighted = F
Normalization = 'sigma'
Helicity handling = drop
Keep correlations = F
------------------------------------------------------------------------
Squared matrix el. (ref) = 6.23269E-05
Squared matrix el. (prc) = 1.67210E-04
Event weight (ref) = 6.43591E-06
Event weight (prc) = 0.00000E+00
------------------------------------------------------------------------
Selected MCI group = 2
Selected term = 6
Selected channel = 4
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
4015284228.0, 1428895961.0, 2071492269.0,
3117534565.0, 2289027307.0, 4233842702.0,
]
Beginning substream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Initial stream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 6.289731E+03
P = 0.000000E+00 0.000000E+00 6.289731E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(-2)
E = 1.633504E+03
P = 0.000000E+00 0.000000E+00 -1.633504E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(-92*)
E = 2.102692E+02
P = 0.000000E+00 0.000000E+00 2.102692E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 4.866496E+03
P = 0.000000E+00 0.000000E+00 -4.866496E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.634990E+03
P = 4.276637E+01 -6.814158E+00 -1.631870E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 6.288246E+03
P = -4.276637E+01 6.814158E+00 6.288096E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
3639474729.0, 1047239815.0, 4115866610.0,
2318295613.0, 4202845922.0, 2012988632.0,
]
Beginning substream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Initial stream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 6.346155E+03
P = 0.000000E+00 0.000000E+00 6.346155E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 1.636520E+03
P = 0.000000E+00 0.000000E+00 -1.636520E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 1.538455E+02
P = 0.000000E+00 0.000000E+00 1.538455E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 4.863480E+03
P = 0.000000E+00 0.000000E+00 -4.863480E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.635092E+03
P = 4.885535E+01 4.684648E+00 -1.631810E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 6.288208E+03
P = -3.667996E+01 1.830811E+01 6.288074E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 5.937394E+01
P = -1.217539E+01 -2.299276E+01 5.337001E+01
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 1.672101149E-04
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 6.289731E+03
P = 0.000000E+00 0.000000E+00 6.289731E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 1.633504E+03
P = 0.000000E+00 0.000000E+00 -1.633504E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 2.102692E+02
P = 0.000000E+00 0.000000E+00 2.102692E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 4.866496E+03
P = 0.000000E+00 0.000000E+00 -4.866496E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.634990E+03
P = 4.276637E+01 -6.814158E+00 -1.631870E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 6.288246E+03
P = -4.276637E+01 6.814158E+00 6.288096E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 6.346155E+03
P = 0.000000E+00 0.000000E+00 6.346155E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 1.636520E+03
P = 0.000000E+00 0.000000E+00 -1.636520E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 1.538455E+02
P = 0.000000E+00 0.000000E+00 1.538455E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 4.863480E+03
P = 0.000000E+00 0.000000E+00 -4.863480E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.635092E+03
P = 4.885535E+01 4.684648E+00 -1.631810E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 6.288208E+03
P = -3.667996E+01 1.830811E+01 6.288074E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 5.937394E+01
P = -1.217539E+01 -2.299276E+01 5.337001E+01
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 6.346155E+03
P = 0.000000E+00 0.000000E+00 6.346155E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 1.636520E+03
P = 0.000000E+00 0.000000E+00 -1.636520E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 1.538455E+02
P = 0.000000E+00 0.000000E+00 1.538455E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 4.863480E+03
P = 0.000000E+00 0.000000E+00 -4.863480E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.635092E+03
P = 4.885535E+01 4.684648E+00 -1.631810E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 6.288208E+03
P = -3.667996E+01 1.830811E+01 6.288074E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 5.937394E+01
P = -1.217539E+01 -2.299276E+01 5.337001E+01
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-1)
E = 6.289731E+03
P = 0.000000E+00 0.000000E+00 6.289731E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(1)
E = 1.633504E+03
P = 0.000000E+00 0.000000E+00 -1.633504E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 2.102692E+02
P = 0.000000E+00 0.000000E+00 2.102692E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 4.866496E+03
P = 0.000000E+00 0.000000E+00 -4.866496E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.576471E+03
P = 4.123264E+01 -6.569783E+00 -1.573278E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-1)
E = 4.744229E+03
P = 4.645959E+02 1.745310E+02 4.718199E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(1)
E = 1.602534E+03
P = -5.058286E+02 -1.679612E+02 1.511305E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 6.346155E+03
P = 0.000000E+00 0.000000E+00 6.346155E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 1.636520E+03
P = 0.000000E+00 0.000000E+00 -1.636520E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 1.538455E+02
P = 0.000000E+00 0.000000E+00 1.538455E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 4.863480E+03
P = 0.000000E+00 0.000000E+00 -4.863480E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.635092E+03
P = 4.885535E+01 4.684648E+00 -1.631810E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 6.288208E+03
P = -3.667996E+01 1.830811E+01 6.288074E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 5.937394E+01
P = -1.217539E+01 -2.299276E+01 5.337001E+01
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 6.44534E+03
n_in* => 2
n_out* => 5
n_tot* => 7
$process_id* => "nlo_ppzj_sim_1_p1"
process_num_id* => [unknown integer]
sqme* => 1.67210E-04
sqme_ref* => 6.23269E-05
event_index* => 1
event_weight* => 0.00000E+00
event_weight_ref* => 6.43591E-06
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:-3|-6.3461545E+03; 0.0000000E+00, 0.0000000E+00,-6.3461545E+03| 0.0000000E+00| 3)
4 prt(i:-3|-1.6365198E+03; 0.0000000E+00, 0.0000000E+00, 1.6365198E+03| 0.0000000E+00| 4)
5 prt(o:92| 1.5384547E+02; 0.0000000E+00, 0.0000000E+00, 1.5384547E+02| 0.0000000E+00| 5)
6 prt(o:92| 4.8634802E+03; 0.0000000E+00, 0.0000000E+00,-4.8634802E+03| 0.0000000E+00| 6)
7 prt(o:23| 1.6350923E+03; 4.8855349E+01, 4.6846477E+00,-1.6318097E+03| 8.3152513E+03| 7)
8 prt(o:-3| 6.2882081E+03;-3.6679957E+01, 1.8308108E+01, 6.2880744E+03| 0.0000000E+00| 8)
9 prt(o:-3| 5.9373943E+01;-1.2175392E+01,-2.2992756E+01, 5.3370011E+01| 0.0000000E+00| 9)
========================================================================
========================================================================
Event #2
------------------------------------------------------------------------
Unweighted = F
Normalization = 'sigma'
Helicity handling = drop
Keep correlations = F
------------------------------------------------------------------------
Squared matrix el. (ref) = 1.19991E+00
Squared matrix el. (prc) = -1.87079E+01
Event weight (ref) = 5.94635E-02
Event weight (prc) = 0.00000E+00
------------------------------------------------------------------------
Selected MCI group = 2
Selected term = 6
Selected channel = 4
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
1602974461.0, 480619195.0, 2217630349.0,
3354302340.0, 3409352020.0, 3903858518.0,
]
Beginning substream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Initial stream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(21)
E = 3.795753E+03
P = 0.000000E+00 0.000000E+00 3.795753E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 2.603821E+03
P = 0.000000E+00 0.000000E+00 -2.603821E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(93*)
E = 2.704247E+03
P = 0.000000E+00 0.000000E+00 2.704247E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 3.896179E+03
P = 0.000000E+00 0.000000E+00 -3.896179E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.604644E+03
P = -1.436899E+01 -2.438255E+01 -2.602893E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 3.794930E+03
P = 1.436899E+01 2.438255E+01 3.794825E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
4012730210.0, 257260579.0, 1062518970.0,
1200068362.0, 322147811.0, 1901625519.0,
]
Beginning substream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Initial stream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 3.985440E+03
P = 0.000000E+00 0.000000E+00 3.985440E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 2.698746E+03
P = 0.000000E+00 0.000000E+00 -2.698746E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 2.514560E+03
P = 0.000000E+00 0.000000E+00 2.514560E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 3.801254E+03
P = 0.000000E+00 0.000000E+00 -3.801254E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.608341E+03
P = 1.052657E+01 -1.534560E+02 -2.602205E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 3.796821E+03
P = 3.924706E+01 -1.046002E+02 3.795177E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 2.790235E+02
P = -4.977363E+01 2.580562E+02 9.372143E+01
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 3.814518973E-02
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 3.795753E+03
P = 0.000000E+00 0.000000E+00 3.795753E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 2.603821E+03
P = 0.000000E+00 0.000000E+00 -2.603821E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 2.704247E+03
P = 0.000000E+00 0.000000E+00 2.704247E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 3.896179E+03
P = 0.000000E+00 0.000000E+00 -3.896179E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.604644E+03
P = -1.436899E+01 -2.438255E+01 -2.602893E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 3.794930E+03
P = 1.436899E+01 2.438255E+01 3.794825E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 3.985440E+03
P = 0.000000E+00 0.000000E+00 3.985440E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 2.698746E+03
P = 0.000000E+00 0.000000E+00 -2.698746E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 2.514560E+03
P = 0.000000E+00 0.000000E+00 2.514560E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 3.801254E+03
P = 0.000000E+00 0.000000E+00 -3.801254E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.608341E+03
P = 1.052657E+01 -1.534560E+02 -2.602205E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 3.796821E+03
P = 3.924706E+01 -1.046002E+02 3.795177E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 2.790235E+02
P = -4.977363E+01 2.580562E+02 9.372143E+01
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 3.985440E+03
P = 0.000000E+00 0.000000E+00 3.985440E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 2.698746E+03
P = 0.000000E+00 0.000000E+00 -2.698746E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 2.514560E+03
P = 0.000000E+00 0.000000E+00 2.514560E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 3.801254E+03
P = 0.000000E+00 0.000000E+00 -3.801254E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.608341E+03
P = 1.052657E+01 -1.534560E+02 -2.602205E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 3.796821E+03
P = 3.924706E+01 -1.046002E+02 3.795177E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 2.790235E+02
P = -4.977363E+01 2.580562E+02 9.372143E+01
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 3.795753E+03
P = 0.000000E+00 0.000000E+00 3.795753E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 2.603821E+03
P = 0.000000E+00 0.000000E+00 -2.603821E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 2.704247E+03
P = 0.000000E+00 0.000000E+00 2.704247E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 3.896179E+03
P = 0.000000E+00 0.000000E+00 -3.896179E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.470038E+03
P = -1.362562E+01 -2.312114E+01 -2.468208E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 3.480562E+03
P = 2.778549E+02 3.222140E+02 3.454459E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 4.489744E+02
P = -2.642293E+02 -2.990928E+02 2.056803E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 3.985440E+03
P = 0.000000E+00 0.000000E+00 3.985440E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 2.698746E+03
P = 0.000000E+00 0.000000E+00 -2.698746E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 2.514560E+03
P = 0.000000E+00 0.000000E+00 2.514560E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 3.801254E+03
P = 0.000000E+00 0.000000E+00 -3.801254E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.608341E+03
P = 1.052657E+01 -1.534560E+02 -2.602205E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 3.796821E+03
P = 3.924706E+01 -1.046002E+02 3.795177E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 2.790235E+02
P = -4.977363E+01 2.580562E+02 9.372143E+01
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 6.28759E+03
n_in* => 2
n_out* => 4
n_tot* => 6
$process_id* => "nlo_ppzj_sim_1_p1"
process_num_id* => [unknown integer]
sqme* => -1.87079E+01
sqme_ref* => 1.19991E+00
event_index* => 2
event_weight* => 0.00000E+00
event_weight_ref* => 5.94635E-02
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:-2|-3.7957529E+03; 0.0000000E+00, 0.0000000E+00,-3.7957529E+03| 0.0000000E+00| 3)
4 prt(i:2|-2.6038213E+03; 0.0000000E+00, 0.0000000E+00, 2.6038213E+03| 0.0000000E+00| 4)
5 prt(o:92| 2.7042471E+03; 0.0000000E+00, 0.0000000E+00, 2.7042471E+03| 0.0000000E+00| 5)
6 prt(o:-92| 3.8961787E+03; 0.0000000E+00, 0.0000000E+00,-3.8961787E+03| 0.0000000E+00| 6)
7 prt(o:23| 2.6046438E+03;-1.4368986E+01,-2.4382552E+01,-2.6028932E+03| 8.3152513E+03| 7)
8 prt(o:21| 3.7949303E+03; 1.4368986E+01, 2.4382552E+01, 3.7948248E+03| 0.0000000E+00| 8)
========================================================================
========================================================================
Event #2
------------------------------------------------------------------------
Unweighted = F
Normalization = 'sigma'
Helicity handling = drop
Keep correlations = F
------------------------------------------------------------------------
Squared matrix el. (ref) = 1.19991E+00
Squared matrix el. (prc) = 2.85540E+01
Event weight (ref) = 5.94635E-02
Event weight (prc) = 0.00000E+00
------------------------------------------------------------------------
Selected MCI group = 2
Selected term = 6
Selected channel = 4
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
1602974461.0, 480619195.0, 2217630349.0,
3354302340.0, 3409352020.0, 3903858518.0,
]
Beginning substream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Initial stream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(21)
E = 3.795753E+03
P = 0.000000E+00 0.000000E+00 3.795753E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 2.603821E+03
P = 0.000000E+00 0.000000E+00 -2.603821E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(93*)
E = 2.704247E+03
P = 0.000000E+00 0.000000E+00 2.704247E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 3.896179E+03
P = 0.000000E+00 0.000000E+00 -3.896179E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.604644E+03
P = -1.436899E+01 -2.438255E+01 -2.602893E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 3.794930E+03
P = 1.436899E+01 2.438255E+01 3.794825E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
4012730210.0, 257260579.0, 1062518970.0,
1200068362.0, 322147811.0, 1901625519.0,
]
Beginning substream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Initial stream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 3.985440E+03
P = 0.000000E+00 0.000000E+00 3.985440E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 2.698746E+03
P = 0.000000E+00 0.000000E+00 -2.698746E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 2.514560E+03
P = 0.000000E+00 0.000000E+00 2.514560E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 3.801254E+03
P = 0.000000E+00 0.000000E+00 -3.801254E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.608341E+03
P = 1.052657E+01 -1.534560E+02 -2.602205E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 3.796821E+03
P = 3.924706E+01 -1.046002E+02 3.795177E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 2.790235E+02
P = -4.977363E+01 2.580562E+02 9.372143E+01
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 3.814518973E-02
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 3.795753E+03
P = 0.000000E+00 0.000000E+00 3.795753E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 2.603821E+03
P = 0.000000E+00 0.000000E+00 -2.603821E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 2.704247E+03
P = 0.000000E+00 0.000000E+00 2.704247E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 3.896179E+03
P = 0.000000E+00 0.000000E+00 -3.896179E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.604644E+03
P = -1.436899E+01 -2.438255E+01 -2.602893E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 3.794930E+03
P = 1.436899E+01 2.438255E+01 3.794825E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 3.985440E+03
P = 0.000000E+00 0.000000E+00 3.985440E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 2.698746E+03
P = 0.000000E+00 0.000000E+00 -2.698746E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 2.514560E+03
P = 0.000000E+00 0.000000E+00 2.514560E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 3.801254E+03
P = 0.000000E+00 0.000000E+00 -3.801254E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.608341E+03
P = 1.052657E+01 -1.534560E+02 -2.602205E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 3.796821E+03
P = 3.924706E+01 -1.046002E+02 3.795177E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 2.790235E+02
P = -4.977363E+01 2.580562E+02 9.372143E+01
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 3.985440E+03
P = 0.000000E+00 0.000000E+00 3.985440E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 2.698746E+03
P = 0.000000E+00 0.000000E+00 -2.698746E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 2.514560E+03
P = 0.000000E+00 0.000000E+00 2.514560E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 3.801254E+03
P = 0.000000E+00 0.000000E+00 -3.801254E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.608341E+03
P = 1.052657E+01 -1.534560E+02 -2.602205E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 3.796821E+03
P = 3.924706E+01 -1.046002E+02 3.795177E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 2.790235E+02
P = -4.977363E+01 2.580562E+02 9.372143E+01
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 3.795753E+03
P = 0.000000E+00 0.000000E+00 3.795753E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 2.603821E+03
P = 0.000000E+00 0.000000E+00 -2.603821E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 2.704247E+03
P = 0.000000E+00 0.000000E+00 2.704247E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 3.896179E+03
P = 0.000000E+00 0.000000E+00 -3.896179E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.470038E+03
P = -1.362562E+01 -2.312114E+01 -2.468208E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 3.480562E+03
P = 2.778549E+02 3.222140E+02 3.454459E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 4.489744E+02
P = -2.642293E+02 -2.990928E+02 2.056803E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 3.985440E+03
P = 0.000000E+00 0.000000E+00 3.985440E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 2.698746E+03
P = 0.000000E+00 0.000000E+00 -2.698746E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 2.514560E+03
P = 0.000000E+00 0.000000E+00 2.514560E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 3.801254E+03
P = 0.000000E+00 0.000000E+00 -3.801254E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.608341E+03
P = 1.052657E+01 -1.534560E+02 -2.602205E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 3.796821E+03
P = 3.924706E+01 -1.046002E+02 3.795177E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 2.790235E+02
P = -4.977363E+01 2.580562E+02 9.372143E+01
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 6.55917E+03
n_in* => 2
n_out* => 5
n_tot* => 7
$process_id* => "nlo_ppzj_sim_1_p1"
process_num_id* => [unknown integer]
sqme* => 2.85540E+01
sqme_ref* => 1.19991E+00
event_index* => 2
event_weight* => 0.00000E+00
event_weight_ref* => 5.94635E-02
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:-2|-3.9854397E+03; 0.0000000E+00, 0.0000000E+00,-3.9854397E+03| 0.0000000E+00| 3)
4 prt(i:-2|-2.6987459E+03; 0.0000000E+00, 0.0000000E+00, 2.6987459E+03| 0.0000000E+00| 4)
5 prt(o:92| 2.5145603E+03; 0.0000000E+00, 0.0000000E+00, 2.5145603E+03| 0.0000000E+00| 5)
6 prt(o:92| 3.8012541E+03; 0.0000000E+00, 0.0000000E+00,-3.8012541E+03| 0.0000000E+00| 6)
7 prt(o:23| 2.6083411E+03; 1.0526570E+01,-1.5345600E+02,-2.6022046E+03| 8.3152513E+03| 7)
8 prt(o:-2| 3.7968210E+03; 3.9247055E+01,-1.0460023E+02, 3.7951770E+03| 0.0000000E+00| 8)
9 prt(o:-2| 2.7902354E+02;-4.9773626E+01, 2.5805623E+02, 9.3721425E+01| 0.0000000E+00| 9)
========================================================================
========================================================================
Event #2
------------------------------------------------------------------------
Unweighted = F
Normalization = 'sigma'
Helicity handling = drop
Keep correlations = F
------------------------------------------------------------------------
Squared matrix el. (ref) = 1.19991E+00
Squared matrix el. (prc) = 2.51695E+01
Event weight (ref) = 5.94635E-02
Event weight (prc) = 0.00000E+00
------------------------------------------------------------------------
Selected MCI group = 2
Selected term = 6
Selected channel = 4
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
1602974461.0, 480619195.0, 2217630349.0,
3354302340.0, 3409352020.0, 3903858518.0,
]
Beginning substream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Initial stream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(21)
E = 3.795753E+03
P = 0.000000E+00 0.000000E+00 3.795753E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 2.603821E+03
P = 0.000000E+00 0.000000E+00 -2.603821E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(93*)
E = 2.704247E+03
P = 0.000000E+00 0.000000E+00 2.704247E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 3.896179E+03
P = 0.000000E+00 0.000000E+00 -3.896179E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.604644E+03
P = -1.436899E+01 -2.438255E+01 -2.602893E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 3.794930E+03
P = 1.436899E+01 2.438255E+01 3.794825E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
4012730210.0, 257260579.0, 1062518970.0,
1200068362.0, 322147811.0, 1901625519.0,
]
Beginning substream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Initial stream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 3.985440E+03
P = 0.000000E+00 0.000000E+00 3.985440E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 2.698746E+03
P = 0.000000E+00 0.000000E+00 -2.698746E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 2.514560E+03
P = 0.000000E+00 0.000000E+00 2.514560E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 3.801254E+03
P = 0.000000E+00 0.000000E+00 -3.801254E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.608341E+03
P = 1.052657E+01 -1.534560E+02 -2.602205E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 3.796821E+03
P = 3.924706E+01 -1.046002E+02 3.795177E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 2.790235E+02
P = -4.977363E+01 2.580562E+02 9.372143E+01
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 3.814518973E-02
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 3.795753E+03
P = 0.000000E+00 0.000000E+00 3.795753E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 2.603821E+03
P = 0.000000E+00 0.000000E+00 -2.603821E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 2.704247E+03
P = 0.000000E+00 0.000000E+00 2.704247E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 3.896179E+03
P = 0.000000E+00 0.000000E+00 -3.896179E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.604644E+03
P = -1.436899E+01 -2.438255E+01 -2.602893E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 3.794930E+03
P = 1.436899E+01 2.438255E+01 3.794825E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 3.985440E+03
P = 0.000000E+00 0.000000E+00 3.985440E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 2.698746E+03
P = 0.000000E+00 0.000000E+00 -2.698746E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 2.514560E+03
P = 0.000000E+00 0.000000E+00 2.514560E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 3.801254E+03
P = 0.000000E+00 0.000000E+00 -3.801254E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.608341E+03
P = 1.052657E+01 -1.534560E+02 -2.602205E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 3.796821E+03
P = 3.924706E+01 -1.046002E+02 3.795177E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 2.790235E+02
P = -4.977363E+01 2.580562E+02 9.372143E+01
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 3.985440E+03
P = 0.000000E+00 0.000000E+00 3.985440E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 2.698746E+03
P = 0.000000E+00 0.000000E+00 -2.698746E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 2.514560E+03
P = 0.000000E+00 0.000000E+00 2.514560E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 3.801254E+03
P = 0.000000E+00 0.000000E+00 -3.801254E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.608341E+03
P = 1.052657E+01 -1.534560E+02 -2.602205E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 3.796821E+03
P = 3.924706E+01 -1.046002E+02 3.795177E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 2.790235E+02
P = -4.977363E+01 2.580562E+02 9.372143E+01
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 3.795753E+03
P = 0.000000E+00 0.000000E+00 3.795753E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 2.603821E+03
P = 0.000000E+00 0.000000E+00 -2.603821E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 2.704247E+03
P = 0.000000E+00 0.000000E+00 2.704247E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 3.896179E+03
P = 0.000000E+00 0.000000E+00 -3.896179E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.470038E+03
P = -1.362562E+01 -2.312114E+01 -2.468208E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 3.480562E+03
P = 2.778549E+02 3.222140E+02 3.454459E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 4.489744E+02
P = -2.642293E+02 -2.990928E+02 2.056803E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 3.985440E+03
P = 0.000000E+00 0.000000E+00 3.985440E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 2.698746E+03
P = 0.000000E+00 0.000000E+00 -2.698746E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 2.514560E+03
P = 0.000000E+00 0.000000E+00 2.514560E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 3.801254E+03
P = 0.000000E+00 0.000000E+00 -3.801254E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.608341E+03
P = 1.052657E+01 -1.534560E+02 -2.602205E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 3.796821E+03
P = 3.924706E+01 -1.046002E+02 3.795177E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 2.790235E+02
P = -4.977363E+01 2.580562E+02 9.372143E+01
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 6.55917E+03
n_in* => 2
n_out* => 5
n_tot* => 7
$process_id* => "nlo_ppzj_sim_1_p1"
process_num_id* => [unknown integer]
sqme* => 2.51695E+01
sqme_ref* => 1.19991E+00
event_index* => 2
event_weight* => 0.00000E+00
event_weight_ref* => 5.94635E-02
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:-2|-3.9854397E+03; 0.0000000E+00, 0.0000000E+00,-3.9854397E+03| 0.0000000E+00| 3)
4 prt(i:-2|-2.6987459E+03; 0.0000000E+00, 0.0000000E+00, 2.6987459E+03| 0.0000000E+00| 4)
5 prt(o:92| 2.5145603E+03; 0.0000000E+00, 0.0000000E+00, 2.5145603E+03| 0.0000000E+00| 5)
6 prt(o:92| 3.8012541E+03; 0.0000000E+00, 0.0000000E+00,-3.8012541E+03| 0.0000000E+00| 6)
7 prt(o:23| 2.6083411E+03; 1.0526570E+01,-1.5345600E+02,-2.6022046E+03| 8.3152513E+03| 7)
8 prt(o:-2| 3.7968210E+03; 3.9247055E+01,-1.0460023E+02, 3.7951770E+03| 0.0000000E+00| 8)
9 prt(o:-2| 2.7902354E+02;-4.9773626E+01, 2.5805623E+02, 9.3721425E+01| 0.0000000E+00| 9)
========================================================================
========================================================================
Event #2
------------------------------------------------------------------------
Unweighted = F
Normalization = 'sigma'
Helicity handling = drop
Keep correlations = F
------------------------------------------------------------------------
Squared matrix el. (ref) = 1.19991E+00
Squared matrix el. (prc) = 1.19991E+00
Event weight (ref) = 5.94635E-02
Event weight (prc) = 5.94635E-02
------------------------------------------------------------------------
Selected MCI group = 2
Selected term = 6
Selected channel = 4
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
1602974461.0, 480619195.0, 2217630349.0,
3354302340.0, 3409352020.0, 3903858518.0,
]
Beginning substream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Initial stream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(21)
E = 3.795753E+03
P = 0.000000E+00 0.000000E+00 3.795753E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 2.603821E+03
P = 0.000000E+00 0.000000E+00 -2.603821E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(93*)
E = 2.704247E+03
P = 0.000000E+00 0.000000E+00 2.704247E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 3.896179E+03
P = 0.000000E+00 0.000000E+00 -3.896179E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.604644E+03
P = -1.436899E+01 -2.438255E+01 -2.602893E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 3.794930E+03
P = 1.436899E+01 2.438255E+01 3.794825E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
4012730210.0, 257260579.0, 1062518970.0,
1200068362.0, 322147811.0, 1901625519.0,
]
Beginning substream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Initial stream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 3.985440E+03
P = 0.000000E+00 0.000000E+00 3.985440E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 2.698746E+03
P = 0.000000E+00 0.000000E+00 -2.698746E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 2.514560E+03
P = 0.000000E+00 0.000000E+00 2.514560E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 3.801254E+03
P = 0.000000E+00 0.000000E+00 -3.801254E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.608341E+03
P = 1.052657E+01 -1.534560E+02 -2.602205E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 3.796821E+03
P = 3.924706E+01 -1.046002E+02 3.795177E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 2.790235E+02
P = -4.977363E+01 2.580562E+02 9.372143E+01
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 3.814518973E-02
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 3.795753E+03
P = 0.000000E+00 0.000000E+00 3.795753E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 2.603821E+03
P = 0.000000E+00 0.000000E+00 -2.603821E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 2.704247E+03
P = 0.000000E+00 0.000000E+00 2.704247E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 3.896179E+03
P = 0.000000E+00 0.000000E+00 -3.896179E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.604644E+03
P = -1.436899E+01 -2.438255E+01 -2.602893E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 3.794930E+03
P = 1.436899E+01 2.438255E+01 3.794825E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 3.985440E+03
P = 0.000000E+00 0.000000E+00 3.985440E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 2.698746E+03
P = 0.000000E+00 0.000000E+00 -2.698746E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 2.514560E+03
P = 0.000000E+00 0.000000E+00 2.514560E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 3.801254E+03
P = 0.000000E+00 0.000000E+00 -3.801254E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.608341E+03
P = 1.052657E+01 -1.534560E+02 -2.602205E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 3.796821E+03
P = 3.924706E+01 -1.046002E+02 3.795177E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 2.790235E+02
P = -4.977363E+01 2.580562E+02 9.372143E+01
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 3.985440E+03
P = 0.000000E+00 0.000000E+00 3.985440E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 2.698746E+03
P = 0.000000E+00 0.000000E+00 -2.698746E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 2.514560E+03
P = 0.000000E+00 0.000000E+00 2.514560E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 3.801254E+03
P = 0.000000E+00 0.000000E+00 -3.801254E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.608341E+03
P = 1.052657E+01 -1.534560E+02 -2.602205E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 3.796821E+03
P = 3.924706E+01 -1.046002E+02 3.795177E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 2.790235E+02
P = -4.977363E+01 2.580562E+02 9.372143E+01
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 3.795753E+03
P = 0.000000E+00 0.000000E+00 3.795753E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 2.603821E+03
P = 0.000000E+00 0.000000E+00 -2.603821E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 2.704247E+03
P = 0.000000E+00 0.000000E+00 2.704247E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 3.896179E+03
P = 0.000000E+00 0.000000E+00 -3.896179E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.470038E+03
P = -1.362562E+01 -2.312114E+01 -2.468208E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 3.480562E+03
P = 2.778549E+02 3.222140E+02 3.454459E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 4.489744E+02
P = -2.642293E+02 -2.990928E+02 2.056803E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 3.985440E+03
P = 0.000000E+00 0.000000E+00 3.985440E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 2.698746E+03
P = 0.000000E+00 0.000000E+00 -2.698746E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 2.514560E+03
P = 0.000000E+00 0.000000E+00 2.514560E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 3.801254E+03
P = 0.000000E+00 0.000000E+00 -3.801254E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.608341E+03
P = 1.052657E+01 -1.534560E+02 -2.602205E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 3.796821E+03
P = 3.924706E+01 -1.046002E+02 3.795177E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 2.790235E+02
P = -4.977363E+01 2.580562E+02 9.372143E+01
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 6.28759E+03
n_in* => 2
n_out* => 5
n_tot* => 7
$process_id* => "nlo_ppzj_sim_1_p1"
process_num_id* => [unknown integer]
sqme* => 1.19991E+00
sqme_ref* => 1.19991E+00
event_index* => 2
event_weight* => 5.94635E-02
event_weight_ref* => 5.94635E-02
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:2|-3.7957529E+03; 0.0000000E+00, 0.0000000E+00,-3.7957529E+03| 0.0000000E+00| 3)
4 prt(i:-2|-2.6038213E+03; 0.0000000E+00, 0.0000000E+00, 2.6038213E+03| 0.0000000E+00| 4)
5 prt(o:-92| 2.7042471E+03; 0.0000000E+00, 0.0000000E+00, 2.7042471E+03| 0.0000000E+00| 5)
6 prt(o:92| 3.8961787E+03; 0.0000000E+00, 0.0000000E+00,-3.8961787E+03| 0.0000000E+00| 6)
7 prt(o:23| 2.4700375E+03;-1.3625618E+01,-2.3121139E+01,-2.4682078E+03| 8.3152513E+03| 7)
8 prt(o:21| 3.4805622E+03; 2.7785487E+02, 3.2221397E+02, 3.4544592E+03| 0.0000000E+00| 8)
9 prt(o:21| 4.4897438E+02;-2.6422926E+02,-2.9909283E+02, 2.0568028E+02| 0.0000000E+00| 9)
========================================================================
========================================================================
Event #2
------------------------------------------------------------------------
Unweighted = F
Normalization = 'sigma'
Helicity handling = drop
Keep correlations = F
------------------------------------------------------------------------
Squared matrix el. (ref) = 1.19991E+00
Squared matrix el. (prc) = 3.81452E-02
Event weight (ref) = 5.94635E-02
Event weight (prc) = 0.00000E+00
------------------------------------------------------------------------
Selected MCI group = 2
Selected term = 6
Selected channel = 4
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
1602974461.0, 480619195.0, 2217630349.0,
3354302340.0, 3409352020.0, 3903858518.0,
]
Beginning substream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Initial stream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(21)
E = 3.795753E+03
P = 0.000000E+00 0.000000E+00 3.795753E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 2.603821E+03
P = 0.000000E+00 0.000000E+00 -2.603821E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(93*)
E = 2.704247E+03
P = 0.000000E+00 0.000000E+00 2.704247E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 3.896179E+03
P = 0.000000E+00 0.000000E+00 -3.896179E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.604644E+03
P = -1.436899E+01 -2.438255E+01 -2.602893E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 3.794930E+03
P = 1.436899E+01 2.438255E+01 3.794825E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
4012730210.0, 257260579.0, 1062518970.0,
1200068362.0, 322147811.0, 1901625519.0,
]
Beginning substream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Initial stream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 3.985440E+03
P = 0.000000E+00 0.000000E+00 3.985440E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 2.698746E+03
P = 0.000000E+00 0.000000E+00 -2.698746E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 2.514560E+03
P = 0.000000E+00 0.000000E+00 2.514560E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 3.801254E+03
P = 0.000000E+00 0.000000E+00 -3.801254E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.608341E+03
P = 1.052657E+01 -1.534560E+02 -2.602205E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 3.796821E+03
P = 3.924706E+01 -1.046002E+02 3.795177E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 2.790235E+02
P = -4.977363E+01 2.580562E+02 9.372143E+01
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 3.814518973E-02
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 3.795753E+03
P = 0.000000E+00 0.000000E+00 3.795753E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 2.603821E+03
P = 0.000000E+00 0.000000E+00 -2.603821E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 2.704247E+03
P = 0.000000E+00 0.000000E+00 2.704247E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 3.896179E+03
P = 0.000000E+00 0.000000E+00 -3.896179E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.604644E+03
P = -1.436899E+01 -2.438255E+01 -2.602893E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 3.794930E+03
P = 1.436899E+01 2.438255E+01 3.794825E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 3.985440E+03
P = 0.000000E+00 0.000000E+00 3.985440E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 2.698746E+03
P = 0.000000E+00 0.000000E+00 -2.698746E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 2.514560E+03
P = 0.000000E+00 0.000000E+00 2.514560E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 3.801254E+03
P = 0.000000E+00 0.000000E+00 -3.801254E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.608341E+03
P = 1.052657E+01 -1.534560E+02 -2.602205E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 3.796821E+03
P = 3.924706E+01 -1.046002E+02 3.795177E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 2.790235E+02
P = -4.977363E+01 2.580562E+02 9.372143E+01
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 3.985440E+03
P = 0.000000E+00 0.000000E+00 3.985440E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 2.698746E+03
P = 0.000000E+00 0.000000E+00 -2.698746E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 2.514560E+03
P = 0.000000E+00 0.000000E+00 2.514560E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 3.801254E+03
P = 0.000000E+00 0.000000E+00 -3.801254E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.608341E+03
P = 1.052657E+01 -1.534560E+02 -2.602205E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 3.796821E+03
P = 3.924706E+01 -1.046002E+02 3.795177E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 2.790235E+02
P = -4.977363E+01 2.580562E+02 9.372143E+01
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 3.795753E+03
P = 0.000000E+00 0.000000E+00 3.795753E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 2.603821E+03
P = 0.000000E+00 0.000000E+00 -2.603821E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 2.704247E+03
P = 0.000000E+00 0.000000E+00 2.704247E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 3.896179E+03
P = 0.000000E+00 0.000000E+00 -3.896179E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.470038E+03
P = -1.362562E+01 -2.312114E+01 -2.468208E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 3.480562E+03
P = 2.778549E+02 3.222140E+02 3.454459E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 4.489744E+02
P = -2.642293E+02 -2.990928E+02 2.056803E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 3.985440E+03
P = 0.000000E+00 0.000000E+00 3.985440E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 2.698746E+03
P = 0.000000E+00 0.000000E+00 -2.698746E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 2.514560E+03
P = 0.000000E+00 0.000000E+00 2.514560E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 3.801254E+03
P = 0.000000E+00 0.000000E+00 -3.801254E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.608341E+03
P = 1.052657E+01 -1.534560E+02 -2.602205E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 3.796821E+03
P = 3.924706E+01 -1.046002E+02 3.795177E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 2.790235E+02
P = -4.977363E+01 2.580562E+02 9.372143E+01
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 6.55917E+03
n_in* => 2
n_out* => 5
n_tot* => 7
$process_id* => "nlo_ppzj_sim_1_p1"
process_num_id* => [unknown integer]
sqme* => 3.81452E-02
sqme_ref* => 1.19991E+00
event_index* => 2
event_weight* => 0.00000E+00
event_weight_ref* => 5.94635E-02
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:-3|-3.9854397E+03; 0.0000000E+00, 0.0000000E+00,-3.9854397E+03| 0.0000000E+00| 3)
4 prt(i:-3|-2.6987459E+03; 0.0000000E+00, 0.0000000E+00, 2.6987459E+03| 0.0000000E+00| 4)
5 prt(o:92| 2.5145603E+03; 0.0000000E+00, 0.0000000E+00, 2.5145603E+03| 0.0000000E+00| 5)
6 prt(o:92| 3.8012541E+03; 0.0000000E+00, 0.0000000E+00,-3.8012541E+03| 0.0000000E+00| 6)
7 prt(o:23| 2.6083411E+03; 1.0526570E+01,-1.5345600E+02,-2.6022046E+03| 8.3152513E+03| 7)
8 prt(o:-3| 3.7968210E+03; 3.9247055E+01,-1.0460023E+02, 3.7951770E+03| 0.0000000E+00| 8)
9 prt(o:-3| 2.7902354E+02;-4.9773626E+01, 2.5805623E+02, 9.3721425E+01| 0.0000000E+00| 9)
========================================================================
========================================================================
Event #3
------------------------------------------------------------------------
Unweighted = F
Normalization = 'sigma'
Helicity handling = drop
Keep correlations = F
------------------------------------------------------------------------
Squared matrix el. (ref) = 2.40849E+02
Squared matrix el. (prc) = -7.99241E+02
Event weight (ref) = 2.01025E+01
Event weight (prc) = 0.00000E+00
------------------------------------------------------------------------
Selected MCI group = 2
Selected term = 6
Selected channel = 4
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
36656637.0, 1178065546.0, 4098913464.0,
2519932891.0, 3866280816.0, 2463289096.0,
]
Beginning substream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Initial stream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(21)
E = 2.138599E+03
P = 0.000000E+00 0.000000E+00 2.138599E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(1)
E = 1.709585E+03
P = 0.000000E+00 0.000000E+00 -1.709585E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(93*)
E = 4.361401E+03
P = 0.000000E+00 0.000000E+00 4.361401E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 4.790415E+03
P = 0.000000E+00 0.000000E+00 -4.790415E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.710805E+03
P = -1.086034E+01 -6.281457E+00 -1.708327E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(1)
E = 2.137379E+03
P = 1.086034E+01 6.281457E+00 2.137342E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
42807673.0, 3252526988.0, 2251751086.0,
605661278.0, 3019034651.0, 2767591064.0,
]
Beginning substream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Initial stream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(21)
E = 2.902771E+03
P = 0.000000E+00 0.000000E+00 2.902771E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 5.130488E+03
P = 0.000000E+00 0.000000E+00 -5.130488E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(93*)
E = 3.597229E+03
P = 0.000000E+00 0.000000E+00 3.597229E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 1.369512E+03
P = 0.000000E+00 0.000000E+00 -1.369512E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.020846E+03
P = 3.853486E+02 1.060909E+03 -1.673763E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 2.458654E+03
P = 4.077225E+02 1.075231E+03 2.173159E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 3.553759E+03
P = -7.930711E+02 -2.136140E+03 -2.727113E+03
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 9.856425683E-06
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 2.138599E+03
P = 0.000000E+00 0.000000E+00 2.138599E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 1.709585E+03
P = 0.000000E+00 0.000000E+00 -1.709585E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 4.361401E+03
P = 0.000000E+00 0.000000E+00 4.361401E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 4.790415E+03
P = 0.000000E+00 0.000000E+00 -4.790415E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.710805E+03
P = -1.086034E+01 -6.281457E+00 -1.708327E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 2.137379E+03
P = 1.086034E+01 6.281457E+00 2.137342E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 2.902771E+03
P = 0.000000E+00 0.000000E+00 2.902771E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 5.130488E+03
P = 0.000000E+00 0.000000E+00 -5.130488E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 3.597229E+03
P = 0.000000E+00 0.000000E+00 3.597229E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 1.369512E+03
P = 0.000000E+00 0.000000E+00 -1.369512E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.020846E+03
P = 3.853486E+02 1.060909E+03 -1.673763E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 2.458654E+03
P = 4.077225E+02 1.075231E+03 2.173159E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 3.553759E+03
P = -7.930711E+02 -2.136140E+03 -2.727113E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 2.902771E+03
P = 0.000000E+00 0.000000E+00 2.902771E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 5.130488E+03
P = 0.000000E+00 0.000000E+00 -5.130488E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 3.597229E+03
P = 0.000000E+00 0.000000E+00 3.597229E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 1.369512E+03
P = 0.000000E+00 0.000000E+00 -1.369512E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.020846E+03
P = 3.853486E+02 1.060909E+03 -1.673763E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 2.458654E+03
P = 4.077225E+02 1.075231E+03 2.173159E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 3.553759E+03
P = -7.930711E+02 -2.136140E+03 -2.727113E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(21)
E = 2.138599E+03
P = 0.000000E+00 0.000000E+00 2.138599E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 1.709585E+03
P = 0.000000E+00 0.000000E+00 -1.709585E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(93*)
E = 4.361401E+03
P = 0.000000E+00 0.000000E+00 4.361401E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 4.790415E+03
P = 0.000000E+00 0.000000E+00 -4.790415E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.296055E+03
P = -8.219632E+00 -4.754113E+00 -1.292808E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 6.066109E+02
P = -3.781738E+02 -4.566246E+02 -1.282782E+02
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 1.945518E+03
P = 3.863935E+02 4.613787E+02 1.850101E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(21)
E = 2.902771E+03
P = 0.000000E+00 0.000000E+00 2.902771E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 5.130488E+03
P = 0.000000E+00 0.000000E+00 -5.130488E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(93*)
E = 3.597229E+03
P = 0.000000E+00 0.000000E+00 3.597229E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 1.369512E+03
P = 0.000000E+00 0.000000E+00 -1.369512E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.020846E+03
P = 3.853486E+02 1.060909E+03 -1.673763E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 2.458654E+03
P = 4.077225E+02 1.075231E+03 2.173159E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 3.553759E+03
P = -7.930711E+02 -2.136140E+03 -2.727113E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 3.82419E+03
n_in* => 2
n_out* => 4
n_tot* => 6
$process_id* => "nlo_ppzj_sim_1_p1"
process_num_id* => [unknown integer]
sqme* => -7.99241E+02
sqme_ref* => 2.40849E+02
event_index* => 3
event_weight* => 0.00000E+00
event_weight_ref* => 2.01025E+01
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:-2|-2.1385992E+03; 0.0000000E+00, 0.0000000E+00,-2.1385992E+03| 0.0000000E+00| 3)
4 prt(i:2|-1.7095848E+03; 0.0000000E+00, 0.0000000E+00, 1.7095848E+03| 0.0000000E+00| 4)
5 prt(o:92| 4.3614008E+03; 0.0000000E+00, 0.0000000E+00, 4.3614008E+03| 0.0000000E+00| 5)
6 prt(o:-92| 4.7904152E+03; 0.0000000E+00, 0.0000000E+00,-4.7904152E+03| 0.0000000E+00| 6)
7 prt(o:23| 1.7108054E+03;-1.0860336E+01,-6.2814574E+00,-1.7083273E+03| 8.3152513E+03| 7)
8 prt(o:21| 2.1373786E+03; 1.0860336E+01, 6.2814574E+00, 2.1373418E+03| 0.0000000E+00| 8)
========================================================================
========================================================================
Event #3
------------------------------------------------------------------------
Unweighted = F
Normalization = 'sigma'
Helicity handling = drop
Keep correlations = F
------------------------------------------------------------------------
Squared matrix el. (ref) = 2.40849E+02
Squared matrix el. (prc) = 6.95831E-04
Event weight (ref) = 2.01025E+01
Event weight (prc) = 5.80777E-05
------------------------------------------------------------------------
Selected MCI group = 2
Selected term = 6
Selected channel = 4
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
36656637.0, 1178065546.0, 4098913464.0,
2519932891.0, 3866280816.0, 2463289096.0,
]
Beginning substream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Initial stream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(21)
E = 2.138599E+03
P = 0.000000E+00 0.000000E+00 2.138599E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(1)
E = 1.709585E+03
P = 0.000000E+00 0.000000E+00 -1.709585E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(93*)
E = 4.361401E+03
P = 0.000000E+00 0.000000E+00 4.361401E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 4.790415E+03
P = 0.000000E+00 0.000000E+00 -4.790415E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.710805E+03
P = -1.086034E+01 -6.281457E+00 -1.708327E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(1)
E = 2.137379E+03
P = 1.086034E+01 6.281457E+00 2.137342E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
42807673.0, 3252526988.0, 2251751086.0,
605661278.0, 3019034651.0, 2767591064.0,
]
Beginning substream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Initial stream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(21)
E = 2.902771E+03
P = 0.000000E+00 0.000000E+00 2.902771E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 5.130488E+03
P = 0.000000E+00 0.000000E+00 -5.130488E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(93*)
E = 3.597229E+03
P = 0.000000E+00 0.000000E+00 3.597229E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 1.369512E+03
P = 0.000000E+00 0.000000E+00 -1.369512E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.020846E+03
P = 3.853486E+02 1.060909E+03 -1.673763E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 2.458654E+03
P = 4.077225E+02 1.075231E+03 2.173159E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 3.553759E+03
P = -7.930711E+02 -2.136140E+03 -2.727113E+03
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 9.856425683E-06
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 2.138599E+03
P = 0.000000E+00 0.000000E+00 2.138599E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 1.709585E+03
P = 0.000000E+00 0.000000E+00 -1.709585E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 4.361401E+03
P = 0.000000E+00 0.000000E+00 4.361401E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 4.790415E+03
P = 0.000000E+00 0.000000E+00 -4.790415E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.710805E+03
P = -1.086034E+01 -6.281457E+00 -1.708327E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 2.137379E+03
P = 1.086034E+01 6.281457E+00 2.137342E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 2.902771E+03
P = 0.000000E+00 0.000000E+00 2.902771E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 5.130488E+03
P = 0.000000E+00 0.000000E+00 -5.130488E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 3.597229E+03
P = 0.000000E+00 0.000000E+00 3.597229E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 1.369512E+03
P = 0.000000E+00 0.000000E+00 -1.369512E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.020846E+03
P = 3.853486E+02 1.060909E+03 -1.673763E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 2.458654E+03
P = 4.077225E+02 1.075231E+03 2.173159E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 3.553759E+03
P = -7.930711E+02 -2.136140E+03 -2.727113E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 2.902771E+03
P = 0.000000E+00 0.000000E+00 2.902771E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 5.130488E+03
P = 0.000000E+00 0.000000E+00 -5.130488E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 3.597229E+03
P = 0.000000E+00 0.000000E+00 3.597229E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 1.369512E+03
P = 0.000000E+00 0.000000E+00 -1.369512E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.020846E+03
P = 3.853486E+02 1.060909E+03 -1.673763E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 2.458654E+03
P = 4.077225E+02 1.075231E+03 2.173159E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 3.553759E+03
P = -7.930711E+02 -2.136140E+03 -2.727113E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(21)
E = 2.138599E+03
P = 0.000000E+00 0.000000E+00 2.138599E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 1.709585E+03
P = 0.000000E+00 0.000000E+00 -1.709585E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(93*)
E = 4.361401E+03
P = 0.000000E+00 0.000000E+00 4.361401E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 4.790415E+03
P = 0.000000E+00 0.000000E+00 -4.790415E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.296055E+03
P = -8.219632E+00 -4.754113E+00 -1.292808E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 6.066109E+02
P = -3.781738E+02 -4.566246E+02 -1.282782E+02
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 1.945518E+03
P = 3.863935E+02 4.613787E+02 1.850101E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(21)
E = 2.902771E+03
P = 0.000000E+00 0.000000E+00 2.902771E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 5.130488E+03
P = 0.000000E+00 0.000000E+00 -5.130488E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(93*)
E = 3.597229E+03
P = 0.000000E+00 0.000000E+00 3.597229E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 1.369512E+03
P = 0.000000E+00 0.000000E+00 -1.369512E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.020846E+03
P = 3.853486E+02 1.060909E+03 -1.673763E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 2.458654E+03
P = 4.077225E+02 1.075231E+03 2.173159E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 3.553759E+03
P = -7.930711E+02 -2.136140E+03 -2.727113E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 7.71819E+03
n_in* => 2
n_out* => 5
n_tot* => 7
$process_id* => "nlo_ppzj_sim_1_p1"
process_num_id* => [unknown integer]
sqme* => 6.95831E-04
sqme_ref* => 2.40849E+02
event_index* => 3
event_weight* => 5.80777E-05
event_weight_ref* => 2.01025E+01
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:2|-2.9027713E+03; 0.0000000E+00, 0.0000000E+00,-2.9027713E+03| 0.0000000E+00| 3)
4 prt(i:2|-5.1304876E+03; 0.0000000E+00, 0.0000000E+00, 5.1304876E+03| 0.0000000E+00| 4)
5 prt(o:-92| 3.5972287E+03; 0.0000000E+00, 0.0000000E+00, 3.5972287E+03| 0.0000000E+00| 5)
6 prt(o:-92| 1.3695124E+03; 0.0000000E+00, 0.0000000E+00,-1.3695124E+03| 0.0000000E+00| 6)
7 prt(o:23| 2.0208458E+03; 3.8534858E+02, 1.0609090E+03,-1.6737625E+03| 8.3152513E+03| 7)
8 prt(o:2| 2.4586543E+03; 4.0772248E+02, 1.0752313E+03, 2.1731592E+03| 0.0000000E+00| 8)
9 prt(o:2| 3.5537589E+03;-7.9307106E+02,-2.1361403E+03,-2.7271130E+03| 0.0000000E+00| 9)
========================================================================
========================================================================
Event #3
------------------------------------------------------------------------
Unweighted = F
Normalization = 'sigma'
Helicity handling = drop
Keep correlations = F
------------------------------------------------------------------------
Squared matrix el. (ref) = 2.40849E+02
Squared matrix el. (prc) = 1.59952E-04
Event weight (ref) = 2.01025E+01
Event weight (prc) = 1.33505E-05
------------------------------------------------------------------------
Selected MCI group = 2
Selected term = 6
Selected channel = 4
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
36656637.0, 1178065546.0, 4098913464.0,
2519932891.0, 3866280816.0, 2463289096.0,
]
Beginning substream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Initial stream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(21)
E = 2.138599E+03
P = 0.000000E+00 0.000000E+00 2.138599E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(1)
E = 1.709585E+03
P = 0.000000E+00 0.000000E+00 -1.709585E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(93*)
E = 4.361401E+03
P = 0.000000E+00 0.000000E+00 4.361401E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 4.790415E+03
P = 0.000000E+00 0.000000E+00 -4.790415E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.710805E+03
P = -1.086034E+01 -6.281457E+00 -1.708327E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(1)
E = 2.137379E+03
P = 1.086034E+01 6.281457E+00 2.137342E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
42807673.0, 3252526988.0, 2251751086.0,
605661278.0, 3019034651.0, 2767591064.0,
]
Beginning substream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Initial stream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(21)
E = 2.902771E+03
P = 0.000000E+00 0.000000E+00 2.902771E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 5.130488E+03
P = 0.000000E+00 0.000000E+00 -5.130488E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(93*)
E = 3.597229E+03
P = 0.000000E+00 0.000000E+00 3.597229E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 1.369512E+03
P = 0.000000E+00 0.000000E+00 -1.369512E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.020846E+03
P = 3.853486E+02 1.060909E+03 -1.673763E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 2.458654E+03
P = 4.077225E+02 1.075231E+03 2.173159E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 3.553759E+03
P = -7.930711E+02 -2.136140E+03 -2.727113E+03
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 9.856425683E-06
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 2.138599E+03
P = 0.000000E+00 0.000000E+00 2.138599E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 1.709585E+03
P = 0.000000E+00 0.000000E+00 -1.709585E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 4.361401E+03
P = 0.000000E+00 0.000000E+00 4.361401E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 4.790415E+03
P = 0.000000E+00 0.000000E+00 -4.790415E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.710805E+03
P = -1.086034E+01 -6.281457E+00 -1.708327E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 2.137379E+03
P = 1.086034E+01 6.281457E+00 2.137342E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 2.902771E+03
P = 0.000000E+00 0.000000E+00 2.902771E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 5.130488E+03
P = 0.000000E+00 0.000000E+00 -5.130488E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 3.597229E+03
P = 0.000000E+00 0.000000E+00 3.597229E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 1.369512E+03
P = 0.000000E+00 0.000000E+00 -1.369512E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.020846E+03
P = 3.853486E+02 1.060909E+03 -1.673763E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 2.458654E+03
P = 4.077225E+02 1.075231E+03 2.173159E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 3.553759E+03
P = -7.930711E+02 -2.136140E+03 -2.727113E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 2.902771E+03
P = 0.000000E+00 0.000000E+00 2.902771E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 5.130488E+03
P = 0.000000E+00 0.000000E+00 -5.130488E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 3.597229E+03
P = 0.000000E+00 0.000000E+00 3.597229E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 1.369512E+03
P = 0.000000E+00 0.000000E+00 -1.369512E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.020846E+03
P = 3.853486E+02 1.060909E+03 -1.673763E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 2.458654E+03
P = 4.077225E+02 1.075231E+03 2.173159E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 3.553759E+03
P = -7.930711E+02 -2.136140E+03 -2.727113E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(21)
E = 2.138599E+03
P = 0.000000E+00 0.000000E+00 2.138599E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 1.709585E+03
P = 0.000000E+00 0.000000E+00 -1.709585E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(93*)
E = 4.361401E+03
P = 0.000000E+00 0.000000E+00 4.361401E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 4.790415E+03
P = 0.000000E+00 0.000000E+00 -4.790415E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.296055E+03
P = -8.219632E+00 -4.754113E+00 -1.292808E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 6.066109E+02
P = -3.781738E+02 -4.566246E+02 -1.282782E+02
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 1.945518E+03
P = 3.863935E+02 4.613787E+02 1.850101E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(21)
E = 2.902771E+03
P = 0.000000E+00 0.000000E+00 2.902771E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 5.130488E+03
P = 0.000000E+00 0.000000E+00 -5.130488E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(93*)
E = 3.597229E+03
P = 0.000000E+00 0.000000E+00 3.597229E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 1.369512E+03
P = 0.000000E+00 0.000000E+00 -1.369512E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.020846E+03
P = 3.853486E+02 1.060909E+03 -1.673763E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 2.458654E+03
P = 4.077225E+02 1.075231E+03 2.173159E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 3.553759E+03
P = -7.930711E+02 -2.136140E+03 -2.727113E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 7.71819E+03
n_in* => 2
n_out* => 5
n_tot* => 7
$process_id* => "nlo_ppzj_sim_1_p1"
process_num_id* => [unknown integer]
sqme* => 1.59952E-04
sqme_ref* => 2.40849E+02
event_index* => 3
event_weight* => 1.33505E-05
event_weight_ref* => 2.01025E+01
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:2|-2.9027713E+03; 0.0000000E+00, 0.0000000E+00,-2.9027713E+03| 0.0000000E+00| 3)
4 prt(i:2|-5.1304876E+03; 0.0000000E+00, 0.0000000E+00, 5.1304876E+03| 0.0000000E+00| 4)
5 prt(o:-92| 3.5972287E+03; 0.0000000E+00, 0.0000000E+00, 3.5972287E+03| 0.0000000E+00| 5)
6 prt(o:-92| 1.3695124E+03; 0.0000000E+00, 0.0000000E+00,-1.3695124E+03| 0.0000000E+00| 6)
7 prt(o:23| 2.0208458E+03; 3.8534858E+02, 1.0609090E+03,-1.6737625E+03| 8.3152513E+03| 7)
8 prt(o:2| 2.4586543E+03; 4.0772248E+02, 1.0752313E+03, 2.1731592E+03| 0.0000000E+00| 8)
9 prt(o:2| 3.5537589E+03;-7.9307106E+02,-2.1361403E+03,-2.7271130E+03| 0.0000000E+00| 9)
========================================================================
========================================================================
Event #3
------------------------------------------------------------------------
Unweighted = F
Normalization = 'sigma'
Helicity handling = drop
Keep correlations = F
------------------------------------------------------------------------
Squared matrix el. (ref) = 2.40849E+02
Squared matrix el. (prc) = 2.40848E+02
Event weight (ref) = 2.01025E+01
Event weight (prc) = 2.01024E+01
------------------------------------------------------------------------
Selected MCI group = 2
Selected term = 6
Selected channel = 4
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
36656637.0, 1178065546.0, 4098913464.0,
2519932891.0, 3866280816.0, 2463289096.0,
]
Beginning substream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Initial stream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(21)
E = 2.138599E+03
P = 0.000000E+00 0.000000E+00 2.138599E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(1)
E = 1.709585E+03
P = 0.000000E+00 0.000000E+00 -1.709585E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(93*)
E = 4.361401E+03
P = 0.000000E+00 0.000000E+00 4.361401E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 4.790415E+03
P = 0.000000E+00 0.000000E+00 -4.790415E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.710805E+03
P = -1.086034E+01 -6.281457E+00 -1.708327E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(1)
E = 2.137379E+03
P = 1.086034E+01 6.281457E+00 2.137342E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
42807673.0, 3252526988.0, 2251751086.0,
605661278.0, 3019034651.0, 2767591064.0,
]
Beginning substream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Initial stream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(21)
E = 2.902771E+03
P = 0.000000E+00 0.000000E+00 2.902771E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 5.130488E+03
P = 0.000000E+00 0.000000E+00 -5.130488E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(93*)
E = 3.597229E+03
P = 0.000000E+00 0.000000E+00 3.597229E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 1.369512E+03
P = 0.000000E+00 0.000000E+00 -1.369512E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.020846E+03
P = 3.853486E+02 1.060909E+03 -1.673763E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 2.458654E+03
P = 4.077225E+02 1.075231E+03 2.173159E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 3.553759E+03
P = -7.930711E+02 -2.136140E+03 -2.727113E+03
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 9.856425683E-06
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 2.138599E+03
P = 0.000000E+00 0.000000E+00 2.138599E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 1.709585E+03
P = 0.000000E+00 0.000000E+00 -1.709585E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 4.361401E+03
P = 0.000000E+00 0.000000E+00 4.361401E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 4.790415E+03
P = 0.000000E+00 0.000000E+00 -4.790415E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.710805E+03
P = -1.086034E+01 -6.281457E+00 -1.708327E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 2.137379E+03
P = 1.086034E+01 6.281457E+00 2.137342E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 2.902771E+03
P = 0.000000E+00 0.000000E+00 2.902771E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 5.130488E+03
P = 0.000000E+00 0.000000E+00 -5.130488E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 3.597229E+03
P = 0.000000E+00 0.000000E+00 3.597229E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 1.369512E+03
P = 0.000000E+00 0.000000E+00 -1.369512E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.020846E+03
P = 3.853486E+02 1.060909E+03 -1.673763E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 2.458654E+03
P = 4.077225E+02 1.075231E+03 2.173159E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 3.553759E+03
P = -7.930711E+02 -2.136140E+03 -2.727113E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 2.902771E+03
P = 0.000000E+00 0.000000E+00 2.902771E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 5.130488E+03
P = 0.000000E+00 0.000000E+00 -5.130488E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 3.597229E+03
P = 0.000000E+00 0.000000E+00 3.597229E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 1.369512E+03
P = 0.000000E+00 0.000000E+00 -1.369512E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.020846E+03
P = 3.853486E+02 1.060909E+03 -1.673763E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 2.458654E+03
P = 4.077225E+02 1.075231E+03 2.173159E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 3.553759E+03
P = -7.930711E+02 -2.136140E+03 -2.727113E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(21)
E = 2.138599E+03
P = 0.000000E+00 0.000000E+00 2.138599E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 1.709585E+03
P = 0.000000E+00 0.000000E+00 -1.709585E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(93*)
E = 4.361401E+03
P = 0.000000E+00 0.000000E+00 4.361401E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 4.790415E+03
P = 0.000000E+00 0.000000E+00 -4.790415E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.296055E+03
P = -8.219632E+00 -4.754113E+00 -1.292808E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 6.066109E+02
P = -3.781738E+02 -4.566246E+02 -1.282782E+02
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 1.945518E+03
P = 3.863935E+02 4.613787E+02 1.850101E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(21)
E = 2.902771E+03
P = 0.000000E+00 0.000000E+00 2.902771E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 5.130488E+03
P = 0.000000E+00 0.000000E+00 -5.130488E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(93*)
E = 3.597229E+03
P = 0.000000E+00 0.000000E+00 3.597229E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 1.369512E+03
P = 0.000000E+00 0.000000E+00 -1.369512E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.020846E+03
P = 3.853486E+02 1.060909E+03 -1.673763E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 2.458654E+03
P = 4.077225E+02 1.075231E+03 2.173159E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 3.553759E+03
P = -7.930711E+02 -2.136140E+03 -2.727113E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 3.82419E+03
n_in* => 2
n_out* => 5
n_tot* => 7
$process_id* => "nlo_ppzj_sim_1_p1"
process_num_id* => [unknown integer]
sqme* => 2.40848E+02
sqme_ref* => 2.40849E+02
event_index* => 3
event_weight* => 2.01024E+01
event_weight_ref* => 2.01025E+01
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:21|-2.1385992E+03; 0.0000000E+00, 0.0000000E+00,-2.1385992E+03| 0.0000000E+00| 3)
4 prt(i:2|-1.7095848E+03; 0.0000000E+00, 0.0000000E+00, 1.7095848E+03| 0.0000000E+00| 4)
5 prt(o:93| 4.3614008E+03; 0.0000000E+00, 0.0000000E+00, 4.3614008E+03| 0.0000000E+00| 5)
6 prt(o:-92| 4.7904152E+03; 0.0000000E+00, 0.0000000E+00,-4.7904152E+03| 0.0000000E+00| 6)
7 prt(o:23| 1.2960546E+03;-8.2196320E+00,-4.7541131E+00,-1.2928079E+03| 8.3152513E+03| 7)
8 prt(o:2| 6.0661088E+02;-3.7817383E+02,-4.5662459E+02,-1.2827820E+02| 0.0000000E+00| 8)
9 prt(o:21| 1.9455185E+03; 3.8639346E+02, 4.6137870E+02, 1.8501005E+03| 0.0000000E+00| 9)
========================================================================
========================================================================
Event #3
------------------------------------------------------------------------
Unweighted = F
Normalization = 'sigma'
Helicity handling = drop
Keep correlations = F
------------------------------------------------------------------------
Squared matrix el. (ref) = 2.40849E+02
Squared matrix el. (prc) = 9.85643E-06
Event weight (ref) = 2.01025E+01
Event weight (prc) = 8.22669E-07
------------------------------------------------------------------------
Selected MCI group = 2
Selected term = 6
Selected channel = 4
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
36656637.0, 1178065546.0, 4098913464.0,
2519932891.0, 3866280816.0, 2463289096.0,
]
Beginning substream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Initial stream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(21)
E = 2.138599E+03
P = 0.000000E+00 0.000000E+00 2.138599E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(1)
E = 1.709585E+03
P = 0.000000E+00 0.000000E+00 -1.709585E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(93*)
E = 4.361401E+03
P = 0.000000E+00 0.000000E+00 4.361401E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 4.790415E+03
P = 0.000000E+00 0.000000E+00 -4.790415E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.710805E+03
P = -1.086034E+01 -6.281457E+00 -1.708327E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(1)
E = 2.137379E+03
P = 1.086034E+01 6.281457E+00 2.137342E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
42807673.0, 3252526988.0, 2251751086.0,
605661278.0, 3019034651.0, 2767591064.0,
]
Beginning substream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Initial stream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(21)
E = 2.902771E+03
P = 0.000000E+00 0.000000E+00 2.902771E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 5.130488E+03
P = 0.000000E+00 0.000000E+00 -5.130488E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(93*)
E = 3.597229E+03
P = 0.000000E+00 0.000000E+00 3.597229E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 1.369512E+03
P = 0.000000E+00 0.000000E+00 -1.369512E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.020846E+03
P = 3.853486E+02 1.060909E+03 -1.673763E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 2.458654E+03
P = 4.077225E+02 1.075231E+03 2.173159E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 3.553759E+03
P = -7.930711E+02 -2.136140E+03 -2.727113E+03
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 9.856425683E-06
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 2.138599E+03
P = 0.000000E+00 0.000000E+00 2.138599E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 1.709585E+03
P = 0.000000E+00 0.000000E+00 -1.709585E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 4.361401E+03
P = 0.000000E+00 0.000000E+00 4.361401E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 4.790415E+03
P = 0.000000E+00 0.000000E+00 -4.790415E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.710805E+03
P = -1.086034E+01 -6.281457E+00 -1.708327E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 2.137379E+03
P = 1.086034E+01 6.281457E+00 2.137342E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 2.902771E+03
P = 0.000000E+00 0.000000E+00 2.902771E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 5.130488E+03
P = 0.000000E+00 0.000000E+00 -5.130488E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 3.597229E+03
P = 0.000000E+00 0.000000E+00 3.597229E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 1.369512E+03
P = 0.000000E+00 0.000000E+00 -1.369512E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.020846E+03
P = 3.853486E+02 1.060909E+03 -1.673763E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 2.458654E+03
P = 4.077225E+02 1.075231E+03 2.173159E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 3.553759E+03
P = -7.930711E+02 -2.136140E+03 -2.727113E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 2.902771E+03
P = 0.000000E+00 0.000000E+00 2.902771E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 5.130488E+03
P = 0.000000E+00 0.000000E+00 -5.130488E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 3.597229E+03
P = 0.000000E+00 0.000000E+00 3.597229E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 1.369512E+03
P = 0.000000E+00 0.000000E+00 -1.369512E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.020846E+03
P = 3.853486E+02 1.060909E+03 -1.673763E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 2.458654E+03
P = 4.077225E+02 1.075231E+03 2.173159E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 3.553759E+03
P = -7.930711E+02 -2.136140E+03 -2.727113E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(21)
E = 2.138599E+03
P = 0.000000E+00 0.000000E+00 2.138599E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 1.709585E+03
P = 0.000000E+00 0.000000E+00 -1.709585E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(93*)
E = 4.361401E+03
P = 0.000000E+00 0.000000E+00 4.361401E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 4.790415E+03
P = 0.000000E+00 0.000000E+00 -4.790415E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.296055E+03
P = -8.219632E+00 -4.754113E+00 -1.292808E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 6.066109E+02
P = -3.781738E+02 -4.566246E+02 -1.282782E+02
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 1.945518E+03
P = 3.863935E+02 4.613787E+02 1.850101E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(21)
E = 2.902771E+03
P = 0.000000E+00 0.000000E+00 2.902771E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 5.130488E+03
P = 0.000000E+00 0.000000E+00 -5.130488E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(93*)
E = 3.597229E+03
P = 0.000000E+00 0.000000E+00 3.597229E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 1.369512E+03
P = 0.000000E+00 0.000000E+00 -1.369512E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.020846E+03
P = 3.853486E+02 1.060909E+03 -1.673763E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 2.458654E+03
P = 4.077225E+02 1.075231E+03 2.173159E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 3.553759E+03
P = -7.930711E+02 -2.136140E+03 -2.727113E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 7.71819E+03
n_in* => 2
n_out* => 5
n_tot* => 7
$process_id* => "nlo_ppzj_sim_1_p1"
process_num_id* => [unknown integer]
sqme* => 9.85643E-06
sqme_ref* => 2.40849E+02
event_index* => 3
event_weight* => 8.22669E-07
event_weight_ref* => 2.01025E+01
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:21|-2.9027713E+03; 0.0000000E+00, 0.0000000E+00,-2.9027713E+03| 0.0000000E+00| 3)
4 prt(i:2|-5.1304876E+03; 0.0000000E+00, 0.0000000E+00, 5.1304876E+03| 0.0000000E+00| 4)
5 prt(o:93| 3.5972287E+03; 0.0000000E+00, 0.0000000E+00, 3.5972287E+03| 0.0000000E+00| 5)
6 prt(o:-92| 1.3695124E+03; 0.0000000E+00, 0.0000000E+00,-1.3695124E+03| 0.0000000E+00| 6)
7 prt(o:23| 2.0208458E+03; 3.8534858E+02, 1.0609090E+03,-1.6737625E+03| 8.3152513E+03| 7)
8 prt(o:2| 2.4586543E+03; 4.0772248E+02, 1.0752313E+03, 2.1731592E+03| 0.0000000E+00| 8)
9 prt(o:21| 3.5537589E+03;-7.9307106E+02,-2.1361403E+03,-2.7271130E+03| 0.0000000E+00| 9)
========================================================================
========================================================================
Event #4
------------------------------------------------------------------------
Unweighted = F
Normalization = 'sigma'
Helicity handling = drop
Keep correlations = F
------------------------------------------------------------------------
Squared matrix el. (ref) = 8.73272E-12
Squared matrix el. (prc) = -4.76873E-10
Event weight (ref) = 3.98580E-16
Event weight (prc) = 0.00000E+00
------------------------------------------------------------------------
Selected MCI group = 2
Selected term = 6
Selected channel = 4
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
3075724450.0, 3714364000.0, 1273526590.0,
654325229.0, 3346090863.0, 595080625.0,
]
Beginning substream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Initial stream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 6.338215E+03
P = 0.000000E+00 0.000000E+00 6.338215E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 6.496102E+03
P = 0.000000E+00 0.000000E+00 -6.496102E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 1.617849E+02
P = 0.000000E+00 0.000000E+00 1.617849E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 3.898394E+00
P = 0.000000E+00 0.000000E+00 -3.898394E+00
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.338543E+03
P = 3.826821E-01 1.696008E+01 6.337865E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 6.495773E+03
P = -3.826821E-01 -1.696008E+01 -6.495751E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
2368564314.0, 286886664.0, 1358903953.0,
3068176274.0, 3702895995.0, 1874125068.0,
]
Beginning substream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Initial stream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 6.339971E+03
P = 0.000000E+00 0.000000E+00 6.339971E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 6.496419E+03
P = 0.000000E+00 0.000000E+00 -6.496419E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 1.600286E+02
P = 0.000000E+00 0.000000E+00 1.600286E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 3.580654E+00
P = 0.000000E+00 0.000000E+00 -3.580654E+00
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.338545E+03
P = 6.540862E-01 1.765604E+01 6.337865E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 6.495772E+03
P = -1.113054E-01 -1.626419E+01 -6.495751E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 2.073992E+00
P = -5.427809E-01 -1.391856E+00 1.438600E+00
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 2.131353253E-10
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 6.338215E+03
P = 0.000000E+00 0.000000E+00 6.338215E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 6.496102E+03
P = 0.000000E+00 0.000000E+00 -6.496102E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 1.617849E+02
P = 0.000000E+00 0.000000E+00 1.617849E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 3.898394E+00
P = 0.000000E+00 0.000000E+00 -3.898394E+00
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.338543E+03
P = 3.826821E-01 1.696008E+01 6.337865E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 6.495773E+03
P = -3.826821E-01 -1.696008E+01 -6.495751E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 6.339971E+03
P = 0.000000E+00 0.000000E+00 6.339971E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 6.496419E+03
P = 0.000000E+00 0.000000E+00 -6.496419E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 1.600286E+02
P = 0.000000E+00 0.000000E+00 1.600286E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 3.580654E+00
P = 0.000000E+00 0.000000E+00 -3.580654E+00
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.338545E+03
P = 6.540862E-01 1.765604E+01 6.337865E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 6.495772E+03
P = -1.113054E-01 -1.626419E+01 -6.495751E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 2.073992E+00
P = -5.427809E-01 -1.391856E+00 1.438600E+00
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 6.339971E+03
P = 0.000000E+00 0.000000E+00 6.339971E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 6.496419E+03
P = 0.000000E+00 0.000000E+00 -6.496419E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 1.600286E+02
P = 0.000000E+00 0.000000E+00 1.600286E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 3.580654E+00
P = 0.000000E+00 0.000000E+00 -3.580654E+00
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.338545E+03
P = 6.540862E-01 1.765604E+01 6.337865E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 6.495772E+03
P = -1.113054E-01 -1.626419E+01 -6.495751E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 2.073992E+00
P = -5.427809E-01 -1.391856E+00 1.438600E+00
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 6.338215E+03
P = 0.000000E+00 0.000000E+00 6.338215E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(21)
E = 6.496102E+03
P = 0.000000E+00 0.000000E+00 -6.496102E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 1.617849E+02
P = 0.000000E+00 0.000000E+00 1.617849E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(93*)
E = 3.898394E+00
P = 0.000000E+00 0.000000E+00 -3.898394E+00
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.266333E+03
P = 3.783216E-01 1.676683E+01 6.265647E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 6.039084E+03
P = -1.356140E+02 -3.407286E+02 -6.027939E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 5.288999E+02
P = 1.352357E+02 3.239618E+02 -3.955947E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 6.339971E+03
P = 0.000000E+00 0.000000E+00 6.339971E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 6.496419E+03
P = 0.000000E+00 0.000000E+00 -6.496419E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 1.600286E+02
P = 0.000000E+00 0.000000E+00 1.600286E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 3.580654E+00
P = 0.000000E+00 0.000000E+00 -3.580654E+00
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.338545E+03
P = 6.540862E-01 1.765604E+01 6.337865E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 6.495772E+03
P = -1.113054E-01 -1.626419E+01 -6.495751E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 2.073992E+00
P = -5.427809E-01 -1.391856E+00 1.438600E+00
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 1.28333E+04
n_in* => 2
n_out* => 4
n_tot* => 6
$process_id* => "nlo_ppzj_sim_1_p1"
process_num_id* => [unknown integer]
sqme* => -4.76873E-10
sqme_ref* => 8.73272E-12
event_index* => 4
event_weight* => 0.00000E+00
event_weight_ref* => 0.00000E+00
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:-2|-6.3382151E+03; 0.0000000E+00, 0.0000000E+00,-6.3382151E+03| 0.0000000E+00| 3)
4 prt(i:2|-6.4961016E+03; 0.0000000E+00, 0.0000000E+00, 6.4961016E+03| 0.0000000E+00| 4)
5 prt(o:92| 1.6178493E+02; 0.0000000E+00, 0.0000000E+00, 1.6178493E+02| 0.0000000E+00| 5)
6 prt(o:-92| 3.8983944E+00; 0.0000000E+00, 0.0000000E+00,-3.8983944E+00| 0.0000000E+00| 6)
7 prt(o:23| 6.3385433E+03; 3.8268207E-01, 1.6960079E+01, 6.3378647E+03| 8.3152513E+03| 7)
8 prt(o:21| 6.4957733E+03;-3.8268207E-01,-1.6960079E+01,-6.4957512E+03| 0.0000000E+00| 8)
========================================================================
========================================================================
Event #4
------------------------------------------------------------------------
Unweighted = F
Normalization = 'sigma'
Helicity handling = drop
Keep correlations = F
------------------------------------------------------------------------
Squared matrix el. (ref) = 8.73272E-12
Squared matrix el. (prc) = 2.09972E-07
Event weight (ref) = 3.98580E-16
Event weight (prc) = 0.00000E+00
------------------------------------------------------------------------
Selected MCI group = 2
Selected term = 6
Selected channel = 4
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
3075724450.0, 3714364000.0, 1273526590.0,
654325229.0, 3346090863.0, 595080625.0,
]
Beginning substream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Initial stream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 6.338215E+03
P = 0.000000E+00 0.000000E+00 6.338215E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 6.496102E+03
P = 0.000000E+00 0.000000E+00 -6.496102E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 1.617849E+02
P = 0.000000E+00 0.000000E+00 1.617849E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 3.898394E+00
P = 0.000000E+00 0.000000E+00 -3.898394E+00
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.338543E+03
P = 3.826821E-01 1.696008E+01 6.337865E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 6.495773E+03
P = -3.826821E-01 -1.696008E+01 -6.495751E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
2368564314.0, 286886664.0, 1358903953.0,
3068176274.0, 3702895995.0, 1874125068.0,
]
Beginning substream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Initial stream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 6.339971E+03
P = 0.000000E+00 0.000000E+00 6.339971E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 6.496419E+03
P = 0.000000E+00 0.000000E+00 -6.496419E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 1.600286E+02
P = 0.000000E+00 0.000000E+00 1.600286E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 3.580654E+00
P = 0.000000E+00 0.000000E+00 -3.580654E+00
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.338545E+03
P = 6.540862E-01 1.765604E+01 6.337865E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 6.495772E+03
P = -1.113054E-01 -1.626419E+01 -6.495751E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 2.073992E+00
P = -5.427809E-01 -1.391856E+00 1.438600E+00
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 2.131353253E-10
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 6.338215E+03
P = 0.000000E+00 0.000000E+00 6.338215E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 6.496102E+03
P = 0.000000E+00 0.000000E+00 -6.496102E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 1.617849E+02
P = 0.000000E+00 0.000000E+00 1.617849E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 3.898394E+00
P = 0.000000E+00 0.000000E+00 -3.898394E+00
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.338543E+03
P = 3.826821E-01 1.696008E+01 6.337865E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 6.495773E+03
P = -3.826821E-01 -1.696008E+01 -6.495751E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 6.339971E+03
P = 0.000000E+00 0.000000E+00 6.339971E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 6.496419E+03
P = 0.000000E+00 0.000000E+00 -6.496419E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 1.600286E+02
P = 0.000000E+00 0.000000E+00 1.600286E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 3.580654E+00
P = 0.000000E+00 0.000000E+00 -3.580654E+00
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.338545E+03
P = 6.540862E-01 1.765604E+01 6.337865E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 6.495772E+03
P = -1.113054E-01 -1.626419E+01 -6.495751E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 2.073992E+00
P = -5.427809E-01 -1.391856E+00 1.438600E+00
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 6.339971E+03
P = 0.000000E+00 0.000000E+00 6.339971E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 6.496419E+03
P = 0.000000E+00 0.000000E+00 -6.496419E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 1.600286E+02
P = 0.000000E+00 0.000000E+00 1.600286E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 3.580654E+00
P = 0.000000E+00 0.000000E+00 -3.580654E+00
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.338545E+03
P = 6.540862E-01 1.765604E+01 6.337865E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 6.495772E+03
P = -1.113054E-01 -1.626419E+01 -6.495751E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 2.073992E+00
P = -5.427809E-01 -1.391856E+00 1.438600E+00
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 6.338215E+03
P = 0.000000E+00 0.000000E+00 6.338215E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(21)
E = 6.496102E+03
P = 0.000000E+00 0.000000E+00 -6.496102E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 1.617849E+02
P = 0.000000E+00 0.000000E+00 1.617849E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(93*)
E = 3.898394E+00
P = 0.000000E+00 0.000000E+00 -3.898394E+00
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.266333E+03
P = 3.783216E-01 1.676683E+01 6.265647E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 6.039084E+03
P = -1.356140E+02 -3.407286E+02 -6.027939E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 5.288999E+02
P = 1.352357E+02 3.239618E+02 -3.955947E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 6.339971E+03
P = 0.000000E+00 0.000000E+00 6.339971E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 6.496419E+03
P = 0.000000E+00 0.000000E+00 -6.496419E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 1.600286E+02
P = 0.000000E+00 0.000000E+00 1.600286E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 3.580654E+00
P = 0.000000E+00 0.000000E+00 -3.580654E+00
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.338545E+03
P = 6.540862E-01 1.765604E+01 6.337865E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 6.495772E+03
P = -1.113054E-01 -1.626419E+01 -6.495751E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 2.073992E+00
P = -5.427809E-01 -1.391856E+00 1.438600E+00
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 1.28354E+04
n_in* => 2
n_out* => 5
n_tot* => 7
$process_id* => "nlo_ppzj_sim_1_p1"
process_num_id* => [unknown integer]
sqme* => 2.09972E-07
sqme_ref* => 8.73272E-12
event_index* => 4
event_weight* => 0.00000E+00
event_weight_ref* => 0.00000E+00
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:-2|-6.3399714E+03; 0.0000000E+00, 0.0000000E+00,-6.3399714E+03| 0.0000000E+00| 3)
4 prt(i:-2|-6.4964193E+03; 0.0000000E+00, 0.0000000E+00, 6.4964193E+03| 0.0000000E+00| 4)
5 prt(o:92| 1.6002860E+02; 0.0000000E+00, 0.0000000E+00, 1.6002860E+02| 0.0000000E+00| 5)
6 prt(o:92| 3.5806542E+00; 0.0000000E+00, 0.0000000E+00,-3.5806542E+00| 0.0000000E+00| 6)
7 prt(o:23| 6.3385452E+03; 6.5408625E-01, 1.7656042E+01, 6.3378646E+03| 8.3152513E+03| 7)
8 prt(o:-2| 6.4957715E+03;-1.1130537E-01,-1.6264186E+01,-6.4957512E+03| 0.0000000E+00| 8)
9 prt(o:-2| 2.0739923E+00;-5.4278088E-01,-1.3918560E+00, 1.4386000E+00| 0.0000000E+00| 9)
========================================================================
========================================================================
Event #4
------------------------------------------------------------------------
Unweighted = F
Normalization = 'sigma'
Helicity handling = drop
Keep correlations = F
------------------------------------------------------------------------
Squared matrix el. (ref) = 8.73272E-12
Squared matrix el. (prc) = 1.21148E-06
Event weight (ref) = 3.98580E-16
Event weight (prc) = 0.00000E+00
------------------------------------------------------------------------
Selected MCI group = 2
Selected term = 6
Selected channel = 4
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
3075724450.0, 3714364000.0, 1273526590.0,
654325229.0, 3346090863.0, 595080625.0,
]
Beginning substream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Initial stream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 6.338215E+03
P = 0.000000E+00 0.000000E+00 6.338215E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 6.496102E+03
P = 0.000000E+00 0.000000E+00 -6.496102E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 1.617849E+02
P = 0.000000E+00 0.000000E+00 1.617849E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 3.898394E+00
P = 0.000000E+00 0.000000E+00 -3.898394E+00
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.338543E+03
P = 3.826821E-01 1.696008E+01 6.337865E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 6.495773E+03
P = -3.826821E-01 -1.696008E+01 -6.495751E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
2368564314.0, 286886664.0, 1358903953.0,
3068176274.0, 3702895995.0, 1874125068.0,
]
Beginning substream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Initial stream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 6.339971E+03
P = 0.000000E+00 0.000000E+00 6.339971E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 6.496419E+03
P = 0.000000E+00 0.000000E+00 -6.496419E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 1.600286E+02
P = 0.000000E+00 0.000000E+00 1.600286E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 3.580654E+00
P = 0.000000E+00 0.000000E+00 -3.580654E+00
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.338545E+03
P = 6.540862E-01 1.765604E+01 6.337865E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 6.495772E+03
P = -1.113054E-01 -1.626419E+01 -6.495751E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 2.073992E+00
P = -5.427809E-01 -1.391856E+00 1.438600E+00
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 2.131353253E-10
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 6.338215E+03
P = 0.000000E+00 0.000000E+00 6.338215E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 6.496102E+03
P = 0.000000E+00 0.000000E+00 -6.496102E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 1.617849E+02
P = 0.000000E+00 0.000000E+00 1.617849E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 3.898394E+00
P = 0.000000E+00 0.000000E+00 -3.898394E+00
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.338543E+03
P = 3.826821E-01 1.696008E+01 6.337865E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 6.495773E+03
P = -3.826821E-01 -1.696008E+01 -6.495751E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 6.339971E+03
P = 0.000000E+00 0.000000E+00 6.339971E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 6.496419E+03
P = 0.000000E+00 0.000000E+00 -6.496419E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 1.600286E+02
P = 0.000000E+00 0.000000E+00 1.600286E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 3.580654E+00
P = 0.000000E+00 0.000000E+00 -3.580654E+00
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.338545E+03
P = 6.540862E-01 1.765604E+01 6.337865E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 6.495772E+03
P = -1.113054E-01 -1.626419E+01 -6.495751E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 2.073992E+00
P = -5.427809E-01 -1.391856E+00 1.438600E+00
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 6.339971E+03
P = 0.000000E+00 0.000000E+00 6.339971E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 6.496419E+03
P = 0.000000E+00 0.000000E+00 -6.496419E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 1.600286E+02
P = 0.000000E+00 0.000000E+00 1.600286E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 3.580654E+00
P = 0.000000E+00 0.000000E+00 -3.580654E+00
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.338545E+03
P = 6.540862E-01 1.765604E+01 6.337865E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 6.495772E+03
P = -1.113054E-01 -1.626419E+01 -6.495751E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 2.073992E+00
P = -5.427809E-01 -1.391856E+00 1.438600E+00
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 6.338215E+03
P = 0.000000E+00 0.000000E+00 6.338215E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(21)
E = 6.496102E+03
P = 0.000000E+00 0.000000E+00 -6.496102E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 1.617849E+02
P = 0.000000E+00 0.000000E+00 1.617849E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(93*)
E = 3.898394E+00
P = 0.000000E+00 0.000000E+00 -3.898394E+00
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.266333E+03
P = 3.783216E-01 1.676683E+01 6.265647E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 6.039084E+03
P = -1.356140E+02 -3.407286E+02 -6.027939E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 5.288999E+02
P = 1.352357E+02 3.239618E+02 -3.955947E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 6.339971E+03
P = 0.000000E+00 0.000000E+00 6.339971E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 6.496419E+03
P = 0.000000E+00 0.000000E+00 -6.496419E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 1.600286E+02
P = 0.000000E+00 0.000000E+00 1.600286E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 3.580654E+00
P = 0.000000E+00 0.000000E+00 -3.580654E+00
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.338545E+03
P = 6.540862E-01 1.765604E+01 6.337865E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 6.495772E+03
P = -1.113054E-01 -1.626419E+01 -6.495751E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 2.073992E+00
P = -5.427809E-01 -1.391856E+00 1.438600E+00
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 1.28354E+04
n_in* => 2
n_out* => 5
n_tot* => 7
$process_id* => "nlo_ppzj_sim_1_p1"
process_num_id* => [unknown integer]
sqme* => 1.21148E-06
sqme_ref* => 8.73272E-12
event_index* => 4
event_weight* => 0.00000E+00
event_weight_ref* => 0.00000E+00
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:-2|-6.3399714E+03; 0.0000000E+00, 0.0000000E+00,-6.3399714E+03| 0.0000000E+00| 3)
4 prt(i:-2|-6.4964193E+03; 0.0000000E+00, 0.0000000E+00, 6.4964193E+03| 0.0000000E+00| 4)
5 prt(o:92| 1.6002860E+02; 0.0000000E+00, 0.0000000E+00, 1.6002860E+02| 0.0000000E+00| 5)
6 prt(o:92| 3.5806542E+00; 0.0000000E+00, 0.0000000E+00,-3.5806542E+00| 0.0000000E+00| 6)
7 prt(o:23| 6.3385452E+03; 6.5408625E-01, 1.7656042E+01, 6.3378646E+03| 8.3152513E+03| 7)
8 prt(o:-2| 6.4957715E+03;-1.1130537E-01,-1.6264186E+01,-6.4957512E+03| 0.0000000E+00| 8)
9 prt(o:-2| 2.0739923E+00;-5.4278088E-01,-1.3918560E+00, 1.4386000E+00| 0.0000000E+00| 9)
========================================================================
========================================================================
Event #4
------------------------------------------------------------------------
Unweighted = F
Normalization = 'sigma'
Helicity handling = drop
Keep correlations = F
------------------------------------------------------------------------
Squared matrix el. (ref) = 8.73272E-12
Squared matrix el. (prc) = 8.73272E-12
Event weight (ref) = 3.98580E-16
Event weight (prc) = 3.98580E-16
------------------------------------------------------------------------
Selected MCI group = 2
Selected term = 6
Selected channel = 4
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
3075724450.0, 3714364000.0, 1273526590.0,
654325229.0, 3346090863.0, 595080625.0,
]
Beginning substream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Initial stream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 6.338215E+03
P = 0.000000E+00 0.000000E+00 6.338215E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 6.496102E+03
P = 0.000000E+00 0.000000E+00 -6.496102E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 1.617849E+02
P = 0.000000E+00 0.000000E+00 1.617849E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 3.898394E+00
P = 0.000000E+00 0.000000E+00 -3.898394E+00
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.338543E+03
P = 3.826821E-01 1.696008E+01 6.337865E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 6.495773E+03
P = -3.826821E-01 -1.696008E+01 -6.495751E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
2368564314.0, 286886664.0, 1358903953.0,
3068176274.0, 3702895995.0, 1874125068.0,
]
Beginning substream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Initial stream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 6.339971E+03
P = 0.000000E+00 0.000000E+00 6.339971E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 6.496419E+03
P = 0.000000E+00 0.000000E+00 -6.496419E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 1.600286E+02
P = 0.000000E+00 0.000000E+00 1.600286E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 3.580654E+00
P = 0.000000E+00 0.000000E+00 -3.580654E+00
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.338545E+03
P = 6.540862E-01 1.765604E+01 6.337865E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 6.495772E+03
P = -1.113054E-01 -1.626419E+01 -6.495751E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 2.073992E+00
P = -5.427809E-01 -1.391856E+00 1.438600E+00
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 2.131353253E-10
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 6.338215E+03
P = 0.000000E+00 0.000000E+00 6.338215E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 6.496102E+03
P = 0.000000E+00 0.000000E+00 -6.496102E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 1.617849E+02
P = 0.000000E+00 0.000000E+00 1.617849E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 3.898394E+00
P = 0.000000E+00 0.000000E+00 -3.898394E+00
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.338543E+03
P = 3.826821E-01 1.696008E+01 6.337865E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 6.495773E+03
P = -3.826821E-01 -1.696008E+01 -6.495751E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 6.339971E+03
P = 0.000000E+00 0.000000E+00 6.339971E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 6.496419E+03
P = 0.000000E+00 0.000000E+00 -6.496419E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 1.600286E+02
P = 0.000000E+00 0.000000E+00 1.600286E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 3.580654E+00
P = 0.000000E+00 0.000000E+00 -3.580654E+00
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.338545E+03
P = 6.540862E-01 1.765604E+01 6.337865E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 6.495772E+03
P = -1.113054E-01 -1.626419E+01 -6.495751E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 2.073992E+00
P = -5.427809E-01 -1.391856E+00 1.438600E+00
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 6.339971E+03
P = 0.000000E+00 0.000000E+00 6.339971E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 6.496419E+03
P = 0.000000E+00 0.000000E+00 -6.496419E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 1.600286E+02
P = 0.000000E+00 0.000000E+00 1.600286E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 3.580654E+00
P = 0.000000E+00 0.000000E+00 -3.580654E+00
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.338545E+03
P = 6.540862E-01 1.765604E+01 6.337865E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 6.495772E+03
P = -1.113054E-01 -1.626419E+01 -6.495751E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 2.073992E+00
P = -5.427809E-01 -1.391856E+00 1.438600E+00
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 6.338215E+03
P = 0.000000E+00 0.000000E+00 6.338215E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(21)
E = 6.496102E+03
P = 0.000000E+00 0.000000E+00 -6.496102E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 1.617849E+02
P = 0.000000E+00 0.000000E+00 1.617849E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(93*)
E = 3.898394E+00
P = 0.000000E+00 0.000000E+00 -3.898394E+00
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.266333E+03
P = 3.783216E-01 1.676683E+01 6.265647E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 6.039084E+03
P = -1.356140E+02 -3.407286E+02 -6.027939E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 5.288999E+02
P = 1.352357E+02 3.239618E+02 -3.955947E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 6.339971E+03
P = 0.000000E+00 0.000000E+00 6.339971E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 6.496419E+03
P = 0.000000E+00 0.000000E+00 -6.496419E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 1.600286E+02
P = 0.000000E+00 0.000000E+00 1.600286E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 3.580654E+00
P = 0.000000E+00 0.000000E+00 -3.580654E+00
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.338545E+03
P = 6.540862E-01 1.765604E+01 6.337865E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 6.495772E+03
P = -1.113054E-01 -1.626419E+01 -6.495751E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 2.073992E+00
P = -5.427809E-01 -1.391856E+00 1.438600E+00
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 1.28333E+04
n_in* => 2
n_out* => 5
n_tot* => 7
$process_id* => "nlo_ppzj_sim_1_p1"
process_num_id* => [unknown integer]
sqme* => 8.73272E-12
sqme_ref* => 8.73272E-12
event_index* => 4
event_weight* => 0.00000E+00
event_weight_ref* => 0.00000E+00
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:2|-6.3382151E+03; 0.0000000E+00, 0.0000000E+00,-6.3382151E+03| 0.0000000E+00| 3)
4 prt(i:21|-6.4961016E+03; 0.0000000E+00, 0.0000000E+00, 6.4961016E+03| 0.0000000E+00| 4)
5 prt(o:-92| 1.6178493E+02; 0.0000000E+00, 0.0000000E+00, 1.6178493E+02| 0.0000000E+00| 5)
6 prt(o:93| 3.8983944E+00; 0.0000000E+00, 0.0000000E+00,-3.8983944E+00| 0.0000000E+00| 6)
7 prt(o:23| 6.2663329E+03; 3.7832155E-01, 1.6766825E+01, 6.2656470E+03| 8.3152513E+03| 7)
8 prt(o:2| 6.0390838E+03;-1.3561402E+02,-3.4072863E+02,-6.0279388E+03| 0.0000000E+00| 8)
9 prt(o:21| 5.2889992E+02; 1.3523570E+02, 3.2396181E+02,-3.9559472E+02| 0.0000000E+00| 9)
========================================================================
========================================================================
Event #4
------------------------------------------------------------------------
Unweighted = F
Normalization = 'sigma'
Helicity handling = drop
Keep correlations = F
------------------------------------------------------------------------
Squared matrix el. (ref) = 8.73272E-12
Squared matrix el. (prc) = 2.13135E-10
Event weight (ref) = 3.98580E-16
Event weight (prc) = 0.00000E+00
------------------------------------------------------------------------
Selected MCI group = 2
Selected term = 6
Selected channel = 4
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
3075724450.0, 3714364000.0, 1273526590.0,
654325229.0, 3346090863.0, 595080625.0,
]
Beginning substream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Initial stream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 6.338215E+03
P = 0.000000E+00 0.000000E+00 6.338215E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 6.496102E+03
P = 0.000000E+00 0.000000E+00 -6.496102E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 1.617849E+02
P = 0.000000E+00 0.000000E+00 1.617849E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 3.898394E+00
P = 0.000000E+00 0.000000E+00 -3.898394E+00
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.338543E+03
P = 3.826821E-01 1.696008E+01 6.337865E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 6.495773E+03
P = -3.826821E-01 -1.696008E+01 -6.495751E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
2368564314.0, 286886664.0, 1358903953.0,
3068176274.0, 3702895995.0, 1874125068.0,
]
Beginning substream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Initial stream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 6.339971E+03
P = 0.000000E+00 0.000000E+00 6.339971E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 6.496419E+03
P = 0.000000E+00 0.000000E+00 -6.496419E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 1.600286E+02
P = 0.000000E+00 0.000000E+00 1.600286E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 3.580654E+00
P = 0.000000E+00 0.000000E+00 -3.580654E+00
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.338545E+03
P = 6.540862E-01 1.765604E+01 6.337865E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 6.495772E+03
P = -1.113054E-01 -1.626419E+01 -6.495751E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 2.073992E+00
P = -5.427809E-01 -1.391856E+00 1.438600E+00
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 2.131353253E-10
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 6.338215E+03
P = 0.000000E+00 0.000000E+00 6.338215E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 6.496102E+03
P = 0.000000E+00 0.000000E+00 -6.496102E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 1.617849E+02
P = 0.000000E+00 0.000000E+00 1.617849E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 3.898394E+00
P = 0.000000E+00 0.000000E+00 -3.898394E+00
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.338543E+03
P = 3.826821E-01 1.696008E+01 6.337865E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 6.495773E+03
P = -3.826821E-01 -1.696008E+01 -6.495751E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 6.339971E+03
P = 0.000000E+00 0.000000E+00 6.339971E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 6.496419E+03
P = 0.000000E+00 0.000000E+00 -6.496419E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 1.600286E+02
P = 0.000000E+00 0.000000E+00 1.600286E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 3.580654E+00
P = 0.000000E+00 0.000000E+00 -3.580654E+00
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.338545E+03
P = 6.540862E-01 1.765604E+01 6.337865E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 6.495772E+03
P = -1.113054E-01 -1.626419E+01 -6.495751E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 2.073992E+00
P = -5.427809E-01 -1.391856E+00 1.438600E+00
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 6.339971E+03
P = 0.000000E+00 0.000000E+00 6.339971E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 6.496419E+03
P = 0.000000E+00 0.000000E+00 -6.496419E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 1.600286E+02
P = 0.000000E+00 0.000000E+00 1.600286E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 3.580654E+00
P = 0.000000E+00 0.000000E+00 -3.580654E+00
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.338545E+03
P = 6.540862E-01 1.765604E+01 6.337865E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 6.495772E+03
P = -1.113054E-01 -1.626419E+01 -6.495751E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 2.073992E+00
P = -5.427809E-01 -1.391856E+00 1.438600E+00
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 6.338215E+03
P = 0.000000E+00 0.000000E+00 6.338215E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(21)
E = 6.496102E+03
P = 0.000000E+00 0.000000E+00 -6.496102E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 1.617849E+02
P = 0.000000E+00 0.000000E+00 1.617849E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(93*)
E = 3.898394E+00
P = 0.000000E+00 0.000000E+00 -3.898394E+00
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.266333E+03
P = 3.783216E-01 1.676683E+01 6.265647E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 6.039084E+03
P = -1.356140E+02 -3.407286E+02 -6.027939E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 5.288999E+02
P = 1.352357E+02 3.239618E+02 -3.955947E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 6.339971E+03
P = 0.000000E+00 0.000000E+00 6.339971E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 6.496419E+03
P = 0.000000E+00 0.000000E+00 -6.496419E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 1.600286E+02
P = 0.000000E+00 0.000000E+00 1.600286E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 3.580654E+00
P = 0.000000E+00 0.000000E+00 -3.580654E+00
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.338545E+03
P = 6.540862E-01 1.765604E+01 6.337865E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 6.495772E+03
P = -1.113054E-01 -1.626419E+01 -6.495751E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 2.073992E+00
P = -5.427809E-01 -1.391856E+00 1.438600E+00
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 1.28354E+04
n_in* => 2
n_out* => 5
n_tot* => 7
$process_id* => "nlo_ppzj_sim_1_p1"
process_num_id* => [unknown integer]
sqme* => 2.13135E-10
sqme_ref* => 8.73272E-12
event_index* => 4
event_weight* => 0.00000E+00
event_weight_ref* => 0.00000E+00
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:-3|-6.3399714E+03; 0.0000000E+00, 0.0000000E+00,-6.3399714E+03| 0.0000000E+00| 3)
4 prt(i:-3|-6.4964193E+03; 0.0000000E+00, 0.0000000E+00, 6.4964193E+03| 0.0000000E+00| 4)
5 prt(o:92| 1.6002860E+02; 0.0000000E+00, 0.0000000E+00, 1.6002860E+02| 0.0000000E+00| 5)
6 prt(o:92| 3.5806542E+00; 0.0000000E+00, 0.0000000E+00,-3.5806542E+00| 0.0000000E+00| 6)
7 prt(o:23| 6.3385452E+03; 6.5408625E-01, 1.7656042E+01, 6.3378646E+03| 8.3152513E+03| 7)
8 prt(o:-3| 6.4957715E+03;-1.1130537E-01,-1.6264186E+01,-6.4957512E+03| 0.0000000E+00| 8)
9 prt(o:-3| 2.0739923E+00;-5.4278088E-01,-1.3918560E+00, 1.4386000E+00| 0.0000000E+00| 9)
========================================================================
========================================================================
Event #5
------------------------------------------------------------------------
Unweighted = F
Normalization = 'sigma'
Helicity handling = drop
Keep correlations = F
------------------------------------------------------------------------
Squared matrix el. (ref) = 3.54058E-09
Squared matrix el. (prc) = -1.85195E-08
Event weight (ref) = 1.51411E-12
Event weight (prc) = 0.00000E+00
------------------------------------------------------------------------
Selected MCI group = 2
Selected term = 6
Selected channel = 4
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
1290911461.0, 1272409615.0, 1425418668.0,
1752005168.0, 2482810437.0, 3942703277.0,
]
Beginning substream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Initial stream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.987896E+03
P = 0.000000E+00 0.000000E+00 5.987896E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(-2)
E = 6.347167E+03
P = 0.000000E+00 0.000000E+00 -6.347167E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(-92*)
E = 5.121044E+02
P = 0.000000E+00 0.000000E+00 5.121044E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.528328E+02
P = 0.000000E+00 0.000000E+00 -1.528328E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.347493E+03
P = -1.965906E+01 1.586207E+01 -6.346788E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 5.987570E+03
P = 1.965906E+01 -1.586207E+01 5.987516E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
1348566029.0, 2127312.0, 2578220259.0,
1490566784.0, 2282904210.0, 3948374283.0,
]
Beginning substream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Initial stream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(21)
E = 6.290310E+03
P = 0.000000E+00 0.000000E+00 6.290310E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 6.469775E+03
P = 0.000000E+00 0.000000E+00 -6.469775E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(93*)
E = 2.096897E+02
P = 0.000000E+00 0.000000E+00 2.096897E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 3.022470E+01
P = 0.000000E+00 0.000000E+00 -3.022470E+01
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.351072E+03
P = -2.067010E+02 4.517618E+01 -6.346892E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 5.989804E+03
P = -1.673420E+02 1.344564E+01 5.987451E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 4.192088E+02
P = 3.740430E+02 -5.862182E+01 1.799760E+02
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 6.648939260E-14
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 5.987896E+03
P = 0.000000E+00 0.000000E+00 5.987896E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 6.347167E+03
P = 0.000000E+00 0.000000E+00 -6.347167E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 5.121044E+02
P = 0.000000E+00 0.000000E+00 5.121044E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 1.528328E+02
P = 0.000000E+00 0.000000E+00 -1.528328E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.347493E+03
P = -1.965906E+01 1.586207E+01 -6.346788E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 5.987570E+03
P = 1.965906E+01 -1.586207E+01 5.987516E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 6.290310E+03
P = 0.000000E+00 0.000000E+00 6.290310E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 6.469775E+03
P = 0.000000E+00 0.000000E+00 -6.469775E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 2.096897E+02
P = 0.000000E+00 0.000000E+00 2.096897E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 3.022470E+01
P = 0.000000E+00 0.000000E+00 -3.022470E+01
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.351072E+03
P = -2.067010E+02 4.517618E+01 -6.346892E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 5.989804E+03
P = -1.673420E+02 1.344564E+01 5.987451E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 4.192088E+02
P = 3.740430E+02 -5.862182E+01 1.799760E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 6.290310E+03
P = 0.000000E+00 0.000000E+00 6.290310E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 6.469775E+03
P = 0.000000E+00 0.000000E+00 -6.469775E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 2.096897E+02
P = 0.000000E+00 0.000000E+00 2.096897E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 3.022470E+01
P = 0.000000E+00 0.000000E+00 -3.022470E+01
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.351072E+03
P = -2.067010E+02 4.517618E+01 -6.346892E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 5.989804E+03
P = -1.673420E+02 1.344564E+01 5.987451E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 4.192088E+02
P = 3.740430E+02 -5.862182E+01 1.799760E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.987896E+03
P = 0.000000E+00 0.000000E+00 5.987896E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 6.347167E+03
P = 0.000000E+00 0.000000E+00 -6.347167E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 5.121044E+02
P = 0.000000E+00 0.000000E+00 5.121044E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.528328E+02
P = 0.000000E+00 0.000000E+00 -1.528328E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 5.995506E+03
P = -1.856867E+01 1.498228E+01 -5.994765E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 1.480457E+03
P = 5.838881E+02 1.003890E+03 9.181680E+02
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 4.859100E+03
P = -5.653194E+02 -1.018872E+03 4.717326E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(21)
E = 6.290310E+03
P = 0.000000E+00 0.000000E+00 6.290310E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 6.469775E+03
P = 0.000000E+00 0.000000E+00 -6.469775E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(93*)
E = 2.096897E+02
P = 0.000000E+00 0.000000E+00 2.096897E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 3.022470E+01
P = 0.000000E+00 0.000000E+00 -3.022470E+01
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.351072E+03
P = -2.067010E+02 4.517618E+01 -6.346892E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 5.989804E+03
P = -1.673420E+02 1.344564E+01 5.987451E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 4.192088E+02
P = 3.740430E+02 -5.862182E+01 1.799760E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 1.23298E+04
n_in* => 2
n_out* => 4
n_tot* => 6
$process_id* => "nlo_ppzj_sim_1_p1"
process_num_id* => [unknown integer]
sqme* => -1.85195E-08
sqme_ref* => 3.54058E-09
event_index* => 5
event_weight* => 0.00000E+00
event_weight_ref* => 1.51411E-12
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:-2|-5.9878956E+03; 0.0000000E+00, 0.0000000E+00,-5.9878956E+03| 0.0000000E+00| 3)
4 prt(i:2|-6.3471672E+03; 0.0000000E+00, 0.0000000E+00, 6.3471672E+03| 0.0000000E+00| 4)
5 prt(o:92| 5.1210440E+02; 0.0000000E+00, 0.0000000E+00, 5.1210440E+02| 0.0000000E+00| 5)
6 prt(o:-92| 1.5283279E+02; 0.0000000E+00, 0.0000000E+00,-1.5283279E+02| 0.0000000E+00| 6)
7 prt(o:23| 6.3474932E+03;-1.9659064E+01, 1.5862072E+01,-6.3467879E+03| 8.3152513E+03| 7)
8 prt(o:21| 5.9875696E+03; 1.9659064E+01,-1.5862072E+01, 5.9875163E+03| 0.0000000E+00| 8)
========================================================================
========================================================================
Event #5
------------------------------------------------------------------------
Unweighted = F
Normalization = 'sigma'
Helicity handling = drop
Keep correlations = F
------------------------------------------------------------------------
Squared matrix el. (ref) = 3.54058E-09
Squared matrix el. (prc) = 3.47432E-10
Event weight (ref) = 1.51411E-12
Event weight (prc) = 1.48577E-13
------------------------------------------------------------------------
Selected MCI group = 2
Selected term = 6
Selected channel = 4
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
1290911461.0, 1272409615.0, 1425418668.0,
1752005168.0, 2482810437.0, 3942703277.0,
]
Beginning substream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Initial stream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.987896E+03
P = 0.000000E+00 0.000000E+00 5.987896E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(-2)
E = 6.347167E+03
P = 0.000000E+00 0.000000E+00 -6.347167E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(-92*)
E = 5.121044E+02
P = 0.000000E+00 0.000000E+00 5.121044E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.528328E+02
P = 0.000000E+00 0.000000E+00 -1.528328E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.347493E+03
P = -1.965906E+01 1.586207E+01 -6.346788E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 5.987570E+03
P = 1.965906E+01 -1.586207E+01 5.987516E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
1348566029.0, 2127312.0, 2578220259.0,
1490566784.0, 2282904210.0, 3948374283.0,
]
Beginning substream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Initial stream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(21)
E = 6.290310E+03
P = 0.000000E+00 0.000000E+00 6.290310E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 6.469775E+03
P = 0.000000E+00 0.000000E+00 -6.469775E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(93*)
E = 2.096897E+02
P = 0.000000E+00 0.000000E+00 2.096897E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 3.022470E+01
P = 0.000000E+00 0.000000E+00 -3.022470E+01
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.351072E+03
P = -2.067010E+02 4.517618E+01 -6.346892E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 5.989804E+03
P = -1.673420E+02 1.344564E+01 5.987451E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 4.192088E+02
P = 3.740430E+02 -5.862182E+01 1.799760E+02
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 6.648939260E-14
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 5.987896E+03
P = 0.000000E+00 0.000000E+00 5.987896E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 6.347167E+03
P = 0.000000E+00 0.000000E+00 -6.347167E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 5.121044E+02
P = 0.000000E+00 0.000000E+00 5.121044E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 1.528328E+02
P = 0.000000E+00 0.000000E+00 -1.528328E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.347493E+03
P = -1.965906E+01 1.586207E+01 -6.346788E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 5.987570E+03
P = 1.965906E+01 -1.586207E+01 5.987516E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 6.290310E+03
P = 0.000000E+00 0.000000E+00 6.290310E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 6.469775E+03
P = 0.000000E+00 0.000000E+00 -6.469775E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 2.096897E+02
P = 0.000000E+00 0.000000E+00 2.096897E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 3.022470E+01
P = 0.000000E+00 0.000000E+00 -3.022470E+01
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.351072E+03
P = -2.067010E+02 4.517618E+01 -6.346892E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 5.989804E+03
P = -1.673420E+02 1.344564E+01 5.987451E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 4.192088E+02
P = 3.740430E+02 -5.862182E+01 1.799760E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 6.290310E+03
P = 0.000000E+00 0.000000E+00 6.290310E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 6.469775E+03
P = 0.000000E+00 0.000000E+00 -6.469775E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 2.096897E+02
P = 0.000000E+00 0.000000E+00 2.096897E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 3.022470E+01
P = 0.000000E+00 0.000000E+00 -3.022470E+01
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.351072E+03
P = -2.067010E+02 4.517618E+01 -6.346892E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 5.989804E+03
P = -1.673420E+02 1.344564E+01 5.987451E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 4.192088E+02
P = 3.740430E+02 -5.862182E+01 1.799760E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.987896E+03
P = 0.000000E+00 0.000000E+00 5.987896E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 6.347167E+03
P = 0.000000E+00 0.000000E+00 -6.347167E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 5.121044E+02
P = 0.000000E+00 0.000000E+00 5.121044E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.528328E+02
P = 0.000000E+00 0.000000E+00 -1.528328E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 5.995506E+03
P = -1.856867E+01 1.498228E+01 -5.994765E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 1.480457E+03
P = 5.838881E+02 1.003890E+03 9.181680E+02
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 4.859100E+03
P = -5.653194E+02 -1.018872E+03 4.717326E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(21)
E = 6.290310E+03
P = 0.000000E+00 0.000000E+00 6.290310E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 6.469775E+03
P = 0.000000E+00 0.000000E+00 -6.469775E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(93*)
E = 2.096897E+02
P = 0.000000E+00 0.000000E+00 2.096897E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 3.022470E+01
P = 0.000000E+00 0.000000E+00 -3.022470E+01
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.351072E+03
P = -2.067010E+02 4.517618E+01 -6.346892E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 5.989804E+03
P = -1.673420E+02 1.344564E+01 5.987451E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 4.192088E+02
P = 3.740430E+02 -5.862182E+01 1.799760E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 1.27588E+04
n_in* => 2
n_out* => 5
n_tot* => 7
$process_id* => "nlo_ppzj_sim_1_p1"
process_num_id* => [unknown integer]
sqme* => 3.47432E-10
sqme_ref* => 3.54058E-09
event_index* => 5
event_weight* => 1.48577E-13
event_weight_ref* => 1.51411E-12
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:2|-6.2903103E+03; 0.0000000E+00, 0.0000000E+00,-6.2903103E+03| 0.0000000E+00| 3)
4 prt(i:2|-6.4697753E+03; 0.0000000E+00, 0.0000000E+00, 6.4697753E+03| 0.0000000E+00| 4)
5 prt(o:-92| 2.0968970E+02; 0.0000000E+00, 0.0000000E+00, 2.0968970E+02| 0.0000000E+00| 5)
6 prt(o:-92| 3.0224703E+01; 0.0000000E+00, 0.0000000E+00,-3.0224703E+01| 0.0000000E+00| 6)
7 prt(o:23| 6.3510725E+03;-2.0670096E+02, 4.5176184E+01,-6.3468922E+03| 8.3152513E+03| 7)
8 prt(o:2| 5.9898044E+03;-1.6734200E+02, 1.3445640E+01, 5.9874512E+03| 0.0000000E+00| 8)
9 prt(o:2| 4.1920877E+02; 3.7404295E+02,-5.8621824E+01, 1.7997595E+02| 0.0000000E+00| 9)
========================================================================
========================================================================
Event #5
------------------------------------------------------------------------
Unweighted = F
Normalization = 'sigma'
Helicity handling = drop
Keep correlations = F
------------------------------------------------------------------------
Squared matrix el. (ref) = 3.54058E-09
Squared matrix el. (prc) = 8.60315E-10
Event weight (ref) = 1.51411E-12
Event weight (prc) = 3.67909E-13
------------------------------------------------------------------------
Selected MCI group = 2
Selected term = 6
Selected channel = 4
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
1290911461.0, 1272409615.0, 1425418668.0,
1752005168.0, 2482810437.0, 3942703277.0,
]
Beginning substream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Initial stream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.987896E+03
P = 0.000000E+00 0.000000E+00 5.987896E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(-2)
E = 6.347167E+03
P = 0.000000E+00 0.000000E+00 -6.347167E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(-92*)
E = 5.121044E+02
P = 0.000000E+00 0.000000E+00 5.121044E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.528328E+02
P = 0.000000E+00 0.000000E+00 -1.528328E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.347493E+03
P = -1.965906E+01 1.586207E+01 -6.346788E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 5.987570E+03
P = 1.965906E+01 -1.586207E+01 5.987516E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
1348566029.0, 2127312.0, 2578220259.0,
1490566784.0, 2282904210.0, 3948374283.0,
]
Beginning substream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Initial stream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(21)
E = 6.290310E+03
P = 0.000000E+00 0.000000E+00 6.290310E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 6.469775E+03
P = 0.000000E+00 0.000000E+00 -6.469775E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(93*)
E = 2.096897E+02
P = 0.000000E+00 0.000000E+00 2.096897E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 3.022470E+01
P = 0.000000E+00 0.000000E+00 -3.022470E+01
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.351072E+03
P = -2.067010E+02 4.517618E+01 -6.346892E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 5.989804E+03
P = -1.673420E+02 1.344564E+01 5.987451E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 4.192088E+02
P = 3.740430E+02 -5.862182E+01 1.799760E+02
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 6.648939260E-14
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 5.987896E+03
P = 0.000000E+00 0.000000E+00 5.987896E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 6.347167E+03
P = 0.000000E+00 0.000000E+00 -6.347167E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 5.121044E+02
P = 0.000000E+00 0.000000E+00 5.121044E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 1.528328E+02
P = 0.000000E+00 0.000000E+00 -1.528328E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.347493E+03
P = -1.965906E+01 1.586207E+01 -6.346788E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 5.987570E+03
P = 1.965906E+01 -1.586207E+01 5.987516E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 6.290310E+03
P = 0.000000E+00 0.000000E+00 6.290310E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 6.469775E+03
P = 0.000000E+00 0.000000E+00 -6.469775E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 2.096897E+02
P = 0.000000E+00 0.000000E+00 2.096897E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 3.022470E+01
P = 0.000000E+00 0.000000E+00 -3.022470E+01
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.351072E+03
P = -2.067010E+02 4.517618E+01 -6.346892E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 5.989804E+03
P = -1.673420E+02 1.344564E+01 5.987451E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 4.192088E+02
P = 3.740430E+02 -5.862182E+01 1.799760E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 6.290310E+03
P = 0.000000E+00 0.000000E+00 6.290310E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 6.469775E+03
P = 0.000000E+00 0.000000E+00 -6.469775E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 2.096897E+02
P = 0.000000E+00 0.000000E+00 2.096897E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 3.022470E+01
P = 0.000000E+00 0.000000E+00 -3.022470E+01
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.351072E+03
P = -2.067010E+02 4.517618E+01 -6.346892E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 5.989804E+03
P = -1.673420E+02 1.344564E+01 5.987451E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 4.192088E+02
P = 3.740430E+02 -5.862182E+01 1.799760E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.987896E+03
P = 0.000000E+00 0.000000E+00 5.987896E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 6.347167E+03
P = 0.000000E+00 0.000000E+00 -6.347167E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 5.121044E+02
P = 0.000000E+00 0.000000E+00 5.121044E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.528328E+02
P = 0.000000E+00 0.000000E+00 -1.528328E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 5.995506E+03
P = -1.856867E+01 1.498228E+01 -5.994765E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 1.480457E+03
P = 5.838881E+02 1.003890E+03 9.181680E+02
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 4.859100E+03
P = -5.653194E+02 -1.018872E+03 4.717326E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(21)
E = 6.290310E+03
P = 0.000000E+00 0.000000E+00 6.290310E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 6.469775E+03
P = 0.000000E+00 0.000000E+00 -6.469775E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(93*)
E = 2.096897E+02
P = 0.000000E+00 0.000000E+00 2.096897E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 3.022470E+01
P = 0.000000E+00 0.000000E+00 -3.022470E+01
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.351072E+03
P = -2.067010E+02 4.517618E+01 -6.346892E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 5.989804E+03
P = -1.673420E+02 1.344564E+01 5.987451E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 4.192088E+02
P = 3.740430E+02 -5.862182E+01 1.799760E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 1.27588E+04
n_in* => 2
n_out* => 5
n_tot* => 7
$process_id* => "nlo_ppzj_sim_1_p1"
process_num_id* => [unknown integer]
sqme* => 8.60315E-10
sqme_ref* => 3.54058E-09
event_index* => 5
event_weight* => 3.67909E-13
event_weight_ref* => 1.51411E-12
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:2|-6.2903103E+03; 0.0000000E+00, 0.0000000E+00,-6.2903103E+03| 0.0000000E+00| 3)
4 prt(i:2|-6.4697753E+03; 0.0000000E+00, 0.0000000E+00, 6.4697753E+03| 0.0000000E+00| 4)
5 prt(o:-92| 2.0968970E+02; 0.0000000E+00, 0.0000000E+00, 2.0968970E+02| 0.0000000E+00| 5)
6 prt(o:-92| 3.0224703E+01; 0.0000000E+00, 0.0000000E+00,-3.0224703E+01| 0.0000000E+00| 6)
7 prt(o:23| 6.3510725E+03;-2.0670096E+02, 4.5176184E+01,-6.3468922E+03| 8.3152513E+03| 7)
8 prt(o:2| 5.9898044E+03;-1.6734200E+02, 1.3445640E+01, 5.9874512E+03| 0.0000000E+00| 8)
9 prt(o:2| 4.1920877E+02; 3.7404295E+02,-5.8621824E+01, 1.7997595E+02| 0.0000000E+00| 9)
========================================================================
========================================================================
Event #5
------------------------------------------------------------------------
Unweighted = F
Normalization = 'sigma'
Helicity handling = drop
Keep correlations = F
------------------------------------------------------------------------
Squared matrix el. (ref) = 3.54058E-09
Squared matrix el. (prc) = 2.33276E-09
Event weight (ref) = 1.51411E-12
Event weight (prc) = 9.97593E-13
------------------------------------------------------------------------
Selected MCI group = 2
Selected term = 6
Selected channel = 4
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
1290911461.0, 1272409615.0, 1425418668.0,
1752005168.0, 2482810437.0, 3942703277.0,
]
Beginning substream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Initial stream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.987896E+03
P = 0.000000E+00 0.000000E+00 5.987896E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(-2)
E = 6.347167E+03
P = 0.000000E+00 0.000000E+00 -6.347167E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(-92*)
E = 5.121044E+02
P = 0.000000E+00 0.000000E+00 5.121044E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.528328E+02
P = 0.000000E+00 0.000000E+00 -1.528328E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.347493E+03
P = -1.965906E+01 1.586207E+01 -6.346788E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 5.987570E+03
P = 1.965906E+01 -1.586207E+01 5.987516E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
1348566029.0, 2127312.0, 2578220259.0,
1490566784.0, 2282904210.0, 3948374283.0,
]
Beginning substream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Initial stream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(21)
E = 6.290310E+03
P = 0.000000E+00 0.000000E+00 6.290310E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 6.469775E+03
P = 0.000000E+00 0.000000E+00 -6.469775E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(93*)
E = 2.096897E+02
P = 0.000000E+00 0.000000E+00 2.096897E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 3.022470E+01
P = 0.000000E+00 0.000000E+00 -3.022470E+01
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.351072E+03
P = -2.067010E+02 4.517618E+01 -6.346892E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 5.989804E+03
P = -1.673420E+02 1.344564E+01 5.987451E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 4.192088E+02
P = 3.740430E+02 -5.862182E+01 1.799760E+02
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 6.648939260E-14
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 5.987896E+03
P = 0.000000E+00 0.000000E+00 5.987896E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 6.347167E+03
P = 0.000000E+00 0.000000E+00 -6.347167E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 5.121044E+02
P = 0.000000E+00 0.000000E+00 5.121044E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 1.528328E+02
P = 0.000000E+00 0.000000E+00 -1.528328E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.347493E+03
P = -1.965906E+01 1.586207E+01 -6.346788E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 5.987570E+03
P = 1.965906E+01 -1.586207E+01 5.987516E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 6.290310E+03
P = 0.000000E+00 0.000000E+00 6.290310E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 6.469775E+03
P = 0.000000E+00 0.000000E+00 -6.469775E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 2.096897E+02
P = 0.000000E+00 0.000000E+00 2.096897E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 3.022470E+01
P = 0.000000E+00 0.000000E+00 -3.022470E+01
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.351072E+03
P = -2.067010E+02 4.517618E+01 -6.346892E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 5.989804E+03
P = -1.673420E+02 1.344564E+01 5.987451E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 4.192088E+02
P = 3.740430E+02 -5.862182E+01 1.799760E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 6.290310E+03
P = 0.000000E+00 0.000000E+00 6.290310E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 6.469775E+03
P = 0.000000E+00 0.000000E+00 -6.469775E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 2.096897E+02
P = 0.000000E+00 0.000000E+00 2.096897E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 3.022470E+01
P = 0.000000E+00 0.000000E+00 -3.022470E+01
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.351072E+03
P = -2.067010E+02 4.517618E+01 -6.346892E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 5.989804E+03
P = -1.673420E+02 1.344564E+01 5.987451E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 4.192088E+02
P = 3.740430E+02 -5.862182E+01 1.799760E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.987896E+03
P = 0.000000E+00 0.000000E+00 5.987896E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 6.347167E+03
P = 0.000000E+00 0.000000E+00 -6.347167E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 5.121044E+02
P = 0.000000E+00 0.000000E+00 5.121044E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.528328E+02
P = 0.000000E+00 0.000000E+00 -1.528328E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 5.995506E+03
P = -1.856867E+01 1.498228E+01 -5.994765E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 1.480457E+03
P = 5.838881E+02 1.003890E+03 9.181680E+02
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 4.859100E+03
P = -5.653194E+02 -1.018872E+03 4.717326E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(21)
E = 6.290310E+03
P = 0.000000E+00 0.000000E+00 6.290310E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 6.469775E+03
P = 0.000000E+00 0.000000E+00 -6.469775E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(93*)
E = 2.096897E+02
P = 0.000000E+00 0.000000E+00 2.096897E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 3.022470E+01
P = 0.000000E+00 0.000000E+00 -3.022470E+01
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.351072E+03
P = -2.067010E+02 4.517618E+01 -6.346892E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 5.989804E+03
P = -1.673420E+02 1.344564E+01 5.987451E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 4.192088E+02
P = 3.740430E+02 -5.862182E+01 1.799760E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 1.23298E+04
n_in* => 2
n_out* => 5
n_tot* => 7
$process_id* => "nlo_ppzj_sim_1_p1"
process_num_id* => [unknown integer]
sqme* => 2.33276E-09
sqme_ref* => 3.54058E-09
event_index* => 5
event_weight* => 9.97593E-13
event_weight_ref* => 1.51411E-12
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:2|-5.9878956E+03; 0.0000000E+00, 0.0000000E+00,-5.9878956E+03| 0.0000000E+00| 3)
4 prt(i:-2|-6.3471672E+03; 0.0000000E+00, 0.0000000E+00, 6.3471672E+03| 0.0000000E+00| 4)
5 prt(o:-92| 5.1210440E+02; 0.0000000E+00, 0.0000000E+00, 5.1210440E+02| 0.0000000E+00| 5)
6 prt(o:92| 1.5283279E+02; 0.0000000E+00, 0.0000000E+00,-1.5283279E+02| 0.0000000E+00| 6)
7 prt(o:23| 5.9955064E+03;-1.8568674E+01, 1.4982282E+01,-5.9947654E+03| 8.3152513E+03| 7)
8 prt(o:-2| 1.4804568E+03; 5.8388809E+02, 1.0038897E+03, 9.1816800E+02| 0.0000000E+00| 8)
9 prt(o:2| 4.8590996E+03;-5.6531941E+02,-1.0188720E+03, 4.7173258E+03| 0.0000000E+00| 9)
========================================================================
========================================================================
Event #5
------------------------------------------------------------------------
Unweighted = F
Normalization = 'sigma'
Helicity handling = drop
Keep correlations = F
------------------------------------------------------------------------
Squared matrix el. (ref) = 3.54058E-09
Squared matrix el. (prc) = 6.64894E-14
Event weight (ref) = 1.51411E-12
Event weight (prc) = 2.84338E-17
------------------------------------------------------------------------
Selected MCI group = 2
Selected term = 6
Selected channel = 4
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
1290911461.0, 1272409615.0, 1425418668.0,
1752005168.0, 2482810437.0, 3942703277.0,
]
Beginning substream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Initial stream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.987896E+03
P = 0.000000E+00 0.000000E+00 5.987896E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(-2)
E = 6.347167E+03
P = 0.000000E+00 0.000000E+00 -6.347167E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(-92*)
E = 5.121044E+02
P = 0.000000E+00 0.000000E+00 5.121044E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.528328E+02
P = 0.000000E+00 0.000000E+00 -1.528328E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.347493E+03
P = -1.965906E+01 1.586207E+01 -6.346788E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 5.987570E+03
P = 1.965906E+01 -1.586207E+01 5.987516E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
1348566029.0, 2127312.0, 2578220259.0,
1490566784.0, 2282904210.0, 3948374283.0,
]
Beginning substream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Initial stream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(21)
E = 6.290310E+03
P = 0.000000E+00 0.000000E+00 6.290310E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 6.469775E+03
P = 0.000000E+00 0.000000E+00 -6.469775E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(93*)
E = 2.096897E+02
P = 0.000000E+00 0.000000E+00 2.096897E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 3.022470E+01
P = 0.000000E+00 0.000000E+00 -3.022470E+01
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.351072E+03
P = -2.067010E+02 4.517618E+01 -6.346892E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 5.989804E+03
P = -1.673420E+02 1.344564E+01 5.987451E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 4.192088E+02
P = 3.740430E+02 -5.862182E+01 1.799760E+02
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 6.648939260E-14
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 5.987896E+03
P = 0.000000E+00 0.000000E+00 5.987896E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 6.347167E+03
P = 0.000000E+00 0.000000E+00 -6.347167E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 5.121044E+02
P = 0.000000E+00 0.000000E+00 5.121044E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 1.528328E+02
P = 0.000000E+00 0.000000E+00 -1.528328E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.347493E+03
P = -1.965906E+01 1.586207E+01 -6.346788E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 5.987570E+03
P = 1.965906E+01 -1.586207E+01 5.987516E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 6.290310E+03
P = 0.000000E+00 0.000000E+00 6.290310E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 6.469775E+03
P = 0.000000E+00 0.000000E+00 -6.469775E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 2.096897E+02
P = 0.000000E+00 0.000000E+00 2.096897E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 3.022470E+01
P = 0.000000E+00 0.000000E+00 -3.022470E+01
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.351072E+03
P = -2.067010E+02 4.517618E+01 -6.346892E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 5.989804E+03
P = -1.673420E+02 1.344564E+01 5.987451E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 4.192088E+02
P = 3.740430E+02 -5.862182E+01 1.799760E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 6.290310E+03
P = 0.000000E+00 0.000000E+00 6.290310E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 6.469775E+03
P = 0.000000E+00 0.000000E+00 -6.469775E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 2.096897E+02
P = 0.000000E+00 0.000000E+00 2.096897E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 3.022470E+01
P = 0.000000E+00 0.000000E+00 -3.022470E+01
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.351072E+03
P = -2.067010E+02 4.517618E+01 -6.346892E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 5.989804E+03
P = -1.673420E+02 1.344564E+01 5.987451E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 4.192088E+02
P = 3.740430E+02 -5.862182E+01 1.799760E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.987896E+03
P = 0.000000E+00 0.000000E+00 5.987896E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 6.347167E+03
P = 0.000000E+00 0.000000E+00 -6.347167E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 5.121044E+02
P = 0.000000E+00 0.000000E+00 5.121044E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.528328E+02
P = 0.000000E+00 0.000000E+00 -1.528328E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 5.995506E+03
P = -1.856867E+01 1.498228E+01 -5.994765E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 1.480457E+03
P = 5.838881E+02 1.003890E+03 9.181680E+02
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 4.859100E+03
P = -5.653194E+02 -1.018872E+03 4.717326E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(21)
E = 6.290310E+03
P = 0.000000E+00 0.000000E+00 6.290310E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 6.469775E+03
P = 0.000000E+00 0.000000E+00 -6.469775E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(93*)
E = 2.096897E+02
P = 0.000000E+00 0.000000E+00 2.096897E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 3.022470E+01
P = 0.000000E+00 0.000000E+00 -3.022470E+01
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.351072E+03
P = -2.067010E+02 4.517618E+01 -6.346892E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 5.989804E+03
P = -1.673420E+02 1.344564E+01 5.987451E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 4.192088E+02
P = 3.740430E+02 -5.862182E+01 1.799760E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 1.27588E+04
n_in* => 2
n_out* => 5
n_tot* => 7
$process_id* => "nlo_ppzj_sim_1_p1"
process_num_id* => [unknown integer]
sqme* => 6.64894E-14
sqme_ref* => 3.54058E-09
event_index* => 5
event_weight* => 0.00000E+00
event_weight_ref* => 1.51411E-12
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:21|-6.2903103E+03; 0.0000000E+00, 0.0000000E+00,-6.2903103E+03| 0.0000000E+00| 3)
4 prt(i:2|-6.4697753E+03; 0.0000000E+00, 0.0000000E+00, 6.4697753E+03| 0.0000000E+00| 4)
5 prt(o:93| 2.0968970E+02; 0.0000000E+00, 0.0000000E+00, 2.0968970E+02| 0.0000000E+00| 5)
6 prt(o:-92| 3.0224703E+01; 0.0000000E+00, 0.0000000E+00,-3.0224703E+01| 0.0000000E+00| 6)
7 prt(o:23| 6.3510725E+03;-2.0670096E+02, 4.5176184E+01,-6.3468922E+03| 8.3152513E+03| 7)
8 prt(o:2| 5.9898044E+03;-1.6734200E+02, 1.3445640E+01, 5.9874512E+03| 0.0000000E+00| 8)
9 prt(o:21| 4.1920877E+02; 3.7404295E+02,-5.8621824E+01, 1.7997595E+02| 0.0000000E+00| 9)
========================================================================
========================================================================
Event #6
------------------------------------------------------------------------
Unweighted = F
Normalization = 'sigma'
Helicity handling = drop
Keep correlations = F
------------------------------------------------------------------------
Squared matrix el. (ref) = 4.95415E-02
Squared matrix el. (prc) = 3.41786E-02
Event weight (ref) = 9.07679E-01
Event weight (prc) = 6.26205E-01
------------------------------------------------------------------------
Selected MCI group = 2
Selected term = 6
Selected channel = 4
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
3451162052.0, 2126038146.0, 4124525625.0,
4198549315.0, 1748905574.0, 1385684486.0,
]
Beginning substream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Initial stream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 1.889356E+03
P = 0.000000E+00 0.000000E+00 1.889356E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 3.808422E+03
P = 0.000000E+00 0.000000E+00 -3.808422E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 4.610644E+03
P = 0.000000E+00 0.000000E+00 4.610644E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 2.691578E+03
P = 0.000000E+00 0.000000E+00 -2.691578E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.901826E+03
P = -3.797913E+02 -1.588359E+02 1.854497E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 3.795952E+03
P = 3.797913E+02 1.588359E+02 -3.773563E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
4088271236.0, 3058148814.0, 3157141285.0,
2721973815.0, 2133413731.0, 3716612499.0,
]
Beginning substream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Initial stream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 1.910352E+03
P = 0.000000E+00 0.000000E+00 1.910352E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 4.730499E+03
P = 0.000000E+00 0.000000E+00 -4.730499E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 4.589648E+03
P = 0.000000E+00 0.000000E+00 4.589648E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.769501E+03
P = 0.000000E+00 0.000000E+00 -1.769501E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.924462E+03
P = -5.112009E+02 -1.515711E+02 1.846873E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 3.780120E+03
P = 2.493408E+02 1.660476E+02 -3.768231E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 9.362693E+02
P = 2.618601E+02 -1.447651E+01 -8.987881E+02
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 4.952607476E-03
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 1.889356E+03
P = 0.000000E+00 0.000000E+00 1.889356E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 3.808422E+03
P = 0.000000E+00 0.000000E+00 -3.808422E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 4.610644E+03
P = 0.000000E+00 0.000000E+00 4.610644E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 2.691578E+03
P = 0.000000E+00 0.000000E+00 -2.691578E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.901826E+03
P = -3.797913E+02 -1.588359E+02 1.854497E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 3.795952E+03
P = 3.797913E+02 1.588359E+02 -3.773563E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 1.910352E+03
P = 0.000000E+00 0.000000E+00 1.910352E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 4.730499E+03
P = 0.000000E+00 0.000000E+00 -4.730499E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 4.589648E+03
P = 0.000000E+00 0.000000E+00 4.589648E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.769501E+03
P = 0.000000E+00 0.000000E+00 -1.769501E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.924462E+03
P = -5.112009E+02 -1.515711E+02 1.846873E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 3.780120E+03
P = 2.493408E+02 1.660476E+02 -3.768231E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 9.362693E+02
P = 2.618601E+02 -1.447651E+01 -8.987881E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 1.910352E+03
P = 0.000000E+00 0.000000E+00 1.910352E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 4.730499E+03
P = 0.000000E+00 0.000000E+00 -4.730499E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 4.589648E+03
P = 0.000000E+00 0.000000E+00 4.589648E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.769501E+03
P = 0.000000E+00 0.000000E+00 -1.769501E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.924462E+03
P = -5.112009E+02 -1.515711E+02 1.846873E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 3.780120E+03
P = 2.493408E+02 1.660476E+02 -3.768231E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 9.362693E+02
P = 2.618601E+02 -1.447651E+01 -8.987881E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 1.889356E+03
P = 0.000000E+00 0.000000E+00 1.889356E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 3.808422E+03
P = 0.000000E+00 0.000000E+00 -3.808422E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 4.610644E+03
P = 0.000000E+00 0.000000E+00 4.610644E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 2.691578E+03
P = 0.000000E+00 0.000000E+00 -2.691578E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.081992E+03
P = -2.156800E+02 -9.020146E+01 1.052491E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 3.575039E+03
P = 3.281872E+01 1.006303E+03 -3.430332E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 1.040747E+03
P = 1.828613E+02 -9.161014E+02 4.587750E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 1.910352E+03
P = 0.000000E+00 0.000000E+00 1.910352E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 4.730499E+03
P = 0.000000E+00 0.000000E+00 -4.730499E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 4.589648E+03
P = 0.000000E+00 0.000000E+00 4.589648E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.769501E+03
P = 0.000000E+00 0.000000E+00 -1.769501E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.924462E+03
P = -5.112009E+02 -1.515711E+02 1.846873E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 3.780120E+03
P = 2.493408E+02 1.660476E+02 -3.768231E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 9.362693E+02
P = 2.618601E+02 -1.447651E+01 -8.987881E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 5.36487E+03
n_in* => 2
n_out* => 4
n_tot* => 6
$process_id* => "nlo_ppzj_sim_1_p1"
process_num_id* => [unknown integer]
sqme* => 3.41786E-02
sqme_ref* => 4.95415E-02
event_index* => 6
event_weight* => 6.26205E-01
event_weight_ref* => 9.07679E-01
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:-2|-1.8893557E+03; 0.0000000E+00, 0.0000000E+00,-1.8893557E+03| 0.0000000E+00| 3)
4 prt(i:2|-3.8084223E+03; 0.0000000E+00, 0.0000000E+00, 3.8084223E+03| 0.0000000E+00| 4)
5 prt(o:92| 4.6106443E+03; 0.0000000E+00, 0.0000000E+00, 4.6106443E+03| 0.0000000E+00| 5)
6 prt(o:-92| 2.6915777E+03; 0.0000000E+00, 0.0000000E+00,-2.6915777E+03| 0.0000000E+00| 6)
7 prt(o:23| 1.9018263E+03;-3.7979134E+02,-1.5883590E+02, 1.8544966E+03| 8.3152513E+03| 7)
8 prt(o:21| 3.7959517E+03; 3.7979134E+02, 1.5883590E+02,-3.7735632E+03| 0.0000000E+00| 8)
========================================================================
========================================================================
Event #6
------------------------------------------------------------------------
Unweighted = F
Normalization = 'sigma'
Helicity handling = drop
Keep correlations = F
------------------------------------------------------------------------
Squared matrix el. (ref) = 4.95415E-02
Squared matrix el. (prc) = 9.97304E-02
Event weight (ref) = 9.07679E-01
Event weight (prc) = 0.00000E+00
------------------------------------------------------------------------
Selected MCI group = 2
Selected term = 6
Selected channel = 4
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
3451162052.0, 2126038146.0, 4124525625.0,
4198549315.0, 1748905574.0, 1385684486.0,
]
Beginning substream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Initial stream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 1.889356E+03
P = 0.000000E+00 0.000000E+00 1.889356E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 3.808422E+03
P = 0.000000E+00 0.000000E+00 -3.808422E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 4.610644E+03
P = 0.000000E+00 0.000000E+00 4.610644E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 2.691578E+03
P = 0.000000E+00 0.000000E+00 -2.691578E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.901826E+03
P = -3.797913E+02 -1.588359E+02 1.854497E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 3.795952E+03
P = 3.797913E+02 1.588359E+02 -3.773563E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
4088271236.0, 3058148814.0, 3157141285.0,
2721973815.0, 2133413731.0, 3716612499.0,
]
Beginning substream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Initial stream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 1.910352E+03
P = 0.000000E+00 0.000000E+00 1.910352E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 4.730499E+03
P = 0.000000E+00 0.000000E+00 -4.730499E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 4.589648E+03
P = 0.000000E+00 0.000000E+00 4.589648E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.769501E+03
P = 0.000000E+00 0.000000E+00 -1.769501E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.924462E+03
P = -5.112009E+02 -1.515711E+02 1.846873E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 3.780120E+03
P = 2.493408E+02 1.660476E+02 -3.768231E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 9.362693E+02
P = 2.618601E+02 -1.447651E+01 -8.987881E+02
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 4.952607476E-03
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 1.889356E+03
P = 0.000000E+00 0.000000E+00 1.889356E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 3.808422E+03
P = 0.000000E+00 0.000000E+00 -3.808422E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 4.610644E+03
P = 0.000000E+00 0.000000E+00 4.610644E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 2.691578E+03
P = 0.000000E+00 0.000000E+00 -2.691578E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.901826E+03
P = -3.797913E+02 -1.588359E+02 1.854497E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 3.795952E+03
P = 3.797913E+02 1.588359E+02 -3.773563E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 1.910352E+03
P = 0.000000E+00 0.000000E+00 1.910352E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 4.730499E+03
P = 0.000000E+00 0.000000E+00 -4.730499E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 4.589648E+03
P = 0.000000E+00 0.000000E+00 4.589648E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.769501E+03
P = 0.000000E+00 0.000000E+00 -1.769501E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.924462E+03
P = -5.112009E+02 -1.515711E+02 1.846873E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 3.780120E+03
P = 2.493408E+02 1.660476E+02 -3.768231E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 9.362693E+02
P = 2.618601E+02 -1.447651E+01 -8.987881E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 1.910352E+03
P = 0.000000E+00 0.000000E+00 1.910352E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 4.730499E+03
P = 0.000000E+00 0.000000E+00 -4.730499E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 4.589648E+03
P = 0.000000E+00 0.000000E+00 4.589648E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.769501E+03
P = 0.000000E+00 0.000000E+00 -1.769501E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.924462E+03
P = -5.112009E+02 -1.515711E+02 1.846873E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 3.780120E+03
P = 2.493408E+02 1.660476E+02 -3.768231E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 9.362693E+02
P = 2.618601E+02 -1.447651E+01 -8.987881E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 1.889356E+03
P = 0.000000E+00 0.000000E+00 1.889356E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 3.808422E+03
P = 0.000000E+00 0.000000E+00 -3.808422E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 4.610644E+03
P = 0.000000E+00 0.000000E+00 4.610644E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 2.691578E+03
P = 0.000000E+00 0.000000E+00 -2.691578E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.081992E+03
P = -2.156800E+02 -9.020146E+01 1.052491E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 3.575039E+03
P = 3.281872E+01 1.006303E+03 -3.430332E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 1.040747E+03
P = 1.828613E+02 -9.161014E+02 4.587750E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 1.910352E+03
P = 0.000000E+00 0.000000E+00 1.910352E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 4.730499E+03
P = 0.000000E+00 0.000000E+00 -4.730499E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 4.589648E+03
P = 0.000000E+00 0.000000E+00 4.589648E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.769501E+03
P = 0.000000E+00 0.000000E+00 -1.769501E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.924462E+03
P = -5.112009E+02 -1.515711E+02 1.846873E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 3.780120E+03
P = 2.493408E+02 1.660476E+02 -3.768231E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 9.362693E+02
P = 2.618601E+02 -1.447651E+01 -8.987881E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 6.01229E+03
n_in* => 2
n_out* => 5
n_tot* => 7
$process_id* => "nlo_ppzj_sim_1_p1"
process_num_id* => [unknown integer]
sqme* => 9.97304E-02
sqme_ref* => 4.95415E-02
event_index* => 6
event_weight* => 0.00000E+00
event_weight_ref* => 9.07679E-01
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:-2|-1.9103525E+03; 0.0000000E+00, 0.0000000E+00,-1.9103525E+03| 0.0000000E+00| 3)
4 prt(i:-2|-4.7304988E+03; 0.0000000E+00, 0.0000000E+00, 4.7304988E+03| 0.0000000E+00| 4)
5 prt(o:92| 4.5896475E+03; 0.0000000E+00, 0.0000000E+00, 4.5896475E+03| 0.0000000E+00| 5)
6 prt(o:92| 1.7695012E+03; 0.0000000E+00, 0.0000000E+00,-1.7695012E+03| 0.0000000E+00| 6)
7 prt(o:23| 1.9244620E+03;-5.1120089E+02,-1.5157113E+02, 1.8468726E+03| 8.3152513E+03| 7)
8 prt(o:-2| 3.7801199E+03; 2.4934082E+02, 1.6604764E+02,-3.7682309E+03| 0.0000000E+00| 8)
9 prt(o:-2| 9.3626934E+02; 2.6186007E+02,-1.4476510E+01,-8.9878808E+02| 0.0000000E+00| 9)
========================================================================
========================================================================
Event #6
------------------------------------------------------------------------
Unweighted = F
Normalization = 'sigma'
Helicity handling = drop
Keep correlations = F
------------------------------------------------------------------------
Squared matrix el. (ref) = 4.95415E-02
Squared matrix el. (prc) = 1.07175E-02
Event weight (ref) = 9.07679E-01
Event weight (prc) = 0.00000E+00
------------------------------------------------------------------------
Selected MCI group = 2
Selected term = 6
Selected channel = 4
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
3451162052.0, 2126038146.0, 4124525625.0,
4198549315.0, 1748905574.0, 1385684486.0,
]
Beginning substream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Initial stream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 1.889356E+03
P = 0.000000E+00 0.000000E+00 1.889356E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 3.808422E+03
P = 0.000000E+00 0.000000E+00 -3.808422E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 4.610644E+03
P = 0.000000E+00 0.000000E+00 4.610644E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 2.691578E+03
P = 0.000000E+00 0.000000E+00 -2.691578E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.901826E+03
P = -3.797913E+02 -1.588359E+02 1.854497E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 3.795952E+03
P = 3.797913E+02 1.588359E+02 -3.773563E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
4088271236.0, 3058148814.0, 3157141285.0,
2721973815.0, 2133413731.0, 3716612499.0,
]
Beginning substream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Initial stream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 1.910352E+03
P = 0.000000E+00 0.000000E+00 1.910352E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 4.730499E+03
P = 0.000000E+00 0.000000E+00 -4.730499E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 4.589648E+03
P = 0.000000E+00 0.000000E+00 4.589648E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.769501E+03
P = 0.000000E+00 0.000000E+00 -1.769501E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.924462E+03
P = -5.112009E+02 -1.515711E+02 1.846873E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 3.780120E+03
P = 2.493408E+02 1.660476E+02 -3.768231E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 9.362693E+02
P = 2.618601E+02 -1.447651E+01 -8.987881E+02
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 4.952607476E-03
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 1.889356E+03
P = 0.000000E+00 0.000000E+00 1.889356E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 3.808422E+03
P = 0.000000E+00 0.000000E+00 -3.808422E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 4.610644E+03
P = 0.000000E+00 0.000000E+00 4.610644E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 2.691578E+03
P = 0.000000E+00 0.000000E+00 -2.691578E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.901826E+03
P = -3.797913E+02 -1.588359E+02 1.854497E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 3.795952E+03
P = 3.797913E+02 1.588359E+02 -3.773563E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 1.910352E+03
P = 0.000000E+00 0.000000E+00 1.910352E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 4.730499E+03
P = 0.000000E+00 0.000000E+00 -4.730499E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 4.589648E+03
P = 0.000000E+00 0.000000E+00 4.589648E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.769501E+03
P = 0.000000E+00 0.000000E+00 -1.769501E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.924462E+03
P = -5.112009E+02 -1.515711E+02 1.846873E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 3.780120E+03
P = 2.493408E+02 1.660476E+02 -3.768231E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 9.362693E+02
P = 2.618601E+02 -1.447651E+01 -8.987881E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 1.910352E+03
P = 0.000000E+00 0.000000E+00 1.910352E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 4.730499E+03
P = 0.000000E+00 0.000000E+00 -4.730499E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 4.589648E+03
P = 0.000000E+00 0.000000E+00 4.589648E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.769501E+03
P = 0.000000E+00 0.000000E+00 -1.769501E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.924462E+03
P = -5.112009E+02 -1.515711E+02 1.846873E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 3.780120E+03
P = 2.493408E+02 1.660476E+02 -3.768231E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 9.362693E+02
P = 2.618601E+02 -1.447651E+01 -8.987881E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 1.889356E+03
P = 0.000000E+00 0.000000E+00 1.889356E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 3.808422E+03
P = 0.000000E+00 0.000000E+00 -3.808422E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 4.610644E+03
P = 0.000000E+00 0.000000E+00 4.610644E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 2.691578E+03
P = 0.000000E+00 0.000000E+00 -2.691578E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.081992E+03
P = -2.156800E+02 -9.020146E+01 1.052491E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 3.575039E+03
P = 3.281872E+01 1.006303E+03 -3.430332E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 1.040747E+03
P = 1.828613E+02 -9.161014E+02 4.587750E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 1.910352E+03
P = 0.000000E+00 0.000000E+00 1.910352E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 4.730499E+03
P = 0.000000E+00 0.000000E+00 -4.730499E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 4.589648E+03
P = 0.000000E+00 0.000000E+00 4.589648E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.769501E+03
P = 0.000000E+00 0.000000E+00 -1.769501E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.924462E+03
P = -5.112009E+02 -1.515711E+02 1.846873E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 3.780120E+03
P = 2.493408E+02 1.660476E+02 -3.768231E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 9.362693E+02
P = 2.618601E+02 -1.447651E+01 -8.987881E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 6.01229E+03
n_in* => 2
n_out* => 5
n_tot* => 7
$process_id* => "nlo_ppzj_sim_1_p1"
process_num_id* => [unknown integer]
sqme* => 1.07175E-02
sqme_ref* => 4.95415E-02
event_index* => 6
event_weight* => 0.00000E+00
event_weight_ref* => 9.07679E-01
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:-2|-1.9103525E+03; 0.0000000E+00, 0.0000000E+00,-1.9103525E+03| 0.0000000E+00| 3)
4 prt(i:-2|-4.7304988E+03; 0.0000000E+00, 0.0000000E+00, 4.7304988E+03| 0.0000000E+00| 4)
5 prt(o:92| 4.5896475E+03; 0.0000000E+00, 0.0000000E+00, 4.5896475E+03| 0.0000000E+00| 5)
6 prt(o:92| 1.7695012E+03; 0.0000000E+00, 0.0000000E+00,-1.7695012E+03| 0.0000000E+00| 6)
7 prt(o:23| 1.9244620E+03;-5.1120089E+02,-1.5157113E+02, 1.8468726E+03| 8.3152513E+03| 7)
8 prt(o:-2| 3.7801199E+03; 2.4934082E+02, 1.6604764E+02,-3.7682309E+03| 0.0000000E+00| 8)
9 prt(o:-2| 9.3626934E+02; 2.6186007E+02,-1.4476510E+01,-8.9878808E+02| 0.0000000E+00| 9)
========================================================================
========================================================================
Event #6
------------------------------------------------------------------------
Unweighted = F
Normalization = 'sigma'
Helicity handling = drop
Keep correlations = F
------------------------------------------------------------------------
Squared matrix el. (ref) = 4.95415E-02
Squared matrix el. (prc) = 1.53630E-02
Event weight (ref) = 9.07679E-01
Event weight (prc) = 2.81474E-01
------------------------------------------------------------------------
Selected MCI group = 2
Selected term = 6
Selected channel = 4
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
3451162052.0, 2126038146.0, 4124525625.0,
4198549315.0, 1748905574.0, 1385684486.0,
]
Beginning substream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Initial stream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 1.889356E+03
P = 0.000000E+00 0.000000E+00 1.889356E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 3.808422E+03
P = 0.000000E+00 0.000000E+00 -3.808422E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 4.610644E+03
P = 0.000000E+00 0.000000E+00 4.610644E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 2.691578E+03
P = 0.000000E+00 0.000000E+00 -2.691578E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.901826E+03
P = -3.797913E+02 -1.588359E+02 1.854497E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 3.795952E+03
P = 3.797913E+02 1.588359E+02 -3.773563E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
4088271236.0, 3058148814.0, 3157141285.0,
2721973815.0, 2133413731.0, 3716612499.0,
]
Beginning substream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Initial stream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 1.910352E+03
P = 0.000000E+00 0.000000E+00 1.910352E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 4.730499E+03
P = 0.000000E+00 0.000000E+00 -4.730499E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 4.589648E+03
P = 0.000000E+00 0.000000E+00 4.589648E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.769501E+03
P = 0.000000E+00 0.000000E+00 -1.769501E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.924462E+03
P = -5.112009E+02 -1.515711E+02 1.846873E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 3.780120E+03
P = 2.493408E+02 1.660476E+02 -3.768231E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 9.362693E+02
P = 2.618601E+02 -1.447651E+01 -8.987881E+02
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 4.952607476E-03
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 1.889356E+03
P = 0.000000E+00 0.000000E+00 1.889356E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 3.808422E+03
P = 0.000000E+00 0.000000E+00 -3.808422E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 4.610644E+03
P = 0.000000E+00 0.000000E+00 4.610644E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 2.691578E+03
P = 0.000000E+00 0.000000E+00 -2.691578E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.901826E+03
P = -3.797913E+02 -1.588359E+02 1.854497E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 3.795952E+03
P = 3.797913E+02 1.588359E+02 -3.773563E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 1.910352E+03
P = 0.000000E+00 0.000000E+00 1.910352E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 4.730499E+03
P = 0.000000E+00 0.000000E+00 -4.730499E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 4.589648E+03
P = 0.000000E+00 0.000000E+00 4.589648E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.769501E+03
P = 0.000000E+00 0.000000E+00 -1.769501E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.924462E+03
P = -5.112009E+02 -1.515711E+02 1.846873E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 3.780120E+03
P = 2.493408E+02 1.660476E+02 -3.768231E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 9.362693E+02
P = 2.618601E+02 -1.447651E+01 -8.987881E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 1.910352E+03
P = 0.000000E+00 0.000000E+00 1.910352E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 4.730499E+03
P = 0.000000E+00 0.000000E+00 -4.730499E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 4.589648E+03
P = 0.000000E+00 0.000000E+00 4.589648E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.769501E+03
P = 0.000000E+00 0.000000E+00 -1.769501E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.924462E+03
P = -5.112009E+02 -1.515711E+02 1.846873E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 3.780120E+03
P = 2.493408E+02 1.660476E+02 -3.768231E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 9.362693E+02
P = 2.618601E+02 -1.447651E+01 -8.987881E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 1.889356E+03
P = 0.000000E+00 0.000000E+00 1.889356E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 3.808422E+03
P = 0.000000E+00 0.000000E+00 -3.808422E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 4.610644E+03
P = 0.000000E+00 0.000000E+00 4.610644E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 2.691578E+03
P = 0.000000E+00 0.000000E+00 -2.691578E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.081992E+03
P = -2.156800E+02 -9.020146E+01 1.052491E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 3.575039E+03
P = 3.281872E+01 1.006303E+03 -3.430332E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 1.040747E+03
P = 1.828613E+02 -9.161014E+02 4.587750E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 1.910352E+03
P = 0.000000E+00 0.000000E+00 1.910352E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 4.730499E+03
P = 0.000000E+00 0.000000E+00 -4.730499E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 4.589648E+03
P = 0.000000E+00 0.000000E+00 4.589648E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.769501E+03
P = 0.000000E+00 0.000000E+00 -1.769501E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.924462E+03
P = -5.112009E+02 -1.515711E+02 1.846873E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 3.780120E+03
P = 2.493408E+02 1.660476E+02 -3.768231E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 9.362693E+02
P = 2.618601E+02 -1.447651E+01 -8.987881E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 5.36487E+03
n_in* => 2
n_out* => 5
n_tot* => 7
$process_id* => "nlo_ppzj_sim_1_p1"
process_num_id* => [unknown integer]
sqme* => 1.53630E-02
sqme_ref* => 4.95415E-02
event_index* => 6
event_weight* => 2.81474E-01
event_weight_ref* => 9.07679E-01
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:-2|-1.8893557E+03; 0.0000000E+00, 0.0000000E+00,-1.8893557E+03| 0.0000000E+00| 3)
4 prt(i:2|-3.8084223E+03; 0.0000000E+00, 0.0000000E+00, 3.8084223E+03| 0.0000000E+00| 4)
5 prt(o:92| 4.6106443E+03; 0.0000000E+00, 0.0000000E+00, 4.6106443E+03| 0.0000000E+00| 5)
6 prt(o:-92| 2.6915777E+03; 0.0000000E+00, 0.0000000E+00,-2.6915777E+03| 0.0000000E+00| 6)
7 prt(o:23| 1.0819919E+03;-2.1568003E+02,-9.0201456E+01, 1.0524908E+03| 8.3152513E+03| 7)
8 prt(o:21| 3.5750390E+03; 3.2818722E+01, 1.0063029E+03,-3.4303325E+03| 0.0000000E+00| 8)
9 prt(o:21| 1.0407472E+03; 1.8286131E+02,-9.1610144E+02, 4.5877504E+02| 0.0000000E+00| 9)
========================================================================
========================================================================
Event #6
------------------------------------------------------------------------
Unweighted = F
Normalization = 'sigma'
Helicity handling = drop
Keep correlations = F
------------------------------------------------------------------------
Squared matrix el. (ref) = 4.95415E-02
Squared matrix el. (prc) = 4.95261E-03
Event weight (ref) = 9.07679E-01
Event weight (prc) = 0.00000E+00
------------------------------------------------------------------------
Selected MCI group = 2
Selected term = 6
Selected channel = 4
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
3451162052.0, 2126038146.0, 4124525625.0,
4198549315.0, 1748905574.0, 1385684486.0,
]
Beginning substream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Initial stream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 1.889356E+03
P = 0.000000E+00 0.000000E+00 1.889356E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 3.808422E+03
P = 0.000000E+00 0.000000E+00 -3.808422E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 4.610644E+03
P = 0.000000E+00 0.000000E+00 4.610644E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 2.691578E+03
P = 0.000000E+00 0.000000E+00 -2.691578E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.901826E+03
P = -3.797913E+02 -1.588359E+02 1.854497E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 3.795952E+03
P = 3.797913E+02 1.588359E+02 -3.773563E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
4088271236.0, 3058148814.0, 3157141285.0,
2721973815.0, 2133413731.0, 3716612499.0,
]
Beginning substream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Initial stream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 1.910352E+03
P = 0.000000E+00 0.000000E+00 1.910352E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 4.730499E+03
P = 0.000000E+00 0.000000E+00 -4.730499E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 4.589648E+03
P = 0.000000E+00 0.000000E+00 4.589648E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.769501E+03
P = 0.000000E+00 0.000000E+00 -1.769501E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.924462E+03
P = -5.112009E+02 -1.515711E+02 1.846873E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 3.780120E+03
P = 2.493408E+02 1.660476E+02 -3.768231E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 9.362693E+02
P = 2.618601E+02 -1.447651E+01 -8.987881E+02
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 4.952607476E-03
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 1.889356E+03
P = 0.000000E+00 0.000000E+00 1.889356E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 3.808422E+03
P = 0.000000E+00 0.000000E+00 -3.808422E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 4.610644E+03
P = 0.000000E+00 0.000000E+00 4.610644E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 2.691578E+03
P = 0.000000E+00 0.000000E+00 -2.691578E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.901826E+03
P = -3.797913E+02 -1.588359E+02 1.854497E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 3.795952E+03
P = 3.797913E+02 1.588359E+02 -3.773563E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 1.910352E+03
P = 0.000000E+00 0.000000E+00 1.910352E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 4.730499E+03
P = 0.000000E+00 0.000000E+00 -4.730499E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 4.589648E+03
P = 0.000000E+00 0.000000E+00 4.589648E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.769501E+03
P = 0.000000E+00 0.000000E+00 -1.769501E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.924462E+03
P = -5.112009E+02 -1.515711E+02 1.846873E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 3.780120E+03
P = 2.493408E+02 1.660476E+02 -3.768231E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 9.362693E+02
P = 2.618601E+02 -1.447651E+01 -8.987881E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 1.910352E+03
P = 0.000000E+00 0.000000E+00 1.910352E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 4.730499E+03
P = 0.000000E+00 0.000000E+00 -4.730499E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 4.589648E+03
P = 0.000000E+00 0.000000E+00 4.589648E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.769501E+03
P = 0.000000E+00 0.000000E+00 -1.769501E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.924462E+03
P = -5.112009E+02 -1.515711E+02 1.846873E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 3.780120E+03
P = 2.493408E+02 1.660476E+02 -3.768231E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 9.362693E+02
P = 2.618601E+02 -1.447651E+01 -8.987881E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 1.889356E+03
P = 0.000000E+00 0.000000E+00 1.889356E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 3.808422E+03
P = 0.000000E+00 0.000000E+00 -3.808422E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 4.610644E+03
P = 0.000000E+00 0.000000E+00 4.610644E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 2.691578E+03
P = 0.000000E+00 0.000000E+00 -2.691578E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.081992E+03
P = -2.156800E+02 -9.020146E+01 1.052491E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 3.575039E+03
P = 3.281872E+01 1.006303E+03 -3.430332E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 1.040747E+03
P = 1.828613E+02 -9.161014E+02 4.587750E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 1.910352E+03
P = 0.000000E+00 0.000000E+00 1.910352E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 4.730499E+03
P = 0.000000E+00 0.000000E+00 -4.730499E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 4.589648E+03
P = 0.000000E+00 0.000000E+00 4.589648E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.769501E+03
P = 0.000000E+00 0.000000E+00 -1.769501E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.924462E+03
P = -5.112009E+02 -1.515711E+02 1.846873E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 3.780120E+03
P = 2.493408E+02 1.660476E+02 -3.768231E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 9.362693E+02
P = 2.618601E+02 -1.447651E+01 -8.987881E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 6.01229E+03
n_in* => 2
n_out* => 5
n_tot* => 7
$process_id* => "nlo_ppzj_sim_1_p1"
process_num_id* => [unknown integer]
sqme* => 4.95261E-03
sqme_ref* => 4.95415E-02
event_index* => 6
event_weight* => 0.00000E+00
event_weight_ref* => 9.07679E-01
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:-3|-1.9103525E+03; 0.0000000E+00, 0.0000000E+00,-1.9103525E+03| 0.0000000E+00| 3)
4 prt(i:-3|-4.7304988E+03; 0.0000000E+00, 0.0000000E+00, 4.7304988E+03| 0.0000000E+00| 4)
5 prt(o:92| 4.5896475E+03; 0.0000000E+00, 0.0000000E+00, 4.5896475E+03| 0.0000000E+00| 5)
6 prt(o:92| 1.7695012E+03; 0.0000000E+00, 0.0000000E+00,-1.7695012E+03| 0.0000000E+00| 6)
7 prt(o:23| 1.9244620E+03;-5.1120089E+02,-1.5157113E+02, 1.8468726E+03| 8.3152513E+03| 7)
8 prt(o:-3| 3.7801199E+03; 2.4934082E+02, 1.6604764E+02,-3.7682309E+03| 0.0000000E+00| 8)
9 prt(o:-3| 9.3626934E+02; 2.6186007E+02,-1.4476510E+01,-8.9878808E+02| 0.0000000E+00| 9)
========================================================================
========================================================================
Event #7
------------------------------------------------------------------------
Unweighted = F
Normalization = 'sigma'
Helicity handling = drop
Keep correlations = F
------------------------------------------------------------------------
Squared matrix el. (ref) = 1.02069E-05
Squared matrix el. (prc) = 1.27762E-01
Event weight (ref) = 7.15005E-07
Event weight (prc) = 0.00000E+00
------------------------------------------------------------------------
Selected MCI group = 2
Selected term = 6
Selected channel = 4
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
1343569551.0, 923711388.0, 2741230169.0,
607667879.0, 415492869.0, 2531095270.0,
]
Beginning substream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Initial stream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 5.339070E+03
P = 0.000000E+00 0.000000E+00 5.339070E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 4.703203E+03
P = 0.000000E+00 0.000000E+00 -4.703203E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 1.160930E+03
P = 0.000000E+00 0.000000E+00 1.160930E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 1.796797E+03
P = 0.000000E+00 0.000000E+00 -1.796797E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 4.703725E+03
P = -5.300535E+01 9.916386E+01 -4.701497E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 5.338548E+03
P = 5.300535E+01 -9.916386E+01 5.337364E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
3151030428.0, 3465847835.0, 1593585735.0,
1647623300.0, 1779762511.0, 62582738.0,
]
Beginning substream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Initial stream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 5.387315E+03
P = 0.000000E+00 0.000000E+00 5.387315E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 5.309140E+03
P = 0.000000E+00 0.000000E+00 -5.309140E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 1.112685E+03
P = 0.000000E+00 0.000000E+00 1.112685E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.190860E+03
P = 0.000000E+00 0.000000E+00 -1.190860E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 4.702741E+03
P = 2.577897E+01 -4.620725E+01 -4.701559E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 5.345000E+03
P = 1.318350E+02 -2.446186E+02 5.337772E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 6.487132E+02
P = -1.576139E+02 2.908258E+02 -5.580385E+02
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 7.166480593E-06
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 5.339070E+03
P = 0.000000E+00 0.000000E+00 5.339070E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 4.703203E+03
P = 0.000000E+00 0.000000E+00 -4.703203E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 1.160930E+03
P = 0.000000E+00 0.000000E+00 1.160930E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 1.796797E+03
P = 0.000000E+00 0.000000E+00 -1.796797E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 4.703725E+03
P = -5.300535E+01 9.916386E+01 -4.701497E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 5.338548E+03
P = 5.300535E+01 -9.916386E+01 5.337364E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 5.387315E+03
P = 0.000000E+00 0.000000E+00 5.387315E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 5.309140E+03
P = 0.000000E+00 0.000000E+00 -5.309140E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 1.112685E+03
P = 0.000000E+00 0.000000E+00 1.112685E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.190860E+03
P = 0.000000E+00 0.000000E+00 -1.190860E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 4.702741E+03
P = 2.577897E+01 -4.620725E+01 -4.701559E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 5.345000E+03
P = 1.318350E+02 -2.446186E+02 5.337772E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 6.487132E+02
P = -1.576139E+02 2.908258E+02 -5.580385E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 5.387315E+03
P = 0.000000E+00 0.000000E+00 5.387315E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 5.309140E+03
P = 0.000000E+00 0.000000E+00 -5.309140E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 1.112685E+03
P = 0.000000E+00 0.000000E+00 1.112685E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.190860E+03
P = 0.000000E+00 0.000000E+00 -1.190860E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 4.702741E+03
P = 2.577897E+01 -4.620725E+01 -4.701559E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 5.345000E+03
P = 1.318350E+02 -2.446186E+02 5.337772E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 6.487132E+02
P = -1.576139E+02 2.908258E+02 -5.580385E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 5.339070E+03
P = 0.000000E+00 0.000000E+00 5.339070E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 4.703203E+03
P = 0.000000E+00 0.000000E+00 -4.703203E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 1.160930E+03
P = 0.000000E+00 0.000000E+00 1.160930E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 1.796797E+03
P = 0.000000E+00 0.000000E+00 -1.796797E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.970087E+03
P = -3.346039E+01 6.259862E+01 -2.967838E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 5.069644E+03
P = 3.829443E+01 -1.681391E+03 4.782546E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 2.002543E+03
P = -4.834037E+00 1.618792E+03 -1.178841E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 5.387315E+03
P = 0.000000E+00 0.000000E+00 5.387315E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 5.309140E+03
P = 0.000000E+00 0.000000E+00 -5.309140E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 1.112685E+03
P = 0.000000E+00 0.000000E+00 1.112685E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.190860E+03
P = 0.000000E+00 0.000000E+00 -1.190860E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 4.702741E+03
P = 2.577897E+01 -4.620725E+01 -4.701559E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 5.345000E+03
P = 1.318350E+02 -2.446186E+02 5.337772E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 6.487132E+02
P = -1.576139E+02 2.908258E+02 -5.580385E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 1.00221E+04
n_in* => 2
n_out* => 4
n_tot* => 6
$process_id* => "nlo_ppzj_sim_1_p1"
process_num_id* => [unknown integer]
sqme* => 1.27762E-01
sqme_ref* => 1.02069E-05
event_index* => 7
event_weight* => 0.00000E+00
event_weight_ref* => 7.15005E-07
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:-2|-5.3390699E+03; 0.0000000E+00, 0.0000000E+00,-5.3390699E+03| 0.0000000E+00| 3)
4 prt(i:2|-4.7032029E+03; 0.0000000E+00, 0.0000000E+00, 4.7032029E+03| 0.0000000E+00| 4)
5 prt(o:92| 1.1609301E+03; 0.0000000E+00, 0.0000000E+00, 1.1609301E+03| 0.0000000E+00| 5)
6 prt(o:-92| 1.7967971E+03; 0.0000000E+00, 0.0000000E+00,-1.7967971E+03| 0.0000000E+00| 6)
7 prt(o:23| 4.7037250E+03;-5.3005349E+01, 9.9163862E+01,-4.7014966E+03| 8.3152513E+03| 7)
8 prt(o:21| 5.3385478E+03; 5.3005349E+01,-9.9163862E+01, 5.3373636E+03| 0.0000000E+00| 8)
========================================================================
========================================================================
Event #7
------------------------------------------------------------------------
Unweighted = F
Normalization = 'sigma'
Helicity handling = drop
Keep correlations = F
------------------------------------------------------------------------
Squared matrix el. (ref) = 1.02069E-05
Squared matrix el. (prc) = 2.87699E-01
Event weight (ref) = 7.15005E-07
Event weight (prc) = 0.00000E+00
------------------------------------------------------------------------
Selected MCI group = 2
Selected term = 6
Selected channel = 4
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
1343569551.0, 923711388.0, 2741230169.0,
607667879.0, 415492869.0, 2531095270.0,
]
Beginning substream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Initial stream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 5.339070E+03
P = 0.000000E+00 0.000000E+00 5.339070E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 4.703203E+03
P = 0.000000E+00 0.000000E+00 -4.703203E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 1.160930E+03
P = 0.000000E+00 0.000000E+00 1.160930E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 1.796797E+03
P = 0.000000E+00 0.000000E+00 -1.796797E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 4.703725E+03
P = -5.300535E+01 9.916386E+01 -4.701497E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 5.338548E+03
P = 5.300535E+01 -9.916386E+01 5.337364E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
3151030428.0, 3465847835.0, 1593585735.0,
1647623300.0, 1779762511.0, 62582738.0,
]
Beginning substream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Initial stream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 5.387315E+03
P = 0.000000E+00 0.000000E+00 5.387315E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 5.309140E+03
P = 0.000000E+00 0.000000E+00 -5.309140E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 1.112685E+03
P = 0.000000E+00 0.000000E+00 1.112685E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.190860E+03
P = 0.000000E+00 0.000000E+00 -1.190860E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 4.702741E+03
P = 2.577897E+01 -4.620725E+01 -4.701559E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 5.345000E+03
P = 1.318350E+02 -2.446186E+02 5.337772E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 6.487132E+02
P = -1.576139E+02 2.908258E+02 -5.580385E+02
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 7.166480593E-06
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 5.339070E+03
P = 0.000000E+00 0.000000E+00 5.339070E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 4.703203E+03
P = 0.000000E+00 0.000000E+00 -4.703203E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 1.160930E+03
P = 0.000000E+00 0.000000E+00 1.160930E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 1.796797E+03
P = 0.000000E+00 0.000000E+00 -1.796797E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 4.703725E+03
P = -5.300535E+01 9.916386E+01 -4.701497E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 5.338548E+03
P = 5.300535E+01 -9.916386E+01 5.337364E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 5.387315E+03
P = 0.000000E+00 0.000000E+00 5.387315E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 5.309140E+03
P = 0.000000E+00 0.000000E+00 -5.309140E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 1.112685E+03
P = 0.000000E+00 0.000000E+00 1.112685E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.190860E+03
P = 0.000000E+00 0.000000E+00 -1.190860E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 4.702741E+03
P = 2.577897E+01 -4.620725E+01 -4.701559E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 5.345000E+03
P = 1.318350E+02 -2.446186E+02 5.337772E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 6.487132E+02
P = -1.576139E+02 2.908258E+02 -5.580385E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 5.387315E+03
P = 0.000000E+00 0.000000E+00 5.387315E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 5.309140E+03
P = 0.000000E+00 0.000000E+00 -5.309140E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 1.112685E+03
P = 0.000000E+00 0.000000E+00 1.112685E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.190860E+03
P = 0.000000E+00 0.000000E+00 -1.190860E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 4.702741E+03
P = 2.577897E+01 -4.620725E+01 -4.701559E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 5.345000E+03
P = 1.318350E+02 -2.446186E+02 5.337772E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 6.487132E+02
P = -1.576139E+02 2.908258E+02 -5.580385E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 5.339070E+03
P = 0.000000E+00 0.000000E+00 5.339070E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 4.703203E+03
P = 0.000000E+00 0.000000E+00 -4.703203E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 1.160930E+03
P = 0.000000E+00 0.000000E+00 1.160930E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 1.796797E+03
P = 0.000000E+00 0.000000E+00 -1.796797E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.970087E+03
P = -3.346039E+01 6.259862E+01 -2.967838E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 5.069644E+03
P = 3.829443E+01 -1.681391E+03 4.782546E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 2.002543E+03
P = -4.834037E+00 1.618792E+03 -1.178841E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 5.387315E+03
P = 0.000000E+00 0.000000E+00 5.387315E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 5.309140E+03
P = 0.000000E+00 0.000000E+00 -5.309140E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 1.112685E+03
P = 0.000000E+00 0.000000E+00 1.112685E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.190860E+03
P = 0.000000E+00 0.000000E+00 -1.190860E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 4.702741E+03
P = 2.577897E+01 -4.620725E+01 -4.701559E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 5.345000E+03
P = 1.318350E+02 -2.446186E+02 5.337772E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 6.487132E+02
P = -1.576139E+02 2.908258E+02 -5.580385E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 1.06962E+04
n_in* => 2
n_out* => 5
n_tot* => 7
$process_id* => "nlo_ppzj_sim_1_p1"
process_num_id* => [unknown integer]
sqme* => 2.87699E-01
sqme_ref* => 1.02069E-05
event_index* => 7
event_weight* => 0.00000E+00
event_weight_ref* => 7.15005E-07
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:-2|-5.3873146E+03; 0.0000000E+00, 0.0000000E+00,-5.3873146E+03| 0.0000000E+00| 3)
4 prt(i:-2|-5.3091399E+03; 0.0000000E+00, 0.0000000E+00, 5.3091399E+03| 0.0000000E+00| 4)
5 prt(o:92| 1.1126854E+03; 0.0000000E+00, 0.0000000E+00, 1.1126854E+03| 0.0000000E+00| 5)
6 prt(o:92| 1.1908601E+03; 0.0000000E+00, 0.0000000E+00,-1.1908601E+03| 0.0000000E+00| 6)
7 prt(o:23| 4.7027408E+03; 2.5778968E+01,-4.6207255E+01,-4.7015589E+03| 8.3152513E+03| 7)
8 prt(o:-2| 5.3450005E+03; 1.3183497E+02,-2.4461856E+02, 5.3377721E+03| 0.0000000E+00| 8)
9 prt(o:-2| 6.4871321E+02;-1.5761394E+02, 2.9082582E+02,-5.5803855E+02| 0.0000000E+00| 9)
========================================================================
========================================================================
Event #7
------------------------------------------------------------------------
Unweighted = F
Normalization = 'sigma'
Helicity handling = drop
Keep correlations = F
------------------------------------------------------------------------
Squared matrix el. (ref) = 1.02069E-05
Squared matrix el. (prc) = 1.93194E-02
Event weight (ref) = 7.15005E-07
Event weight (prc) = 0.00000E+00
------------------------------------------------------------------------
Selected MCI group = 2
Selected term = 6
Selected channel = 4
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
1343569551.0, 923711388.0, 2741230169.0,
607667879.0, 415492869.0, 2531095270.0,
]
Beginning substream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Initial stream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 5.339070E+03
P = 0.000000E+00 0.000000E+00 5.339070E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 4.703203E+03
P = 0.000000E+00 0.000000E+00 -4.703203E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 1.160930E+03
P = 0.000000E+00 0.000000E+00 1.160930E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 1.796797E+03
P = 0.000000E+00 0.000000E+00 -1.796797E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 4.703725E+03
P = -5.300535E+01 9.916386E+01 -4.701497E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 5.338548E+03
P = 5.300535E+01 -9.916386E+01 5.337364E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
3151030428.0, 3465847835.0, 1593585735.0,
1647623300.0, 1779762511.0, 62582738.0,
]
Beginning substream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Initial stream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 5.387315E+03
P = 0.000000E+00 0.000000E+00 5.387315E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 5.309140E+03
P = 0.000000E+00 0.000000E+00 -5.309140E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 1.112685E+03
P = 0.000000E+00 0.000000E+00 1.112685E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.190860E+03
P = 0.000000E+00 0.000000E+00 -1.190860E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 4.702741E+03
P = 2.577897E+01 -4.620725E+01 -4.701559E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 5.345000E+03
P = 1.318350E+02 -2.446186E+02 5.337772E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 6.487132E+02
P = -1.576139E+02 2.908258E+02 -5.580385E+02
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 7.166480593E-06
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 5.339070E+03
P = 0.000000E+00 0.000000E+00 5.339070E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 4.703203E+03
P = 0.000000E+00 0.000000E+00 -4.703203E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 1.160930E+03
P = 0.000000E+00 0.000000E+00 1.160930E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 1.796797E+03
P = 0.000000E+00 0.000000E+00 -1.796797E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 4.703725E+03
P = -5.300535E+01 9.916386E+01 -4.701497E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 5.338548E+03
P = 5.300535E+01 -9.916386E+01 5.337364E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 5.387315E+03
P = 0.000000E+00 0.000000E+00 5.387315E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 5.309140E+03
P = 0.000000E+00 0.000000E+00 -5.309140E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 1.112685E+03
P = 0.000000E+00 0.000000E+00 1.112685E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.190860E+03
P = 0.000000E+00 0.000000E+00 -1.190860E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 4.702741E+03
P = 2.577897E+01 -4.620725E+01 -4.701559E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 5.345000E+03
P = 1.318350E+02 -2.446186E+02 5.337772E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 6.487132E+02
P = -1.576139E+02 2.908258E+02 -5.580385E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 5.387315E+03
P = 0.000000E+00 0.000000E+00 5.387315E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 5.309140E+03
P = 0.000000E+00 0.000000E+00 -5.309140E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 1.112685E+03
P = 0.000000E+00 0.000000E+00 1.112685E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.190860E+03
P = 0.000000E+00 0.000000E+00 -1.190860E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 4.702741E+03
P = 2.577897E+01 -4.620725E+01 -4.701559E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 5.345000E+03
P = 1.318350E+02 -2.446186E+02 5.337772E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 6.487132E+02
P = -1.576139E+02 2.908258E+02 -5.580385E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 5.339070E+03
P = 0.000000E+00 0.000000E+00 5.339070E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 4.703203E+03
P = 0.000000E+00 0.000000E+00 -4.703203E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 1.160930E+03
P = 0.000000E+00 0.000000E+00 1.160930E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 1.796797E+03
P = 0.000000E+00 0.000000E+00 -1.796797E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.970087E+03
P = -3.346039E+01 6.259862E+01 -2.967838E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 5.069644E+03
P = 3.829443E+01 -1.681391E+03 4.782546E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 2.002543E+03
P = -4.834037E+00 1.618792E+03 -1.178841E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 5.387315E+03
P = 0.000000E+00 0.000000E+00 5.387315E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 5.309140E+03
P = 0.000000E+00 0.000000E+00 -5.309140E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 1.112685E+03
P = 0.000000E+00 0.000000E+00 1.112685E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.190860E+03
P = 0.000000E+00 0.000000E+00 -1.190860E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 4.702741E+03
P = 2.577897E+01 -4.620725E+01 -4.701559E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 5.345000E+03
P = 1.318350E+02 -2.446186E+02 5.337772E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 6.487132E+02
P = -1.576139E+02 2.908258E+02 -5.580385E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 1.06962E+04
n_in* => 2
n_out* => 5
n_tot* => 7
$process_id* => "nlo_ppzj_sim_1_p1"
process_num_id* => [unknown integer]
sqme* => 1.93194E-02
sqme_ref* => 1.02069E-05
event_index* => 7
event_weight* => 0.00000E+00
event_weight_ref* => 7.15005E-07
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:-2|-5.3873146E+03; 0.0000000E+00, 0.0000000E+00,-5.3873146E+03| 0.0000000E+00| 3)
4 prt(i:-2|-5.3091399E+03; 0.0000000E+00, 0.0000000E+00, 5.3091399E+03| 0.0000000E+00| 4)
5 prt(o:92| 1.1126854E+03; 0.0000000E+00, 0.0000000E+00, 1.1126854E+03| 0.0000000E+00| 5)
6 prt(o:92| 1.1908601E+03; 0.0000000E+00, 0.0000000E+00,-1.1908601E+03| 0.0000000E+00| 6)
7 prt(o:23| 4.7027408E+03; 2.5778968E+01,-4.6207255E+01,-4.7015589E+03| 8.3152513E+03| 7)
8 prt(o:-2| 5.3450005E+03; 1.3183497E+02,-2.4461856E+02, 5.3377721E+03| 0.0000000E+00| 8)
9 prt(o:-2| 6.4871321E+02;-1.5761394E+02, 2.9082582E+02,-5.5803855E+02| 0.0000000E+00| 9)
========================================================================
========================================================================
Event #7
------------------------------------------------------------------------
Unweighted = F
Normalization = 'sigma'
Helicity handling = drop
Keep correlations = F
------------------------------------------------------------------------
Squared matrix el. (ref) = 1.02069E-05
Squared matrix el. (prc) = 1.02069E-05
Event weight (ref) = 7.15005E-07
Event weight (prc) = 7.15005E-07
------------------------------------------------------------------------
Selected MCI group = 2
Selected term = 6
Selected channel = 4
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
1343569551.0, 923711388.0, 2741230169.0,
607667879.0, 415492869.0, 2531095270.0,
]
Beginning substream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Initial stream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 5.339070E+03
P = 0.000000E+00 0.000000E+00 5.339070E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 4.703203E+03
P = 0.000000E+00 0.000000E+00 -4.703203E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 1.160930E+03
P = 0.000000E+00 0.000000E+00 1.160930E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 1.796797E+03
P = 0.000000E+00 0.000000E+00 -1.796797E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 4.703725E+03
P = -5.300535E+01 9.916386E+01 -4.701497E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 5.338548E+03
P = 5.300535E+01 -9.916386E+01 5.337364E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
3151030428.0, 3465847835.0, 1593585735.0,
1647623300.0, 1779762511.0, 62582738.0,
]
Beginning substream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Initial stream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 5.387315E+03
P = 0.000000E+00 0.000000E+00 5.387315E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 5.309140E+03
P = 0.000000E+00 0.000000E+00 -5.309140E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 1.112685E+03
P = 0.000000E+00 0.000000E+00 1.112685E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.190860E+03
P = 0.000000E+00 0.000000E+00 -1.190860E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 4.702741E+03
P = 2.577897E+01 -4.620725E+01 -4.701559E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 5.345000E+03
P = 1.318350E+02 -2.446186E+02 5.337772E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 6.487132E+02
P = -1.576139E+02 2.908258E+02 -5.580385E+02
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 7.166480593E-06
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 5.339070E+03
P = 0.000000E+00 0.000000E+00 5.339070E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 4.703203E+03
P = 0.000000E+00 0.000000E+00 -4.703203E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 1.160930E+03
P = 0.000000E+00 0.000000E+00 1.160930E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 1.796797E+03
P = 0.000000E+00 0.000000E+00 -1.796797E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 4.703725E+03
P = -5.300535E+01 9.916386E+01 -4.701497E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 5.338548E+03
P = 5.300535E+01 -9.916386E+01 5.337364E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 5.387315E+03
P = 0.000000E+00 0.000000E+00 5.387315E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 5.309140E+03
P = 0.000000E+00 0.000000E+00 -5.309140E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 1.112685E+03
P = 0.000000E+00 0.000000E+00 1.112685E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.190860E+03
P = 0.000000E+00 0.000000E+00 -1.190860E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 4.702741E+03
P = 2.577897E+01 -4.620725E+01 -4.701559E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 5.345000E+03
P = 1.318350E+02 -2.446186E+02 5.337772E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 6.487132E+02
P = -1.576139E+02 2.908258E+02 -5.580385E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 5.387315E+03
P = 0.000000E+00 0.000000E+00 5.387315E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 5.309140E+03
P = 0.000000E+00 0.000000E+00 -5.309140E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 1.112685E+03
P = 0.000000E+00 0.000000E+00 1.112685E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.190860E+03
P = 0.000000E+00 0.000000E+00 -1.190860E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 4.702741E+03
P = 2.577897E+01 -4.620725E+01 -4.701559E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 5.345000E+03
P = 1.318350E+02 -2.446186E+02 5.337772E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 6.487132E+02
P = -1.576139E+02 2.908258E+02 -5.580385E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 5.339070E+03
P = 0.000000E+00 0.000000E+00 5.339070E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 4.703203E+03
P = 0.000000E+00 0.000000E+00 -4.703203E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 1.160930E+03
P = 0.000000E+00 0.000000E+00 1.160930E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 1.796797E+03
P = 0.000000E+00 0.000000E+00 -1.796797E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.970087E+03
P = -3.346039E+01 6.259862E+01 -2.967838E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 5.069644E+03
P = 3.829443E+01 -1.681391E+03 4.782546E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 2.002543E+03
P = -4.834037E+00 1.618792E+03 -1.178841E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 5.387315E+03
P = 0.000000E+00 0.000000E+00 5.387315E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 5.309140E+03
P = 0.000000E+00 0.000000E+00 -5.309140E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 1.112685E+03
P = 0.000000E+00 0.000000E+00 1.112685E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.190860E+03
P = 0.000000E+00 0.000000E+00 -1.190860E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 4.702741E+03
P = 2.577897E+01 -4.620725E+01 -4.701559E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 5.345000E+03
P = 1.318350E+02 -2.446186E+02 5.337772E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 6.487132E+02
P = -1.576139E+02 2.908258E+02 -5.580385E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 1.00221E+04
n_in* => 2
n_out* => 5
n_tot* => 7
$process_id* => "nlo_ppzj_sim_1_p1"
process_num_id* => [unknown integer]
sqme* => 1.02069E-05
sqme_ref* => 1.02069E-05
event_index* => 7
event_weight* => 7.15005E-07
event_weight_ref* => 7.15005E-07
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:-2|-5.3390699E+03; 0.0000000E+00, 0.0000000E+00,-5.3390699E+03| 0.0000000E+00| 3)
4 prt(i:2|-4.7032029E+03; 0.0000000E+00, 0.0000000E+00, 4.7032029E+03| 0.0000000E+00| 4)
5 prt(o:92| 1.1609301E+03; 0.0000000E+00, 0.0000000E+00, 1.1609301E+03| 0.0000000E+00| 5)
6 prt(o:-92| 1.7967971E+03; 0.0000000E+00, 0.0000000E+00,-1.7967971E+03| 0.0000000E+00| 6)
7 prt(o:23| 2.9700865E+03;-3.3460394E+01, 6.2598624E+01,-2.9678377E+03| 8.3152513E+03| 7)
8 prt(o:-2| 5.0696435E+03; 3.8294432E+01,-1.6813907E+03, 4.7825458E+03| 0.0000000E+00| 8)
9 prt(o:2| 2.0025428E+03;-4.8340373E+00, 1.6187920E+03,-1.1788412E+03| 0.0000000E+00| 9)
========================================================================
========================================================================
Event #7
------------------------------------------------------------------------
Unweighted = F
Normalization = 'sigma'
Helicity handling = drop
Keep correlations = F
------------------------------------------------------------------------
Squared matrix el. (ref) = 1.02069E-05
Squared matrix el. (prc) = 7.16648E-06
Event weight (ref) = 7.15005E-07
Event weight (prc) = 0.00000E+00
------------------------------------------------------------------------
Selected MCI group = 2
Selected term = 6
Selected channel = 4
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
1343569551.0, 923711388.0, 2741230169.0,
607667879.0, 415492869.0, 2531095270.0,
]
Beginning substream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Initial stream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 5.339070E+03
P = 0.000000E+00 0.000000E+00 5.339070E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 4.703203E+03
P = 0.000000E+00 0.000000E+00 -4.703203E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 1.160930E+03
P = 0.000000E+00 0.000000E+00 1.160930E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 1.796797E+03
P = 0.000000E+00 0.000000E+00 -1.796797E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 4.703725E+03
P = -5.300535E+01 9.916386E+01 -4.701497E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 5.338548E+03
P = 5.300535E+01 -9.916386E+01 5.337364E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
3151030428.0, 3465847835.0, 1593585735.0,
1647623300.0, 1779762511.0, 62582738.0,
]
Beginning substream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Initial stream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 5.387315E+03
P = 0.000000E+00 0.000000E+00 5.387315E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 5.309140E+03
P = 0.000000E+00 0.000000E+00 -5.309140E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 1.112685E+03
P = 0.000000E+00 0.000000E+00 1.112685E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.190860E+03
P = 0.000000E+00 0.000000E+00 -1.190860E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 4.702741E+03
P = 2.577897E+01 -4.620725E+01 -4.701559E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 5.345000E+03
P = 1.318350E+02 -2.446186E+02 5.337772E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 6.487132E+02
P = -1.576139E+02 2.908258E+02 -5.580385E+02
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 7.166480593E-06
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 5.339070E+03
P = 0.000000E+00 0.000000E+00 5.339070E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 4.703203E+03
P = 0.000000E+00 0.000000E+00 -4.703203E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 1.160930E+03
P = 0.000000E+00 0.000000E+00 1.160930E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 1.796797E+03
P = 0.000000E+00 0.000000E+00 -1.796797E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 4.703725E+03
P = -5.300535E+01 9.916386E+01 -4.701497E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 5.338548E+03
P = 5.300535E+01 -9.916386E+01 5.337364E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 5.387315E+03
P = 0.000000E+00 0.000000E+00 5.387315E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 5.309140E+03
P = 0.000000E+00 0.000000E+00 -5.309140E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 1.112685E+03
P = 0.000000E+00 0.000000E+00 1.112685E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.190860E+03
P = 0.000000E+00 0.000000E+00 -1.190860E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 4.702741E+03
P = 2.577897E+01 -4.620725E+01 -4.701559E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 5.345000E+03
P = 1.318350E+02 -2.446186E+02 5.337772E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 6.487132E+02
P = -1.576139E+02 2.908258E+02 -5.580385E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 5.387315E+03
P = 0.000000E+00 0.000000E+00 5.387315E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 5.309140E+03
P = 0.000000E+00 0.000000E+00 -5.309140E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 1.112685E+03
P = 0.000000E+00 0.000000E+00 1.112685E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.190860E+03
P = 0.000000E+00 0.000000E+00 -1.190860E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 4.702741E+03
P = 2.577897E+01 -4.620725E+01 -4.701559E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 5.345000E+03
P = 1.318350E+02 -2.446186E+02 5.337772E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 6.487132E+02
P = -1.576139E+02 2.908258E+02 -5.580385E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 5.339070E+03
P = 0.000000E+00 0.000000E+00 5.339070E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 4.703203E+03
P = 0.000000E+00 0.000000E+00 -4.703203E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 1.160930E+03
P = 0.000000E+00 0.000000E+00 1.160930E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 1.796797E+03
P = 0.000000E+00 0.000000E+00 -1.796797E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.970087E+03
P = -3.346039E+01 6.259862E+01 -2.967838E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 5.069644E+03
P = 3.829443E+01 -1.681391E+03 4.782546E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 2.002543E+03
P = -4.834037E+00 1.618792E+03 -1.178841E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 5.387315E+03
P = 0.000000E+00 0.000000E+00 5.387315E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 5.309140E+03
P = 0.000000E+00 0.000000E+00 -5.309140E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 1.112685E+03
P = 0.000000E+00 0.000000E+00 1.112685E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.190860E+03
P = 0.000000E+00 0.000000E+00 -1.190860E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 4.702741E+03
P = 2.577897E+01 -4.620725E+01 -4.701559E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 5.345000E+03
P = 1.318350E+02 -2.446186E+02 5.337772E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 6.487132E+02
P = -1.576139E+02 2.908258E+02 -5.580385E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 1.06962E+04
n_in* => 2
n_out* => 5
n_tot* => 7
$process_id* => "nlo_ppzj_sim_1_p1"
process_num_id* => [unknown integer]
sqme* => 7.16648E-06
sqme_ref* => 1.02069E-05
event_index* => 7
event_weight* => 0.00000E+00
event_weight_ref* => 7.15005E-07
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:-3|-5.3873146E+03; 0.0000000E+00, 0.0000000E+00,-5.3873146E+03| 0.0000000E+00| 3)
4 prt(i:-3|-5.3091399E+03; 0.0000000E+00, 0.0000000E+00, 5.3091399E+03| 0.0000000E+00| 4)
5 prt(o:92| 1.1126854E+03; 0.0000000E+00, 0.0000000E+00, 1.1126854E+03| 0.0000000E+00| 5)
6 prt(o:92| 1.1908601E+03; 0.0000000E+00, 0.0000000E+00,-1.1908601E+03| 0.0000000E+00| 6)
7 prt(o:23| 4.7027408E+03; 2.5778968E+01,-4.6207255E+01,-4.7015589E+03| 8.3152513E+03| 7)
8 prt(o:-3| 5.3450005E+03; 1.3183497E+02,-2.4461856E+02, 5.3377721E+03| 0.0000000E+00| 8)
9 prt(o:-3| 6.4871321E+02;-1.5761394E+02, 2.9082582E+02,-5.5803855E+02| 0.0000000E+00| 9)
========================================================================
========================================================================
Event #8
------------------------------------------------------------------------
Unweighted = F
Normalization = 'sigma'
Helicity handling = drop
Keep correlations = F
------------------------------------------------------------------------
Squared matrix el. (ref) = 9.65827E-05
Squared matrix el. (prc) = 1.02033E-01
Event weight (ref) = 9.79541E-06
Event weight (prc) = 0.00000E+00
------------------------------------------------------------------------
Selected MCI group = 2
Selected term = 6
Selected channel = 4
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
757906877.0, 2538315746.0, 215142392.0,
3633058791.0, 1205176167.0, 4082604719.0,
]
Beginning substream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Initial stream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 5.372168E+03
P = 0.000000E+00 0.000000E+00 5.372168E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 6.013955E+03
P = 0.000000E+00 0.000000E+00 -6.013955E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 1.127832E+03
P = 0.000000E+00 0.000000E+00 1.127832E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 4.860454E+02
P = 0.000000E+00 0.000000E+00 -4.860454E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 5.372809E+03
P = 2.193985E+02 5.458670E+01 5.367275E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 6.013314E+03
P = -2.193985E+02 -5.458670E+01 -6.009062E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
2645888468.0, 2326394298.0, 848535072.0,
3843794136.0, 2897472533.0, 946987225.0,
]
Beginning substream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Initial stream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.625481E+03
P = 0.000000E+00 0.000000E+00 5.625481E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 6.122230E+03
P = 0.000000E+00 0.000000E+00 -6.122230E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 8.745189E+02
P = 0.000000E+00 0.000000E+00 8.745189E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 3.777701E+02
P = 0.000000E+00 0.000000E+00 -3.777701E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 5.370124E+03
P = 1.219551E+02 -7.599822E+01 5.367427E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 6.020679E+03
P = -3.169153E+02 -1.852701E+02 -6.009477E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 3.569078E+02
P = 1.949602E+02 2.612683E+02 1.453016E+02
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 6.659301946E-09
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 5.372168E+03
P = 0.000000E+00 0.000000E+00 5.372168E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 6.013955E+03
P = 0.000000E+00 0.000000E+00 -6.013955E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 1.127832E+03
P = 0.000000E+00 0.000000E+00 1.127832E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 4.860454E+02
P = 0.000000E+00 0.000000E+00 -4.860454E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 5.372809E+03
P = 2.193985E+02 5.458670E+01 5.367275E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 6.013314E+03
P = -2.193985E+02 -5.458670E+01 -6.009062E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.625481E+03
P = 0.000000E+00 0.000000E+00 5.625481E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 6.122230E+03
P = 0.000000E+00 0.000000E+00 -6.122230E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 8.745189E+02
P = 0.000000E+00 0.000000E+00 8.745189E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 3.777701E+02
P = 0.000000E+00 0.000000E+00 -3.777701E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 5.370124E+03
P = 1.219551E+02 -7.599822E+01 5.367427E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 6.020679E+03
P = -3.169153E+02 -1.852701E+02 -6.009477E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 3.569078E+02
P = 1.949602E+02 2.612683E+02 1.453016E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.625481E+03
P = 0.000000E+00 0.000000E+00 5.625481E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 6.122230E+03
P = 0.000000E+00 0.000000E+00 -6.122230E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 8.745189E+02
P = 0.000000E+00 0.000000E+00 8.745189E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 3.777701E+02
P = 0.000000E+00 0.000000E+00 -3.777701E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 5.370124E+03
P = 1.219551E+02 -7.599822E+01 5.367427E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 6.020679E+03
P = -3.169153E+02 -1.852701E+02 -6.009477E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 3.569078E+02
P = 1.949602E+02 2.612683E+02 1.453016E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.372168E+03
P = 0.000000E+00 0.000000E+00 5.372168E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 6.013955E+03
P = 0.000000E+00 0.000000E+00 -6.013955E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 1.127832E+03
P = 0.000000E+00 0.000000E+00 1.127832E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 4.860454E+02
P = 0.000000E+00 0.000000E+00 -4.860454E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 5.056430E+03
P = 2.064755E+02 5.137145E+01 5.051128E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 4.760356E+03
P = 8.853906E+02 -4.843322E+02 -4.652149E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 1.569337E+03
P = -1.091866E+03 4.329608E+02 -1.040765E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.625481E+03
P = 0.000000E+00 0.000000E+00 5.625481E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 6.122230E+03
P = 0.000000E+00 0.000000E+00 -6.122230E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 8.745189E+02
P = 0.000000E+00 0.000000E+00 8.745189E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 3.777701E+02
P = 0.000000E+00 0.000000E+00 -3.777701E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 5.370124E+03
P = 1.219551E+02 -7.599822E+01 5.367427E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 6.020679E+03
P = -3.169153E+02 -1.852701E+02 -6.009477E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 3.569078E+02
P = 1.949602E+02 2.612683E+02 1.453016E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 1.13680E+04
n_in* => 2
n_out* => 4
n_tot* => 6
$process_id* => "nlo_ppzj_sim_1_p1"
process_num_id* => [unknown integer]
sqme* => 1.02033E-01
sqme_ref* => 9.65827E-05
event_index* => 8
event_weight* => 0.00000E+00
event_weight_ref* => 9.79541E-06
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:-2|-5.3721680E+03; 0.0000000E+00, 0.0000000E+00,-5.3721680E+03| 0.0000000E+00| 3)
4 prt(i:2|-6.0139546E+03; 0.0000000E+00, 0.0000000E+00, 6.0139546E+03| 0.0000000E+00| 4)
5 prt(o:92| 1.1278320E+03; 0.0000000E+00, 0.0000000E+00, 1.1278320E+03| 0.0000000E+00| 5)
6 prt(o:-92| 4.8604537E+02; 0.0000000E+00, 0.0000000E+00,-4.8604537E+02| 0.0000000E+00| 6)
7 prt(o:23| 5.3728089E+03; 2.1939848E+02, 5.4586704E+01, 5.3672754E+03| 8.3152513E+03| 7)
8 prt(o:21| 6.0133137E+03;-2.1939848E+02,-5.4586704E+01,-6.0090620E+03| 0.0000000E+00| 8)
========================================================================
========================================================================
Event #8
------------------------------------------------------------------------
Unweighted = F
Normalization = 'sigma'
Helicity handling = drop
Keep correlations = F
------------------------------------------------------------------------
Squared matrix el. (ref) = 9.65827E-05
Squared matrix el. (prc) = 2.57982E-05
Event weight (ref) = 9.79541E-06
Event weight (prc) = 2.61646E-06
------------------------------------------------------------------------
Selected MCI group = 2
Selected term = 6
Selected channel = 4
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
757906877.0, 2538315746.0, 215142392.0,
3633058791.0, 1205176167.0, 4082604719.0,
]
Beginning substream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Initial stream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 5.372168E+03
P = 0.000000E+00 0.000000E+00 5.372168E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 6.013955E+03
P = 0.000000E+00 0.000000E+00 -6.013955E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 1.127832E+03
P = 0.000000E+00 0.000000E+00 1.127832E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 4.860454E+02
P = 0.000000E+00 0.000000E+00 -4.860454E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 5.372809E+03
P = 2.193985E+02 5.458670E+01 5.367275E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 6.013314E+03
P = -2.193985E+02 -5.458670E+01 -6.009062E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
2645888468.0, 2326394298.0, 848535072.0,
3843794136.0, 2897472533.0, 946987225.0,
]
Beginning substream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Initial stream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.625481E+03
P = 0.000000E+00 0.000000E+00 5.625481E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 6.122230E+03
P = 0.000000E+00 0.000000E+00 -6.122230E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 8.745189E+02
P = 0.000000E+00 0.000000E+00 8.745189E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 3.777701E+02
P = 0.000000E+00 0.000000E+00 -3.777701E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 5.370124E+03
P = 1.219551E+02 -7.599822E+01 5.367427E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 6.020679E+03
P = -3.169153E+02 -1.852701E+02 -6.009477E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 3.569078E+02
P = 1.949602E+02 2.612683E+02 1.453016E+02
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 6.659301946E-09
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 5.372168E+03
P = 0.000000E+00 0.000000E+00 5.372168E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 6.013955E+03
P = 0.000000E+00 0.000000E+00 -6.013955E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 1.127832E+03
P = 0.000000E+00 0.000000E+00 1.127832E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 4.860454E+02
P = 0.000000E+00 0.000000E+00 -4.860454E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 5.372809E+03
P = 2.193985E+02 5.458670E+01 5.367275E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 6.013314E+03
P = -2.193985E+02 -5.458670E+01 -6.009062E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.625481E+03
P = 0.000000E+00 0.000000E+00 5.625481E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 6.122230E+03
P = 0.000000E+00 0.000000E+00 -6.122230E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 8.745189E+02
P = 0.000000E+00 0.000000E+00 8.745189E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 3.777701E+02
P = 0.000000E+00 0.000000E+00 -3.777701E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 5.370124E+03
P = 1.219551E+02 -7.599822E+01 5.367427E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 6.020679E+03
P = -3.169153E+02 -1.852701E+02 -6.009477E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 3.569078E+02
P = 1.949602E+02 2.612683E+02 1.453016E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.625481E+03
P = 0.000000E+00 0.000000E+00 5.625481E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 6.122230E+03
P = 0.000000E+00 0.000000E+00 -6.122230E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 8.745189E+02
P = 0.000000E+00 0.000000E+00 8.745189E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 3.777701E+02
P = 0.000000E+00 0.000000E+00 -3.777701E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 5.370124E+03
P = 1.219551E+02 -7.599822E+01 5.367427E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 6.020679E+03
P = -3.169153E+02 -1.852701E+02 -6.009477E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 3.569078E+02
P = 1.949602E+02 2.612683E+02 1.453016E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.372168E+03
P = 0.000000E+00 0.000000E+00 5.372168E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 6.013955E+03
P = 0.000000E+00 0.000000E+00 -6.013955E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 1.127832E+03
P = 0.000000E+00 0.000000E+00 1.127832E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 4.860454E+02
P = 0.000000E+00 0.000000E+00 -4.860454E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 5.056430E+03
P = 2.064755E+02 5.137145E+01 5.051128E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 4.760356E+03
P = 8.853906E+02 -4.843322E+02 -4.652149E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 1.569337E+03
P = -1.091866E+03 4.329608E+02 -1.040765E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.625481E+03
P = 0.000000E+00 0.000000E+00 5.625481E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 6.122230E+03
P = 0.000000E+00 0.000000E+00 -6.122230E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 8.745189E+02
P = 0.000000E+00 0.000000E+00 8.745189E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 3.777701E+02
P = 0.000000E+00 0.000000E+00 -3.777701E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 5.370124E+03
P = 1.219551E+02 -7.599822E+01 5.367427E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 6.020679E+03
P = -3.169153E+02 -1.852701E+02 -6.009477E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 3.569078E+02
P = 1.949602E+02 2.612683E+02 1.453016E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 1.17372E+04
n_in* => 2
n_out* => 5
n_tot* => 7
$process_id* => "nlo_ppzj_sim_1_p1"
process_num_id* => [unknown integer]
sqme* => 2.57982E-05
sqme_ref* => 9.65827E-05
event_index* => 8
event_weight* => 2.61646E-06
event_weight_ref* => 9.79541E-06
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:2|-5.6254811E+03; 0.0000000E+00, 0.0000000E+00,-5.6254811E+03| 0.0000000E+00| 3)
4 prt(i:2|-6.1222299E+03; 0.0000000E+00, 0.0000000E+00, 6.1222299E+03| 0.0000000E+00| 4)
5 prt(o:-92| 8.7451892E+02; 0.0000000E+00, 0.0000000E+00, 8.7451892E+02| 0.0000000E+00| 5)
6 prt(o:-92| 3.7777007E+02; 0.0000000E+00, 0.0000000E+00,-3.7777007E+02| 0.0000000E+00| 6)
7 prt(o:23| 5.3701241E+03; 1.2195510E+02,-7.5998218E+01, 5.3674267E+03| 8.3152513E+03| 7)
8 prt(o:2| 6.0206790E+03;-3.1691535E+02,-1.8527010E+02,-6.0094772E+03| 0.0000000E+00| 8)
9 prt(o:2| 3.5690782E+02; 1.9496024E+02, 2.6126832E+02, 1.4530162E+02| 0.0000000E+00| 9)
========================================================================
========================================================================
Event #8
------------------------------------------------------------------------
Unweighted = F
Normalization = 'sigma'
Helicity handling = drop
Keep correlations = F
------------------------------------------------------------------------
Squared matrix el. (ref) = 9.65827E-05
Squared matrix el. (prc) = 7.07519E-05
Event weight (ref) = 9.79541E-06
Event weight (prc) = 7.17566E-06
------------------------------------------------------------------------
Selected MCI group = 2
Selected term = 6
Selected channel = 4
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
757906877.0, 2538315746.0, 215142392.0,
3633058791.0, 1205176167.0, 4082604719.0,
]
Beginning substream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Initial stream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 5.372168E+03
P = 0.000000E+00 0.000000E+00 5.372168E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 6.013955E+03
P = 0.000000E+00 0.000000E+00 -6.013955E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 1.127832E+03
P = 0.000000E+00 0.000000E+00 1.127832E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 4.860454E+02
P = 0.000000E+00 0.000000E+00 -4.860454E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 5.372809E+03
P = 2.193985E+02 5.458670E+01 5.367275E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 6.013314E+03
P = -2.193985E+02 -5.458670E+01 -6.009062E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
2645888468.0, 2326394298.0, 848535072.0,
3843794136.0, 2897472533.0, 946987225.0,
]
Beginning substream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Initial stream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.625481E+03
P = 0.000000E+00 0.000000E+00 5.625481E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 6.122230E+03
P = 0.000000E+00 0.000000E+00 -6.122230E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 8.745189E+02
P = 0.000000E+00 0.000000E+00 8.745189E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 3.777701E+02
P = 0.000000E+00 0.000000E+00 -3.777701E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 5.370124E+03
P = 1.219551E+02 -7.599822E+01 5.367427E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 6.020679E+03
P = -3.169153E+02 -1.852701E+02 -6.009477E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 3.569078E+02
P = 1.949602E+02 2.612683E+02 1.453016E+02
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 6.659301946E-09
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 5.372168E+03
P = 0.000000E+00 0.000000E+00 5.372168E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 6.013955E+03
P = 0.000000E+00 0.000000E+00 -6.013955E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 1.127832E+03
P = 0.000000E+00 0.000000E+00 1.127832E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 4.860454E+02
P = 0.000000E+00 0.000000E+00 -4.860454E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 5.372809E+03
P = 2.193985E+02 5.458670E+01 5.367275E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 6.013314E+03
P = -2.193985E+02 -5.458670E+01 -6.009062E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.625481E+03
P = 0.000000E+00 0.000000E+00 5.625481E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 6.122230E+03
P = 0.000000E+00 0.000000E+00 -6.122230E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 8.745189E+02
P = 0.000000E+00 0.000000E+00 8.745189E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 3.777701E+02
P = 0.000000E+00 0.000000E+00 -3.777701E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 5.370124E+03
P = 1.219551E+02 -7.599822E+01 5.367427E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 6.020679E+03
P = -3.169153E+02 -1.852701E+02 -6.009477E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 3.569078E+02
P = 1.949602E+02 2.612683E+02 1.453016E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.625481E+03
P = 0.000000E+00 0.000000E+00 5.625481E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 6.122230E+03
P = 0.000000E+00 0.000000E+00 -6.122230E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 8.745189E+02
P = 0.000000E+00 0.000000E+00 8.745189E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 3.777701E+02
P = 0.000000E+00 0.000000E+00 -3.777701E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 5.370124E+03
P = 1.219551E+02 -7.599822E+01 5.367427E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 6.020679E+03
P = -3.169153E+02 -1.852701E+02 -6.009477E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 3.569078E+02
P = 1.949602E+02 2.612683E+02 1.453016E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.372168E+03
P = 0.000000E+00 0.000000E+00 5.372168E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 6.013955E+03
P = 0.000000E+00 0.000000E+00 -6.013955E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 1.127832E+03
P = 0.000000E+00 0.000000E+00 1.127832E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 4.860454E+02
P = 0.000000E+00 0.000000E+00 -4.860454E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 5.056430E+03
P = 2.064755E+02 5.137145E+01 5.051128E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 4.760356E+03
P = 8.853906E+02 -4.843322E+02 -4.652149E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 1.569337E+03
P = -1.091866E+03 4.329608E+02 -1.040765E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.625481E+03
P = 0.000000E+00 0.000000E+00 5.625481E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 6.122230E+03
P = 0.000000E+00 0.000000E+00 -6.122230E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 8.745189E+02
P = 0.000000E+00 0.000000E+00 8.745189E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 3.777701E+02
P = 0.000000E+00 0.000000E+00 -3.777701E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 5.370124E+03
P = 1.219551E+02 -7.599822E+01 5.367427E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 6.020679E+03
P = -3.169153E+02 -1.852701E+02 -6.009477E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 3.569078E+02
P = 1.949602E+02 2.612683E+02 1.453016E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 1.17372E+04
n_in* => 2
n_out* => 5
n_tot* => 7
$process_id* => "nlo_ppzj_sim_1_p1"
process_num_id* => [unknown integer]
sqme* => 7.07519E-05
sqme_ref* => 9.65827E-05
event_index* => 8
event_weight* => 7.17566E-06
event_weight_ref* => 9.79541E-06
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:2|-5.6254811E+03; 0.0000000E+00, 0.0000000E+00,-5.6254811E+03| 0.0000000E+00| 3)
4 prt(i:2|-6.1222299E+03; 0.0000000E+00, 0.0000000E+00, 6.1222299E+03| 0.0000000E+00| 4)
5 prt(o:-92| 8.7451892E+02; 0.0000000E+00, 0.0000000E+00, 8.7451892E+02| 0.0000000E+00| 5)
6 prt(o:-92| 3.7777007E+02; 0.0000000E+00, 0.0000000E+00,-3.7777007E+02| 0.0000000E+00| 6)
7 prt(o:23| 5.3701241E+03; 1.2195510E+02,-7.5998218E+01, 5.3674267E+03| 8.3152513E+03| 7)
8 prt(o:2| 6.0206790E+03;-3.1691535E+02,-1.8527010E+02,-6.0094772E+03| 0.0000000E+00| 8)
9 prt(o:2| 3.5690782E+02; 1.9496024E+02, 2.6126832E+02, 1.4530162E+02| 0.0000000E+00| 9)
========================================================================
========================================================================
Event #8
------------------------------------------------------------------------
Unweighted = F
Normalization = 'sigma'
Helicity handling = drop
Keep correlations = F
------------------------------------------------------------------------
Squared matrix el. (ref) = 9.65827E-05
Squared matrix el. (prc) = 2.58868E-08
Event weight (ref) = 9.79541E-06
Event weight (prc) = 2.62544E-09
------------------------------------------------------------------------
Selected MCI group = 2
Selected term = 6
Selected channel = 4
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
757906877.0, 2538315746.0, 215142392.0,
3633058791.0, 1205176167.0, 4082604719.0,
]
Beginning substream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Initial stream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 5.372168E+03
P = 0.000000E+00 0.000000E+00 5.372168E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 6.013955E+03
P = 0.000000E+00 0.000000E+00 -6.013955E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 1.127832E+03
P = 0.000000E+00 0.000000E+00 1.127832E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 4.860454E+02
P = 0.000000E+00 0.000000E+00 -4.860454E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 5.372809E+03
P = 2.193985E+02 5.458670E+01 5.367275E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 6.013314E+03
P = -2.193985E+02 -5.458670E+01 -6.009062E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
2645888468.0, 2326394298.0, 848535072.0,
3843794136.0, 2897472533.0, 946987225.0,
]
Beginning substream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Initial stream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.625481E+03
P = 0.000000E+00 0.000000E+00 5.625481E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 6.122230E+03
P = 0.000000E+00 0.000000E+00 -6.122230E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 8.745189E+02
P = 0.000000E+00 0.000000E+00 8.745189E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 3.777701E+02
P = 0.000000E+00 0.000000E+00 -3.777701E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 5.370124E+03
P = 1.219551E+02 -7.599822E+01 5.367427E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 6.020679E+03
P = -3.169153E+02 -1.852701E+02 -6.009477E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 3.569078E+02
P = 1.949602E+02 2.612683E+02 1.453016E+02
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 6.659301946E-09
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 5.372168E+03
P = 0.000000E+00 0.000000E+00 5.372168E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 6.013955E+03
P = 0.000000E+00 0.000000E+00 -6.013955E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 1.127832E+03
P = 0.000000E+00 0.000000E+00 1.127832E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 4.860454E+02
P = 0.000000E+00 0.000000E+00 -4.860454E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 5.372809E+03
P = 2.193985E+02 5.458670E+01 5.367275E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 6.013314E+03
P = -2.193985E+02 -5.458670E+01 -6.009062E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.625481E+03
P = 0.000000E+00 0.000000E+00 5.625481E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 6.122230E+03
P = 0.000000E+00 0.000000E+00 -6.122230E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 8.745189E+02
P = 0.000000E+00 0.000000E+00 8.745189E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 3.777701E+02
P = 0.000000E+00 0.000000E+00 -3.777701E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 5.370124E+03
P = 1.219551E+02 -7.599822E+01 5.367427E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 6.020679E+03
P = -3.169153E+02 -1.852701E+02 -6.009477E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 3.569078E+02
P = 1.949602E+02 2.612683E+02 1.453016E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.625481E+03
P = 0.000000E+00 0.000000E+00 5.625481E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 6.122230E+03
P = 0.000000E+00 0.000000E+00 -6.122230E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 8.745189E+02
P = 0.000000E+00 0.000000E+00 8.745189E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 3.777701E+02
P = 0.000000E+00 0.000000E+00 -3.777701E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 5.370124E+03
P = 1.219551E+02 -7.599822E+01 5.367427E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 6.020679E+03
P = -3.169153E+02 -1.852701E+02 -6.009477E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 3.569078E+02
P = 1.949602E+02 2.612683E+02 1.453016E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.372168E+03
P = 0.000000E+00 0.000000E+00 5.372168E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 6.013955E+03
P = 0.000000E+00 0.000000E+00 -6.013955E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 1.127832E+03
P = 0.000000E+00 0.000000E+00 1.127832E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 4.860454E+02
P = 0.000000E+00 0.000000E+00 -4.860454E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 5.056430E+03
P = 2.064755E+02 5.137145E+01 5.051128E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 4.760356E+03
P = 8.853906E+02 -4.843322E+02 -4.652149E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 1.569337E+03
P = -1.091866E+03 4.329608E+02 -1.040765E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.625481E+03
P = 0.000000E+00 0.000000E+00 5.625481E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 6.122230E+03
P = 0.000000E+00 0.000000E+00 -6.122230E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 8.745189E+02
P = 0.000000E+00 0.000000E+00 8.745189E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 3.777701E+02
P = 0.000000E+00 0.000000E+00 -3.777701E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 5.370124E+03
P = 1.219551E+02 -7.599822E+01 5.367427E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 6.020679E+03
P = -3.169153E+02 -1.852701E+02 -6.009477E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 3.569078E+02
P = 1.949602E+02 2.612683E+02 1.453016E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 1.13680E+04
n_in* => 2
n_out* => 5
n_tot* => 7
$process_id* => "nlo_ppzj_sim_1_p1"
process_num_id* => [unknown integer]
sqme* => 2.58868E-08
sqme_ref* => 9.65827E-05
event_index* => 8
event_weight* => 2.62544E-09
event_weight_ref* => 9.79541E-06
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:2|-5.3721680E+03; 0.0000000E+00, 0.0000000E+00,-5.3721680E+03| 0.0000000E+00| 3)
4 prt(i:-2|-6.0139546E+03; 0.0000000E+00, 0.0000000E+00, 6.0139546E+03| 0.0000000E+00| 4)
5 prt(o:-92| 1.1278320E+03; 0.0000000E+00, 0.0000000E+00, 1.1278320E+03| 0.0000000E+00| 5)
6 prt(o:92| 4.8604537E+02; 0.0000000E+00, 0.0000000E+00,-4.8604537E+02| 0.0000000E+00| 6)
7 prt(o:23| 5.0564296E+03; 2.0647551E+02, 5.1371447E+01, 5.0511280E+03| 8.3152513E+03| 7)
8 prt(o:-2| 4.7603559E+03; 8.8539057E+02,-4.8433223E+02,-4.6521494E+03| 0.0000000E+00| 8)
9 prt(o:2| 1.5693371E+03;-1.0918661E+03, 4.3296078E+02,-1.0407652E+03| 0.0000000E+00| 9)
========================================================================
========================================================================
Event #8
------------------------------------------------------------------------
Unweighted = F
Normalization = 'sigma'
Helicity handling = drop
Keep correlations = F
------------------------------------------------------------------------
Squared matrix el. (ref) = 9.65827E-05
Squared matrix el. (prc) = 6.65930E-09
Event weight (ref) = 9.79541E-06
Event weight (prc) = 6.75386E-10
------------------------------------------------------------------------
Selected MCI group = 2
Selected term = 6
Selected channel = 4
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
757906877.0, 2538315746.0, 215142392.0,
3633058791.0, 1205176167.0, 4082604719.0,
]
Beginning substream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Initial stream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 5.372168E+03
P = 0.000000E+00 0.000000E+00 5.372168E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 6.013955E+03
P = 0.000000E+00 0.000000E+00 -6.013955E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 1.127832E+03
P = 0.000000E+00 0.000000E+00 1.127832E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 4.860454E+02
P = 0.000000E+00 0.000000E+00 -4.860454E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 5.372809E+03
P = 2.193985E+02 5.458670E+01 5.367275E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 6.013314E+03
P = -2.193985E+02 -5.458670E+01 -6.009062E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
2645888468.0, 2326394298.0, 848535072.0,
3843794136.0, 2897472533.0, 946987225.0,
]
Beginning substream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Initial stream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.625481E+03
P = 0.000000E+00 0.000000E+00 5.625481E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 6.122230E+03
P = 0.000000E+00 0.000000E+00 -6.122230E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 8.745189E+02
P = 0.000000E+00 0.000000E+00 8.745189E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 3.777701E+02
P = 0.000000E+00 0.000000E+00 -3.777701E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 5.370124E+03
P = 1.219551E+02 -7.599822E+01 5.367427E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 6.020679E+03
P = -3.169153E+02 -1.852701E+02 -6.009477E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 3.569078E+02
P = 1.949602E+02 2.612683E+02 1.453016E+02
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 6.659301946E-09
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 5.372168E+03
P = 0.000000E+00 0.000000E+00 5.372168E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 6.013955E+03
P = 0.000000E+00 0.000000E+00 -6.013955E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 1.127832E+03
P = 0.000000E+00 0.000000E+00 1.127832E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 4.860454E+02
P = 0.000000E+00 0.000000E+00 -4.860454E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 5.372809E+03
P = 2.193985E+02 5.458670E+01 5.367275E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 6.013314E+03
P = -2.193985E+02 -5.458670E+01 -6.009062E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.625481E+03
P = 0.000000E+00 0.000000E+00 5.625481E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 6.122230E+03
P = 0.000000E+00 0.000000E+00 -6.122230E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 8.745189E+02
P = 0.000000E+00 0.000000E+00 8.745189E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 3.777701E+02
P = 0.000000E+00 0.000000E+00 -3.777701E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 5.370124E+03
P = 1.219551E+02 -7.599822E+01 5.367427E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 6.020679E+03
P = -3.169153E+02 -1.852701E+02 -6.009477E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 3.569078E+02
P = 1.949602E+02 2.612683E+02 1.453016E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.625481E+03
P = 0.000000E+00 0.000000E+00 5.625481E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 6.122230E+03
P = 0.000000E+00 0.000000E+00 -6.122230E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 8.745189E+02
P = 0.000000E+00 0.000000E+00 8.745189E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 3.777701E+02
P = 0.000000E+00 0.000000E+00 -3.777701E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 5.370124E+03
P = 1.219551E+02 -7.599822E+01 5.367427E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 6.020679E+03
P = -3.169153E+02 -1.852701E+02 -6.009477E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 3.569078E+02
P = 1.949602E+02 2.612683E+02 1.453016E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.372168E+03
P = 0.000000E+00 0.000000E+00 5.372168E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 6.013955E+03
P = 0.000000E+00 0.000000E+00 -6.013955E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 1.127832E+03
P = 0.000000E+00 0.000000E+00 1.127832E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 4.860454E+02
P = 0.000000E+00 0.000000E+00 -4.860454E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 5.056430E+03
P = 2.064755E+02 5.137145E+01 5.051128E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 4.760356E+03
P = 8.853906E+02 -4.843322E+02 -4.652149E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 1.569337E+03
P = -1.091866E+03 4.329608E+02 -1.040765E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.625481E+03
P = 0.000000E+00 0.000000E+00 5.625481E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 6.122230E+03
P = 0.000000E+00 0.000000E+00 -6.122230E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 8.745189E+02
P = 0.000000E+00 0.000000E+00 8.745189E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 3.777701E+02
P = 0.000000E+00 0.000000E+00 -3.777701E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 5.370124E+03
P = 1.219551E+02 -7.599822E+01 5.367427E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 6.020679E+03
P = -3.169153E+02 -1.852701E+02 -6.009477E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 3.569078E+02
P = 1.949602E+02 2.612683E+02 1.453016E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 1.17372E+04
n_in* => 2
n_out* => 5
n_tot* => 7
$process_id* => "nlo_ppzj_sim_1_p1"
process_num_id* => [unknown integer]
sqme* => 6.65930E-09
sqme_ref* => 9.65827E-05
event_index* => 8
event_weight* => 6.75386E-10
event_weight_ref* => 9.79541E-06
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:2|-5.6254811E+03; 0.0000000E+00, 0.0000000E+00,-5.6254811E+03| 0.0000000E+00| 3)
4 prt(i:-2|-6.1222299E+03; 0.0000000E+00, 0.0000000E+00, 6.1222299E+03| 0.0000000E+00| 4)
5 prt(o:-92| 8.7451892E+02; 0.0000000E+00, 0.0000000E+00, 8.7451892E+02| 0.0000000E+00| 5)
6 prt(o:92| 3.7777007E+02; 0.0000000E+00, 0.0000000E+00,-3.7777007E+02| 0.0000000E+00| 6)
7 prt(o:23| 5.3701241E+03; 1.2195510E+02,-7.5998218E+01, 5.3674267E+03| 8.3152513E+03| 7)
8 prt(o:21| 6.0206790E+03;-3.1691535E+02,-1.8527010E+02,-6.0094772E+03| 0.0000000E+00| 8)
9 prt(o:21| 3.5690782E+02; 1.9496024E+02, 2.6126832E+02, 1.4530162E+02| 0.0000000E+00| 9)
========================================================================
========================================================================
Event #9
------------------------------------------------------------------------
Unweighted = F
Normalization = 'sigma'
Helicity handling = drop
Keep correlations = F
------------------------------------------------------------------------
Squared matrix el. (ref) = 4.07480E-04
Squared matrix el. (prc) = -1.43767E-02
Event weight (ref) = 1.56420E+00
Event weight (prc) = -5.51880E+01
------------------------------------------------------------------------
Selected MCI group = 2
Selected term = 6
Selected channel = 5
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
1690023452.0, 1506697985.0, 1603944153.0,
1594696513.0, 1724411355.0, 2807695136.0,
]
Beginning substream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Initial stream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.150429E+03
P = 0.000000E+00 0.000000E+00 5.150429E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(21)
E = 6.534115E+02
P = 0.000000E+00 0.000000E+00 -6.534115E+02
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(-92*)
E = 1.349571E+03
P = 0.000000E+00 0.000000E+00 1.349571E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(93*)
E = 5.846589E+03
P = 0.000000E+00 0.000000E+00 -5.846589E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.859445E+03
P = -1.268794E+03 1.012658E+03 9.021681E+02
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 3.944396E+03
P = 1.268794E+03 -1.012658E+03 3.594850E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
3337958689.0, 3958698135.0, 3666109244.0,
3669187808.0, 1826997964.0, 1255857350.0,
]
Beginning substream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Initial stream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(1)
E = 5.161493E+03
P = 0.000000E+00 0.000000E+00 5.161493E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-1)
E = 8.026280E+02
P = 0.000000E+00 0.000000E+00 -8.026280E+02
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 1.338507E+03
P = 0.000000E+00 0.000000E+00 1.338507E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 5.697372E+03
P = 0.000000E+00 0.000000E+00 -5.697372E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.859003E+03
P = -1.244183E+03 1.042255E+03 9.018256E+02
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 3.946114E+03
P = 1.293383E+03 -9.830856E+02 3.596181E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 1.590037E+02
P = -4.920023E+01 -5.916959E+01 -1.391419E+02
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 1.191543374E-02
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 5.150429E+03
P = 0.000000E+00 0.000000E+00 5.150429E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 6.534115E+02
P = 0.000000E+00 0.000000E+00 -6.534115E+02
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 1.349571E+03
P = 0.000000E+00 0.000000E+00 1.349571E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 5.846589E+03
P = 0.000000E+00 0.000000E+00 -5.846589E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.859445E+03
P = -1.268794E+03 1.012658E+03 9.021681E+02
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 3.944396E+03
P = 1.268794E+03 -1.012658E+03 3.594850E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.161493E+03
P = 0.000000E+00 0.000000E+00 5.161493E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 8.026280E+02
P = 0.000000E+00 0.000000E+00 -8.026280E+02
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 1.338507E+03
P = 0.000000E+00 0.000000E+00 1.338507E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 5.697372E+03
P = 0.000000E+00 0.000000E+00 -5.697372E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.859003E+03
P = -1.244183E+03 1.042255E+03 9.018256E+02
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 3.946114E+03
P = 1.293383E+03 -9.830856E+02 3.596181E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 1.590037E+02
P = -4.920023E+01 -5.916959E+01 -1.391419E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.161493E+03
P = 0.000000E+00 0.000000E+00 5.161493E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(1)
E = 8.026280E+02
P = 0.000000E+00 0.000000E+00 -8.026280E+02
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 1.338507E+03
P = 0.000000E+00 0.000000E+00 1.338507E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 5.697372E+03
P = 0.000000E+00 0.000000E+00 -5.697372E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.859003E+03
P = -1.244183E+03 1.042255E+03 9.018256E+02
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(1)
E = 3.946114E+03
P = 1.293383E+03 -9.830856E+02 3.596181E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 1.590037E+02
P = -4.920023E+01 -5.916959E+01 -1.391419E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.150429E+03
P = 0.000000E+00 0.000000E+00 5.150429E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(21)
E = 6.534115E+02
P = 0.000000E+00 0.000000E+00 -6.534115E+02
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 1.349571E+03
P = 0.000000E+00 0.000000E+00 1.349571E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(93*)
E = 5.846589E+03
P = 0.000000E+00 0.000000E+00 -5.846589E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.479997E+03
P = -1.008746E+03 8.051068E+02 7.185470E+02
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 4.011979E+03
P = 1.198267E+03 -1.034996E+03 3.686315E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 3.118649E+02
P = -1.895206E+02 2.298889E+02 9.215611E+01
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(1)
E = 5.161493E+03
P = 0.000000E+00 0.000000E+00 5.161493E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-1)
E = 8.026280E+02
P = 0.000000E+00 0.000000E+00 -8.026280E+02
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 1.338507E+03
P = 0.000000E+00 0.000000E+00 1.338507E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 5.697372E+03
P = 0.000000E+00 0.000000E+00 -5.697372E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.859003E+03
P = -1.244183E+03 1.042255E+03 9.018256E+02
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 3.946114E+03
P = 1.293383E+03 -9.830856E+02 3.596181E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 1.590037E+02
P = -4.920023E+01 -5.916959E+01 -1.391419E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 3.66898E+03
n_in* => 2
n_out* => 4
n_tot* => 6
$process_id* => "nlo_ppzj_sim_1_p1"
process_num_id* => [unknown integer]
sqme* => -1.43767E-02
sqme_ref* => 4.07480E-04
event_index* => 9
event_weight* => -5.51880E+01
event_weight_ref* => 1.56420E+00
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:-2|-5.1504292E+03; 0.0000000E+00, 0.0000000E+00,-5.1504292E+03| 0.0000000E+00| 3)
4 prt(i:2|-6.5341147E+02; 0.0000000E+00, 0.0000000E+00, 6.5341147E+02| 0.0000000E+00| 4)
5 prt(o:92| 1.3495708E+03; 0.0000000E+00, 0.0000000E+00, 1.3495708E+03| 0.0000000E+00| 5)
6 prt(o:-92| 5.8465885E+03; 0.0000000E+00, 0.0000000E+00,-5.8465885E+03| 0.0000000E+00| 6)
7 prt(o:23| 1.8594450E+03;-1.2687938E+03, 1.0126576E+03, 9.0216807E+02| 8.3152513E+03| 7)
8 prt(o:21| 3.9443957E+03; 1.2687938E+03,-1.0126576E+03, 3.5948497E+03| 0.0000000E+00| 8)
========================================================================
========================================================================
Event #9
------------------------------------------------------------------------
Unweighted = F
Normalization = 'sigma'
Helicity handling = drop
Keep correlations = F
------------------------------------------------------------------------
Squared matrix el. (ref) = 4.07480E-04
Squared matrix el. (prc) = 2.41023E-03
Event weight (ref) = 1.56420E+00
Event weight (prc) = 9.25219E+00
------------------------------------------------------------------------
Selected MCI group = 2
Selected term = 6
Selected channel = 5
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
1690023452.0, 1506697985.0, 1603944153.0,
1594696513.0, 1724411355.0, 2807695136.0,
]
Beginning substream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Initial stream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.150429E+03
P = 0.000000E+00 0.000000E+00 5.150429E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(21)
E = 6.534115E+02
P = 0.000000E+00 0.000000E+00 -6.534115E+02
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(-92*)
E = 1.349571E+03
P = 0.000000E+00 0.000000E+00 1.349571E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(93*)
E = 5.846589E+03
P = 0.000000E+00 0.000000E+00 -5.846589E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.859445E+03
P = -1.268794E+03 1.012658E+03 9.021681E+02
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 3.944396E+03
P = 1.268794E+03 -1.012658E+03 3.594850E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
3337958689.0, 3958698135.0, 3666109244.0,
3669187808.0, 1826997964.0, 1255857350.0,
]
Beginning substream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Initial stream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(1)
E = 5.161493E+03
P = 0.000000E+00 0.000000E+00 5.161493E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-1)
E = 8.026280E+02
P = 0.000000E+00 0.000000E+00 -8.026280E+02
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 1.338507E+03
P = 0.000000E+00 0.000000E+00 1.338507E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 5.697372E+03
P = 0.000000E+00 0.000000E+00 -5.697372E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.859003E+03
P = -1.244183E+03 1.042255E+03 9.018256E+02
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 3.946114E+03
P = 1.293383E+03 -9.830856E+02 3.596181E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 1.590037E+02
P = -4.920023E+01 -5.916959E+01 -1.391419E+02
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 1.191543374E-02
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 5.150429E+03
P = 0.000000E+00 0.000000E+00 5.150429E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 6.534115E+02
P = 0.000000E+00 0.000000E+00 -6.534115E+02
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 1.349571E+03
P = 0.000000E+00 0.000000E+00 1.349571E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 5.846589E+03
P = 0.000000E+00 0.000000E+00 -5.846589E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.859445E+03
P = -1.268794E+03 1.012658E+03 9.021681E+02
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 3.944396E+03
P = 1.268794E+03 -1.012658E+03 3.594850E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.161493E+03
P = 0.000000E+00 0.000000E+00 5.161493E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 8.026280E+02
P = 0.000000E+00 0.000000E+00 -8.026280E+02
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 1.338507E+03
P = 0.000000E+00 0.000000E+00 1.338507E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 5.697372E+03
P = 0.000000E+00 0.000000E+00 -5.697372E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.859003E+03
P = -1.244183E+03 1.042255E+03 9.018256E+02
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 3.946114E+03
P = 1.293383E+03 -9.830856E+02 3.596181E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 1.590037E+02
P = -4.920023E+01 -5.916959E+01 -1.391419E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.161493E+03
P = 0.000000E+00 0.000000E+00 5.161493E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(1)
E = 8.026280E+02
P = 0.000000E+00 0.000000E+00 -8.026280E+02
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 1.338507E+03
P = 0.000000E+00 0.000000E+00 1.338507E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 5.697372E+03
P = 0.000000E+00 0.000000E+00 -5.697372E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.859003E+03
P = -1.244183E+03 1.042255E+03 9.018256E+02
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(1)
E = 3.946114E+03
P = 1.293383E+03 -9.830856E+02 3.596181E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 1.590037E+02
P = -4.920023E+01 -5.916959E+01 -1.391419E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.150429E+03
P = 0.000000E+00 0.000000E+00 5.150429E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(21)
E = 6.534115E+02
P = 0.000000E+00 0.000000E+00 -6.534115E+02
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 1.349571E+03
P = 0.000000E+00 0.000000E+00 1.349571E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(93*)
E = 5.846589E+03
P = 0.000000E+00 0.000000E+00 -5.846589E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.479997E+03
P = -1.008746E+03 8.051068E+02 7.185470E+02
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 4.011979E+03
P = 1.198267E+03 -1.034996E+03 3.686315E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 3.118649E+02
P = -1.895206E+02 2.298889E+02 9.215611E+01
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(1)
E = 5.161493E+03
P = 0.000000E+00 0.000000E+00 5.161493E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-1)
E = 8.026280E+02
P = 0.000000E+00 0.000000E+00 -8.026280E+02
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 1.338507E+03
P = 0.000000E+00 0.000000E+00 1.338507E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 5.697372E+03
P = 0.000000E+00 0.000000E+00 -5.697372E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.859003E+03
P = -1.244183E+03 1.042255E+03 9.018256E+02
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 3.946114E+03
P = 1.293383E+03 -9.830856E+02 3.596181E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 1.590037E+02
P = -4.920023E+01 -5.916959E+01 -1.391419E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 4.07075E+03
n_in* => 2
n_out* => 5
n_tot* => 7
$process_id* => "nlo_ppzj_sim_1_p1"
process_num_id* => [unknown integer]
sqme* => 2.41023E-03
sqme_ref* => 4.07480E-04
event_index* => 9
event_weight* => 9.25219E+00
event_weight_ref* => 1.56420E+00
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:2|-5.1614928E+03; 0.0000000E+00, 0.0000000E+00,-5.1614928E+03| 0.0000000E+00| 3)
4 prt(i:2|-8.0262799E+02; 0.0000000E+00, 0.0000000E+00, 8.0262799E+02| 0.0000000E+00| 4)
5 prt(o:-92| 1.3385072E+03; 0.0000000E+00, 0.0000000E+00, 1.3385072E+03| 0.0000000E+00| 5)
6 prt(o:-92| 5.6973720E+03; 0.0000000E+00, 0.0000000E+00,-5.6973720E+03| 0.0000000E+00| 6)
7 prt(o:23| 1.8590030E+03;-1.2441831E+03, 1.0422552E+03, 9.0182557E+02| 8.3152513E+03| 7)
8 prt(o:2| 3.9461142E+03; 1.2933833E+03,-9.8308560E+02, 3.5961812E+03| 0.0000000E+00| 8)
9 prt(o:2| 1.5900371E+02;-4.9200234E+01,-5.9169588E+01,-1.3914192E+02| 0.0000000E+00| 9)
========================================================================
========================================================================
Event #9
------------------------------------------------------------------------
Unweighted = F
Normalization = 'sigma'
Helicity handling = drop
Keep correlations = F
------------------------------------------------------------------------
Squared matrix el. (ref) = 4.07480E-04
Squared matrix el. (prc) = 6.18009E-05
Event weight (ref) = 1.56420E+00
Event weight (prc) = 2.37236E-01
------------------------------------------------------------------------
Selected MCI group = 2
Selected term = 6
Selected channel = 5
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
1690023452.0, 1506697985.0, 1603944153.0,
1594696513.0, 1724411355.0, 2807695136.0,
]
Beginning substream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Initial stream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.150429E+03
P = 0.000000E+00 0.000000E+00 5.150429E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(21)
E = 6.534115E+02
P = 0.000000E+00 0.000000E+00 -6.534115E+02
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(-92*)
E = 1.349571E+03
P = 0.000000E+00 0.000000E+00 1.349571E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(93*)
E = 5.846589E+03
P = 0.000000E+00 0.000000E+00 -5.846589E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.859445E+03
P = -1.268794E+03 1.012658E+03 9.021681E+02
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 3.944396E+03
P = 1.268794E+03 -1.012658E+03 3.594850E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
3337958689.0, 3958698135.0, 3666109244.0,
3669187808.0, 1826997964.0, 1255857350.0,
]
Beginning substream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Initial stream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(1)
E = 5.161493E+03
P = 0.000000E+00 0.000000E+00 5.161493E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-1)
E = 8.026280E+02
P = 0.000000E+00 0.000000E+00 -8.026280E+02
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 1.338507E+03
P = 0.000000E+00 0.000000E+00 1.338507E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 5.697372E+03
P = 0.000000E+00 0.000000E+00 -5.697372E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.859003E+03
P = -1.244183E+03 1.042255E+03 9.018256E+02
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 3.946114E+03
P = 1.293383E+03 -9.830856E+02 3.596181E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 1.590037E+02
P = -4.920023E+01 -5.916959E+01 -1.391419E+02
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 1.191543374E-02
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 5.150429E+03
P = 0.000000E+00 0.000000E+00 5.150429E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 6.534115E+02
P = 0.000000E+00 0.000000E+00 -6.534115E+02
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 1.349571E+03
P = 0.000000E+00 0.000000E+00 1.349571E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 5.846589E+03
P = 0.000000E+00 0.000000E+00 -5.846589E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.859445E+03
P = -1.268794E+03 1.012658E+03 9.021681E+02
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 3.944396E+03
P = 1.268794E+03 -1.012658E+03 3.594850E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.161493E+03
P = 0.000000E+00 0.000000E+00 5.161493E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 8.026280E+02
P = 0.000000E+00 0.000000E+00 -8.026280E+02
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 1.338507E+03
P = 0.000000E+00 0.000000E+00 1.338507E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 5.697372E+03
P = 0.000000E+00 0.000000E+00 -5.697372E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.859003E+03
P = -1.244183E+03 1.042255E+03 9.018256E+02
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 3.946114E+03
P = 1.293383E+03 -9.830856E+02 3.596181E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 1.590037E+02
P = -4.920023E+01 -5.916959E+01 -1.391419E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.161493E+03
P = 0.000000E+00 0.000000E+00 5.161493E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(1)
E = 8.026280E+02
P = 0.000000E+00 0.000000E+00 -8.026280E+02
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 1.338507E+03
P = 0.000000E+00 0.000000E+00 1.338507E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 5.697372E+03
P = 0.000000E+00 0.000000E+00 -5.697372E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.859003E+03
P = -1.244183E+03 1.042255E+03 9.018256E+02
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(1)
E = 3.946114E+03
P = 1.293383E+03 -9.830856E+02 3.596181E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 1.590037E+02
P = -4.920023E+01 -5.916959E+01 -1.391419E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.150429E+03
P = 0.000000E+00 0.000000E+00 5.150429E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(21)
E = 6.534115E+02
P = 0.000000E+00 0.000000E+00 -6.534115E+02
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 1.349571E+03
P = 0.000000E+00 0.000000E+00 1.349571E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(93*)
E = 5.846589E+03
P = 0.000000E+00 0.000000E+00 -5.846589E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.479997E+03
P = -1.008746E+03 8.051068E+02 7.185470E+02
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 4.011979E+03
P = 1.198267E+03 -1.034996E+03 3.686315E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 3.118649E+02
P = -1.895206E+02 2.298889E+02 9.215611E+01
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(1)
E = 5.161493E+03
P = 0.000000E+00 0.000000E+00 5.161493E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-1)
E = 8.026280E+02
P = 0.000000E+00 0.000000E+00 -8.026280E+02
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 1.338507E+03
P = 0.000000E+00 0.000000E+00 1.338507E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 5.697372E+03
P = 0.000000E+00 0.000000E+00 -5.697372E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.859003E+03
P = -1.244183E+03 1.042255E+03 9.018256E+02
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 3.946114E+03
P = 1.293383E+03 -9.830856E+02 3.596181E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 1.590037E+02
P = -4.920023E+01 -5.916959E+01 -1.391419E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 4.07075E+03
n_in* => 2
n_out* => 5
n_tot* => 7
$process_id* => "nlo_ppzj_sim_1_p1"
process_num_id* => [unknown integer]
sqme* => 6.18009E-05
sqme_ref* => 4.07480E-04
event_index* => 9
event_weight* => 2.37236E-01
event_weight_ref* => 1.56420E+00
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:2|-5.1614928E+03; 0.0000000E+00, 0.0000000E+00,-5.1614928E+03| 0.0000000E+00| 3)
4 prt(i:1|-8.0262799E+02; 0.0000000E+00, 0.0000000E+00, 8.0262799E+02| 0.0000000E+00| 4)
5 prt(o:-92| 1.3385072E+03; 0.0000000E+00, 0.0000000E+00, 1.3385072E+03| 0.0000000E+00| 5)
6 prt(o:-92| 5.6973720E+03; 0.0000000E+00, 0.0000000E+00,-5.6973720E+03| 0.0000000E+00| 6)
7 prt(o:23| 1.8590030E+03;-1.2441831E+03, 1.0422552E+03, 9.0182557E+02| 8.3152513E+03| 7)
8 prt(o:1| 3.9461142E+03; 1.2933833E+03,-9.8308560E+02, 3.5961812E+03| 0.0000000E+00| 8)
9 prt(o:2| 1.5900371E+02;-4.9200234E+01,-5.9169588E+01,-1.3914192E+02| 0.0000000E+00| 9)
========================================================================
========================================================================
Event #9
------------------------------------------------------------------------
Unweighted = F
Normalization = 'sigma'
Helicity handling = drop
Keep correlations = F
------------------------------------------------------------------------
Squared matrix el. (ref) = 4.07480E-04
Squared matrix el. (prc) = 3.96699E-04
Event weight (ref) = 1.56420E+00
Event weight (prc) = 1.52282E+00
------------------------------------------------------------------------
Selected MCI group = 2
Selected term = 6
Selected channel = 5
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
1690023452.0, 1506697985.0, 1603944153.0,
1594696513.0, 1724411355.0, 2807695136.0,
]
Beginning substream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Initial stream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.150429E+03
P = 0.000000E+00 0.000000E+00 5.150429E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(21)
E = 6.534115E+02
P = 0.000000E+00 0.000000E+00 -6.534115E+02
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(-92*)
E = 1.349571E+03
P = 0.000000E+00 0.000000E+00 1.349571E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(93*)
E = 5.846589E+03
P = 0.000000E+00 0.000000E+00 -5.846589E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.859445E+03
P = -1.268794E+03 1.012658E+03 9.021681E+02
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 3.944396E+03
P = 1.268794E+03 -1.012658E+03 3.594850E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
3337958689.0, 3958698135.0, 3666109244.0,
3669187808.0, 1826997964.0, 1255857350.0,
]
Beginning substream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Initial stream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(1)
E = 5.161493E+03
P = 0.000000E+00 0.000000E+00 5.161493E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-1)
E = 8.026280E+02
P = 0.000000E+00 0.000000E+00 -8.026280E+02
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 1.338507E+03
P = 0.000000E+00 0.000000E+00 1.338507E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 5.697372E+03
P = 0.000000E+00 0.000000E+00 -5.697372E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.859003E+03
P = -1.244183E+03 1.042255E+03 9.018256E+02
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 3.946114E+03
P = 1.293383E+03 -9.830856E+02 3.596181E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 1.590037E+02
P = -4.920023E+01 -5.916959E+01 -1.391419E+02
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 1.191543374E-02
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 5.150429E+03
P = 0.000000E+00 0.000000E+00 5.150429E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 6.534115E+02
P = 0.000000E+00 0.000000E+00 -6.534115E+02
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 1.349571E+03
P = 0.000000E+00 0.000000E+00 1.349571E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 5.846589E+03
P = 0.000000E+00 0.000000E+00 -5.846589E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.859445E+03
P = -1.268794E+03 1.012658E+03 9.021681E+02
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 3.944396E+03
P = 1.268794E+03 -1.012658E+03 3.594850E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.161493E+03
P = 0.000000E+00 0.000000E+00 5.161493E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 8.026280E+02
P = 0.000000E+00 0.000000E+00 -8.026280E+02
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 1.338507E+03
P = 0.000000E+00 0.000000E+00 1.338507E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 5.697372E+03
P = 0.000000E+00 0.000000E+00 -5.697372E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.859003E+03
P = -1.244183E+03 1.042255E+03 9.018256E+02
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 3.946114E+03
P = 1.293383E+03 -9.830856E+02 3.596181E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 1.590037E+02
P = -4.920023E+01 -5.916959E+01 -1.391419E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.161493E+03
P = 0.000000E+00 0.000000E+00 5.161493E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(1)
E = 8.026280E+02
P = 0.000000E+00 0.000000E+00 -8.026280E+02
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 1.338507E+03
P = 0.000000E+00 0.000000E+00 1.338507E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 5.697372E+03
P = 0.000000E+00 0.000000E+00 -5.697372E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.859003E+03
P = -1.244183E+03 1.042255E+03 9.018256E+02
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(1)
E = 3.946114E+03
P = 1.293383E+03 -9.830856E+02 3.596181E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 1.590037E+02
P = -4.920023E+01 -5.916959E+01 -1.391419E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.150429E+03
P = 0.000000E+00 0.000000E+00 5.150429E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(21)
E = 6.534115E+02
P = 0.000000E+00 0.000000E+00 -6.534115E+02
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 1.349571E+03
P = 0.000000E+00 0.000000E+00 1.349571E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(93*)
E = 5.846589E+03
P = 0.000000E+00 0.000000E+00 -5.846589E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.479997E+03
P = -1.008746E+03 8.051068E+02 7.185470E+02
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 4.011979E+03
P = 1.198267E+03 -1.034996E+03 3.686315E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 3.118649E+02
P = -1.895206E+02 2.298889E+02 9.215611E+01
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(1)
E = 5.161493E+03
P = 0.000000E+00 0.000000E+00 5.161493E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-1)
E = 8.026280E+02
P = 0.000000E+00 0.000000E+00 -8.026280E+02
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 1.338507E+03
P = 0.000000E+00 0.000000E+00 1.338507E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 5.697372E+03
P = 0.000000E+00 0.000000E+00 -5.697372E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.859003E+03
P = -1.244183E+03 1.042255E+03 9.018256E+02
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 3.946114E+03
P = 1.293383E+03 -9.830856E+02 3.596181E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 1.590037E+02
P = -4.920023E+01 -5.916959E+01 -1.391419E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 3.66898E+03
n_in* => 2
n_out* => 5
n_tot* => 7
$process_id* => "nlo_ppzj_sim_1_p1"
process_num_id* => [unknown integer]
sqme* => 3.96699E-04
sqme_ref* => 4.07480E-04
event_index* => 9
event_weight* => 1.52282E+00
event_weight_ref* => 1.56420E+00
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:2|-5.1504292E+03; 0.0000000E+00, 0.0000000E+00,-5.1504292E+03| 0.0000000E+00| 3)
4 prt(i:21|-6.5341147E+02; 0.0000000E+00, 0.0000000E+00, 6.5341147E+02| 0.0000000E+00| 4)
5 prt(o:-92| 1.3495708E+03; 0.0000000E+00, 0.0000000E+00, 1.3495708E+03| 0.0000000E+00| 5)
6 prt(o:93| 5.8465885E+03; 0.0000000E+00, 0.0000000E+00,-5.8465885E+03| 0.0000000E+00| 6)
7 prt(o:23| 1.4799968E+03;-1.0087461E+03, 8.0510676E+02, 7.1854696E+02| 8.3152513E+03| 7)
8 prt(o:2| 4.0119790E+03; 1.1982667E+03,-1.0349957E+03, 3.6863147E+03| 0.0000000E+00| 8)
9 prt(o:21| 3.1186490E+02;-1.8952059E+02, 2.2988892E+02, 9.2156107E+01| 0.0000000E+00| 9)
========================================================================
========================================================================
Event #9
------------------------------------------------------------------------
Unweighted = F
Normalization = 'sigma'
Helicity handling = drop
Keep correlations = F
------------------------------------------------------------------------
Squared matrix el. (ref) = 4.07480E-04
Squared matrix el. (prc) = 1.19154E-02
Event weight (ref) = 1.56420E+00
Event weight (prc) = 4.57400E+01
------------------------------------------------------------------------
Selected MCI group = 2
Selected term = 6
Selected channel = 5
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
1690023452.0, 1506697985.0, 1603944153.0,
1594696513.0, 1724411355.0, 2807695136.0,
]
Beginning substream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Initial stream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.150429E+03
P = 0.000000E+00 0.000000E+00 5.150429E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(21)
E = 6.534115E+02
P = 0.000000E+00 0.000000E+00 -6.534115E+02
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(-92*)
E = 1.349571E+03
P = 0.000000E+00 0.000000E+00 1.349571E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(93*)
E = 5.846589E+03
P = 0.000000E+00 0.000000E+00 -5.846589E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.859445E+03
P = -1.268794E+03 1.012658E+03 9.021681E+02
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 3.944396E+03
P = 1.268794E+03 -1.012658E+03 3.594850E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
3337958689.0, 3958698135.0, 3666109244.0,
3669187808.0, 1826997964.0, 1255857350.0,
]
Beginning substream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Initial stream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(1)
E = 5.161493E+03
P = 0.000000E+00 0.000000E+00 5.161493E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-1)
E = 8.026280E+02
P = 0.000000E+00 0.000000E+00 -8.026280E+02
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 1.338507E+03
P = 0.000000E+00 0.000000E+00 1.338507E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 5.697372E+03
P = 0.000000E+00 0.000000E+00 -5.697372E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.859003E+03
P = -1.244183E+03 1.042255E+03 9.018256E+02
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 3.946114E+03
P = 1.293383E+03 -9.830856E+02 3.596181E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 1.590037E+02
P = -4.920023E+01 -5.916959E+01 -1.391419E+02
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 1.191543374E-02
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 5.150429E+03
P = 0.000000E+00 0.000000E+00 5.150429E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 6.534115E+02
P = 0.000000E+00 0.000000E+00 -6.534115E+02
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 1.349571E+03
P = 0.000000E+00 0.000000E+00 1.349571E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 5.846589E+03
P = 0.000000E+00 0.000000E+00 -5.846589E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.859445E+03
P = -1.268794E+03 1.012658E+03 9.021681E+02
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 3.944396E+03
P = 1.268794E+03 -1.012658E+03 3.594850E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.161493E+03
P = 0.000000E+00 0.000000E+00 5.161493E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 8.026280E+02
P = 0.000000E+00 0.000000E+00 -8.026280E+02
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 1.338507E+03
P = 0.000000E+00 0.000000E+00 1.338507E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 5.697372E+03
P = 0.000000E+00 0.000000E+00 -5.697372E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.859003E+03
P = -1.244183E+03 1.042255E+03 9.018256E+02
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 3.946114E+03
P = 1.293383E+03 -9.830856E+02 3.596181E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 1.590037E+02
P = -4.920023E+01 -5.916959E+01 -1.391419E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.161493E+03
P = 0.000000E+00 0.000000E+00 5.161493E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(1)
E = 8.026280E+02
P = 0.000000E+00 0.000000E+00 -8.026280E+02
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 1.338507E+03
P = 0.000000E+00 0.000000E+00 1.338507E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 5.697372E+03
P = 0.000000E+00 0.000000E+00 -5.697372E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.859003E+03
P = -1.244183E+03 1.042255E+03 9.018256E+02
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(1)
E = 3.946114E+03
P = 1.293383E+03 -9.830856E+02 3.596181E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 1.590037E+02
P = -4.920023E+01 -5.916959E+01 -1.391419E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.150429E+03
P = 0.000000E+00 0.000000E+00 5.150429E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(21)
E = 6.534115E+02
P = 0.000000E+00 0.000000E+00 -6.534115E+02
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 1.349571E+03
P = 0.000000E+00 0.000000E+00 1.349571E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(93*)
E = 5.846589E+03
P = 0.000000E+00 0.000000E+00 -5.846589E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.479997E+03
P = -1.008746E+03 8.051068E+02 7.185470E+02
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 4.011979E+03
P = 1.198267E+03 -1.034996E+03 3.686315E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 3.118649E+02
P = -1.895206E+02 2.298889E+02 9.215611E+01
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(1)
E = 5.161493E+03
P = 0.000000E+00 0.000000E+00 5.161493E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-1)
E = 8.026280E+02
P = 0.000000E+00 0.000000E+00 -8.026280E+02
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 1.338507E+03
P = 0.000000E+00 0.000000E+00 1.338507E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 5.697372E+03
P = 0.000000E+00 0.000000E+00 -5.697372E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.859003E+03
P = -1.244183E+03 1.042255E+03 9.018256E+02
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 3.946114E+03
P = 1.293383E+03 -9.830856E+02 3.596181E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 1.590037E+02
P = -4.920023E+01 -5.916959E+01 -1.391419E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 4.07075E+03
n_in* => 2
n_out* => 5
n_tot* => 7
$process_id* => "nlo_ppzj_sim_1_p1"
process_num_id* => [unknown integer]
sqme* => 1.19154E-02
sqme_ref* => 4.07480E-04
event_index* => 9
event_weight* => 4.57400E+01
event_weight_ref* => 1.56420E+00
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:1|-5.1614928E+03; 0.0000000E+00, 0.0000000E+00,-5.1614928E+03| 0.0000000E+00| 3)
4 prt(i:-1|-8.0262799E+02; 0.0000000E+00, 0.0000000E+00, 8.0262799E+02| 0.0000000E+00| 4)
5 prt(o:-92| 1.3385072E+03; 0.0000000E+00, 0.0000000E+00, 1.3385072E+03| 0.0000000E+00| 5)
6 prt(o:92| 5.6973720E+03; 0.0000000E+00, 0.0000000E+00,-5.6973720E+03| 0.0000000E+00| 6)
7 prt(o:23| 1.8590030E+03;-1.2441831E+03, 1.0422552E+03, 9.0182557E+02| 8.3152513E+03| 7)
8 prt(o:21| 3.9461142E+03; 1.2933833E+03,-9.8308560E+02, 3.5961812E+03| 0.0000000E+00| 8)
9 prt(o:21| 1.5900371E+02;-4.9200234E+01,-5.9169588E+01,-1.3914192E+02| 0.0000000E+00| 9)
========================================================================
========================================================================
Event #10
------------------------------------------------------------------------
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 = 6
Selected channel = 4
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
2196095161.0, 2277555156.0, 2833279767.0,
600270049.0, 2643161231.0, 2906444566.0,
]
Beginning substream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Initial stream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 5.735569E+03
P = 0.000000E+00 0.000000E+00 5.735569E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(21)
E = 2.563267E+02
P = 0.000000E+00 0.000000E+00 -2.563267E+02
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 7.644306E+02
P = 0.000000E+00 0.000000E+00 7.644306E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(93*)
E = 6.243673E+03
P = 0.000000E+00 0.000000E+00 -6.243673E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.654219E+02
P = 3.212569E+01 4.860136E+00 -2.471393E+02
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 5.726474E+03
P = -3.212569E+01 -4.860136E+00 5.726382E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
2846212510.0, 1789958399.0, 3272525225.0,
4086594042.0, 2216429131.0, 510754329.0,
]
Beginning substream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Initial stream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 5.809356E+03
P = 0.000000E+00 0.000000E+00 5.809356E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 2.563267E+02
P = 0.000000E+00 0.000000E+00 -2.563267E+02
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 6.906439E+02
P = 0.000000E+00 0.000000E+00 6.906439E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 6.243673E+03
P = 0.000000E+00 0.000000E+00 -6.243673E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.654262E+02
P = 3.219238E+01 4.852398E+00 -2.471354E+02
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 5.726470E+03
P = -3.205918E+01 -4.867852E+00 5.726378E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 7.378676E+01
P = -1.332036E-01 1.545430E-02 7.378664E+01
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 1.191543374E-02
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 5.735569E+03
P = 0.000000E+00 0.000000E+00 5.735569E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 2.563267E+02
P = 0.000000E+00 0.000000E+00 -2.563267E+02
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 7.644306E+02
P = 0.000000E+00 0.000000E+00 7.644306E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 6.243673E+03
P = 0.000000E+00 0.000000E+00 -6.243673E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.654219E+02
P = 3.212569E+01 4.860136E+00 -2.471393E+02
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 5.726474E+03
P = -3.212569E+01 -4.860136E+00 5.726382E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 5.809356E+03
P = 0.000000E+00 0.000000E+00 5.809356E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 2.563267E+02
P = 0.000000E+00 0.000000E+00 -2.563267E+02
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 6.906439E+02
P = 0.000000E+00 0.000000E+00 6.906439E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 6.243673E+03
P = 0.000000E+00 0.000000E+00 -6.243673E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.654262E+02
P = 3.219238E+01 4.852398E+00 -2.471354E+02
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 5.726470E+03
P = -3.205918E+01 -4.867852E+00 5.726378E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 7.378676E+01
P = -1.332036E-01 1.545430E-02 7.378664E+01
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 5.809356E+03
P = 0.000000E+00 0.000000E+00 5.809356E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 2.563267E+02
P = 0.000000E+00 0.000000E+00 -2.563267E+02
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 6.906439E+02
P = 0.000000E+00 0.000000E+00 6.906439E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 6.243673E+03
P = 0.000000E+00 0.000000E+00 -6.243673E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.654262E+02
P = 3.219238E+01 4.852398E+00 -2.471354E+02
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 5.726470E+03
P = -3.205918E+01 -4.867852E+00 5.726378E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 7.378676E+01
P = -1.332036E-01 1.545430E-02 7.378664E+01
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 5.735569E+03
P = 0.000000E+00 0.000000E+00 5.735569E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 2.563267E+02
P = 0.000000E+00 0.000000E+00 -2.563267E+02
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 7.644306E+02
P = 0.000000E+00 0.000000E+00 7.644306E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 6.243673E+03
P = 0.000000E+00 0.000000E+00 -6.243673E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.654214E+02
P = 3.212563E+01 4.860127E+00 -2.471388E+02
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 5.108014E+03
P = -2.892105E+01 -3.361472E+00 5.107931E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 6.184604E+02
P = -3.204586E+00 -1.498655E+00 6.184503E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 5.809356E+03
P = 0.000000E+00 0.000000E+00 5.809356E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 2.563267E+02
P = 0.000000E+00 0.000000E+00 -2.563267E+02
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 6.906439E+02
P = 0.000000E+00 0.000000E+00 6.906439E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 6.243673E+03
P = 0.000000E+00 0.000000E+00 -6.243673E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.654262E+02
P = 3.219238E+01 4.852398E+00 -2.471354E+02
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 5.726470E+03
P = -3.205918E+01 -4.867852E+00 5.726378E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 7.378676E+01
P = -1.332036E-01 1.545430E-02 7.378664E+01
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 2.42502E+03
n_in* => 2
n_out* => 4
n_tot* => 6
$process_id* => "nlo_ppzj_sim_1_p1"
process_num_id* => [unknown integer]
sqme* => 0.00000E+00
sqme_ref* => 0.00000E+00
event_index* => 10
event_weight* => 0.00000E+00
event_weight_ref* => 0.00000E+00
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:-2|-5.7355694E+03; 0.0000000E+00, 0.0000000E+00,-5.7355694E+03| 0.0000000E+00| 3)
4 prt(i:2|-2.5632667E+02; 0.0000000E+00, 0.0000000E+00, 2.5632667E+02| 0.0000000E+00| 4)
5 prt(o:92| 7.6443065E+02; 0.0000000E+00, 0.0000000E+00, 7.6443065E+02| 0.0000000E+00| 5)
6 prt(o:-92| 6.2436733E+03; 0.0000000E+00, 0.0000000E+00,-6.2436733E+03| 0.0000000E+00| 6)
7 prt(o:23| 2.6542187E+02; 3.2125689E+01, 4.8601360E+00,-2.4713930E+02| 8.3152513E+03| 7)
8 prt(o:21| 5.7264742E+03;-3.2125689E+01,-4.8601360E+00, 5.7263820E+03| 0.0000000E+00| 8)
========================================================================
========================================================================
Event #10
------------------------------------------------------------------------
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 = 6
Selected channel = 4
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
2196095161.0, 2277555156.0, 2833279767.0,
600270049.0, 2643161231.0, 2906444566.0,
]
Beginning substream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Initial stream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 5.735569E+03
P = 0.000000E+00 0.000000E+00 5.735569E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(21)
E = 2.563267E+02
P = 0.000000E+00 0.000000E+00 -2.563267E+02
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 7.644306E+02
P = 0.000000E+00 0.000000E+00 7.644306E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(93*)
E = 6.243673E+03
P = 0.000000E+00 0.000000E+00 -6.243673E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.654219E+02
P = 3.212569E+01 4.860136E+00 -2.471393E+02
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 5.726474E+03
P = -3.212569E+01 -4.860136E+00 5.726382E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
2846212510.0, 1789958399.0, 3272525225.0,
4086594042.0, 2216429131.0, 510754329.0,
]
Beginning substream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Initial stream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 5.809356E+03
P = 0.000000E+00 0.000000E+00 5.809356E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 2.563267E+02
P = 0.000000E+00 0.000000E+00 -2.563267E+02
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 6.906439E+02
P = 0.000000E+00 0.000000E+00 6.906439E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 6.243673E+03
P = 0.000000E+00 0.000000E+00 -6.243673E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.654262E+02
P = 3.219238E+01 4.852398E+00 -2.471354E+02
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 5.726470E+03
P = -3.205918E+01 -4.867852E+00 5.726378E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 7.378676E+01
P = -1.332036E-01 1.545430E-02 7.378664E+01
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 1.191543374E-02
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 5.735569E+03
P = 0.000000E+00 0.000000E+00 5.735569E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 2.563267E+02
P = 0.000000E+00 0.000000E+00 -2.563267E+02
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 7.644306E+02
P = 0.000000E+00 0.000000E+00 7.644306E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 6.243673E+03
P = 0.000000E+00 0.000000E+00 -6.243673E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.654219E+02
P = 3.212569E+01 4.860136E+00 -2.471393E+02
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 5.726474E+03
P = -3.212569E+01 -4.860136E+00 5.726382E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 5.809356E+03
P = 0.000000E+00 0.000000E+00 5.809356E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 2.563267E+02
P = 0.000000E+00 0.000000E+00 -2.563267E+02
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 6.906439E+02
P = 0.000000E+00 0.000000E+00 6.906439E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 6.243673E+03
P = 0.000000E+00 0.000000E+00 -6.243673E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.654262E+02
P = 3.219238E+01 4.852398E+00 -2.471354E+02
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 5.726470E+03
P = -3.205918E+01 -4.867852E+00 5.726378E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 7.378676E+01
P = -1.332036E-01 1.545430E-02 7.378664E+01
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 5.809356E+03
P = 0.000000E+00 0.000000E+00 5.809356E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 2.563267E+02
P = 0.000000E+00 0.000000E+00 -2.563267E+02
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 6.906439E+02
P = 0.000000E+00 0.000000E+00 6.906439E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 6.243673E+03
P = 0.000000E+00 0.000000E+00 -6.243673E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.654262E+02
P = 3.219238E+01 4.852398E+00 -2.471354E+02
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 5.726470E+03
P = -3.205918E+01 -4.867852E+00 5.726378E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 7.378676E+01
P = -1.332036E-01 1.545430E-02 7.378664E+01
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 5.735569E+03
P = 0.000000E+00 0.000000E+00 5.735569E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 2.563267E+02
P = 0.000000E+00 0.000000E+00 -2.563267E+02
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 7.644306E+02
P = 0.000000E+00 0.000000E+00 7.644306E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 6.243673E+03
P = 0.000000E+00 0.000000E+00 -6.243673E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.654214E+02
P = 3.212563E+01 4.860127E+00 -2.471388E+02
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 5.108014E+03
P = -2.892105E+01 -3.361472E+00 5.107931E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 6.184604E+02
P = -3.204586E+00 -1.498655E+00 6.184503E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 5.809356E+03
P = 0.000000E+00 0.000000E+00 5.809356E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 2.563267E+02
P = 0.000000E+00 0.000000E+00 -2.563267E+02
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 6.906439E+02
P = 0.000000E+00 0.000000E+00 6.906439E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 6.243673E+03
P = 0.000000E+00 0.000000E+00 -6.243673E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.654262E+02
P = 3.219238E+01 4.852398E+00 -2.471354E+02
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 5.726470E+03
P = -3.205918E+01 -4.867852E+00 5.726378E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 7.378676E+01
P = -1.332036E-01 1.545430E-02 7.378664E+01
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 2.44057E+03
n_in* => 2
n_out* => 5
n_tot* => 7
$process_id* => "nlo_ppzj_sim_1_p1"
process_num_id* => [unknown integer]
sqme* => 0.00000E+00
sqme_ref* => 0.00000E+00
event_index* => 10
event_weight* => 0.00000E+00
event_weight_ref* => 0.00000E+00
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:-2|-5.8093561E+03; 0.0000000E+00, 0.0000000E+00,-5.8093561E+03| 0.0000000E+00| 3)
4 prt(i:-2|-2.5632673E+02; 0.0000000E+00, 0.0000000E+00, 2.5632673E+02| 0.0000000E+00| 4)
5 prt(o:92| 6.9064394E+02; 0.0000000E+00, 0.0000000E+00, 6.9064394E+02| 0.0000000E+00| 5)
6 prt(o:92| 6.2436733E+03; 0.0000000E+00, 0.0000000E+00,-6.2436733E+03| 0.0000000E+00| 6)
7 prt(o:23| 2.6542615E+02; 3.2192385E+01, 4.8523979E+00,-2.4713538E+02| 8.3152513E+03| 7)
8 prt(o:-2| 5.7264699E+03;-3.2059181E+01,-4.8678522E+00, 5.7263781E+03| 0.0000000E+00| 8)
9 prt(o:-2| 7.3786758E+01;-1.3320361E-01, 1.5454297E-02, 7.3786636E+01| 0.0000000E+00| 9)
========================================================================
========================================================================
Event #10
------------------------------------------------------------------------
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 = 6
Selected channel = 4
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
2196095161.0, 2277555156.0, 2833279767.0,
600270049.0, 2643161231.0, 2906444566.0,
]
Beginning substream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Initial stream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 5.735569E+03
P = 0.000000E+00 0.000000E+00 5.735569E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(21)
E = 2.563267E+02
P = 0.000000E+00 0.000000E+00 -2.563267E+02
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 7.644306E+02
P = 0.000000E+00 0.000000E+00 7.644306E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(93*)
E = 6.243673E+03
P = 0.000000E+00 0.000000E+00 -6.243673E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.654219E+02
P = 3.212569E+01 4.860136E+00 -2.471393E+02
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 5.726474E+03
P = -3.212569E+01 -4.860136E+00 5.726382E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
2846212510.0, 1789958399.0, 3272525225.0,
4086594042.0, 2216429131.0, 510754329.0,
]
Beginning substream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Initial stream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 5.809356E+03
P = 0.000000E+00 0.000000E+00 5.809356E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 2.563267E+02
P = 0.000000E+00 0.000000E+00 -2.563267E+02
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 6.906439E+02
P = 0.000000E+00 0.000000E+00 6.906439E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 6.243673E+03
P = 0.000000E+00 0.000000E+00 -6.243673E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.654262E+02
P = 3.219238E+01 4.852398E+00 -2.471354E+02
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 5.726470E+03
P = -3.205918E+01 -4.867852E+00 5.726378E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 7.378676E+01
P = -1.332036E-01 1.545430E-02 7.378664E+01
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 1.191543374E-02
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 5.735569E+03
P = 0.000000E+00 0.000000E+00 5.735569E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 2.563267E+02
P = 0.000000E+00 0.000000E+00 -2.563267E+02
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 7.644306E+02
P = 0.000000E+00 0.000000E+00 7.644306E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 6.243673E+03
P = 0.000000E+00 0.000000E+00 -6.243673E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.654219E+02
P = 3.212569E+01 4.860136E+00 -2.471393E+02
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 5.726474E+03
P = -3.212569E+01 -4.860136E+00 5.726382E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 5.809356E+03
P = 0.000000E+00 0.000000E+00 5.809356E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 2.563267E+02
P = 0.000000E+00 0.000000E+00 -2.563267E+02
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 6.906439E+02
P = 0.000000E+00 0.000000E+00 6.906439E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 6.243673E+03
P = 0.000000E+00 0.000000E+00 -6.243673E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.654262E+02
P = 3.219238E+01 4.852398E+00 -2.471354E+02
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 5.726470E+03
P = -3.205918E+01 -4.867852E+00 5.726378E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 7.378676E+01
P = -1.332036E-01 1.545430E-02 7.378664E+01
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 5.809356E+03
P = 0.000000E+00 0.000000E+00 5.809356E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 2.563267E+02
P = 0.000000E+00 0.000000E+00 -2.563267E+02
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 6.906439E+02
P = 0.000000E+00 0.000000E+00 6.906439E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 6.243673E+03
P = 0.000000E+00 0.000000E+00 -6.243673E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.654262E+02
P = 3.219238E+01 4.852398E+00 -2.471354E+02
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 5.726470E+03
P = -3.205918E+01 -4.867852E+00 5.726378E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 7.378676E+01
P = -1.332036E-01 1.545430E-02 7.378664E+01
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 5.735569E+03
P = 0.000000E+00 0.000000E+00 5.735569E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 2.563267E+02
P = 0.000000E+00 0.000000E+00 -2.563267E+02
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 7.644306E+02
P = 0.000000E+00 0.000000E+00 7.644306E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 6.243673E+03
P = 0.000000E+00 0.000000E+00 -6.243673E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.654214E+02
P = 3.212563E+01 4.860127E+00 -2.471388E+02
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 5.108014E+03
P = -2.892105E+01 -3.361472E+00 5.107931E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 6.184604E+02
P = -3.204586E+00 -1.498655E+00 6.184503E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 5.809356E+03
P = 0.000000E+00 0.000000E+00 5.809356E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 2.563267E+02
P = 0.000000E+00 0.000000E+00 -2.563267E+02
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 6.906439E+02
P = 0.000000E+00 0.000000E+00 6.906439E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 6.243673E+03
P = 0.000000E+00 0.000000E+00 -6.243673E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.654262E+02
P = 3.219238E+01 4.852398E+00 -2.471354E+02
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 5.726470E+03
P = -3.205918E+01 -4.867852E+00 5.726378E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 7.378676E+01
P = -1.332036E-01 1.545430E-02 7.378664E+01
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 2.44057E+03
n_in* => 2
n_out* => 5
n_tot* => 7
$process_id* => "nlo_ppzj_sim_1_p1"
process_num_id* => [unknown integer]
sqme* => 0.00000E+00
sqme_ref* => 0.00000E+00
event_index* => 10
event_weight* => 0.00000E+00
event_weight_ref* => 0.00000E+00
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:-2|-5.8093561E+03; 0.0000000E+00, 0.0000000E+00,-5.8093561E+03| 0.0000000E+00| 3)
4 prt(i:-2|-2.5632673E+02; 0.0000000E+00, 0.0000000E+00, 2.5632673E+02| 0.0000000E+00| 4)
5 prt(o:92| 6.9064394E+02; 0.0000000E+00, 0.0000000E+00, 6.9064394E+02| 0.0000000E+00| 5)
6 prt(o:92| 6.2436733E+03; 0.0000000E+00, 0.0000000E+00,-6.2436733E+03| 0.0000000E+00| 6)
7 prt(o:23| 2.6542615E+02; 3.2192385E+01, 4.8523979E+00,-2.4713538E+02| 8.3152513E+03| 7)
8 prt(o:-2| 5.7264699E+03;-3.2059181E+01,-4.8678522E+00, 5.7263781E+03| 0.0000000E+00| 8)
9 prt(o:-2| 7.3786758E+01;-1.3320361E-01, 1.5454297E-02, 7.3786636E+01| 0.0000000E+00| 9)
========================================================================
========================================================================
Event #10
------------------------------------------------------------------------
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 = 6
Selected channel = 4
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
2196095161.0, 2277555156.0, 2833279767.0,
600270049.0, 2643161231.0, 2906444566.0,
]
Beginning substream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Initial stream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 5.735569E+03
P = 0.000000E+00 0.000000E+00 5.735569E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(21)
E = 2.563267E+02
P = 0.000000E+00 0.000000E+00 -2.563267E+02
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 7.644306E+02
P = 0.000000E+00 0.000000E+00 7.644306E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(93*)
E = 6.243673E+03
P = 0.000000E+00 0.000000E+00 -6.243673E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.654219E+02
P = 3.212569E+01 4.860136E+00 -2.471393E+02
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 5.726474E+03
P = -3.212569E+01 -4.860136E+00 5.726382E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
2846212510.0, 1789958399.0, 3272525225.0,
4086594042.0, 2216429131.0, 510754329.0,
]
Beginning substream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Initial stream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 5.809356E+03
P = 0.000000E+00 0.000000E+00 5.809356E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 2.563267E+02
P = 0.000000E+00 0.000000E+00 -2.563267E+02
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 6.906439E+02
P = 0.000000E+00 0.000000E+00 6.906439E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 6.243673E+03
P = 0.000000E+00 0.000000E+00 -6.243673E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.654262E+02
P = 3.219238E+01 4.852398E+00 -2.471354E+02
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 5.726470E+03
P = -3.205918E+01 -4.867852E+00 5.726378E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 7.378676E+01
P = -1.332036E-01 1.545430E-02 7.378664E+01
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 1.191543374E-02
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 5.735569E+03
P = 0.000000E+00 0.000000E+00 5.735569E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 2.563267E+02
P = 0.000000E+00 0.000000E+00 -2.563267E+02
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 7.644306E+02
P = 0.000000E+00 0.000000E+00 7.644306E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 6.243673E+03
P = 0.000000E+00 0.000000E+00 -6.243673E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.654219E+02
P = 3.212569E+01 4.860136E+00 -2.471393E+02
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 5.726474E+03
P = -3.212569E+01 -4.860136E+00 5.726382E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 5.809356E+03
P = 0.000000E+00 0.000000E+00 5.809356E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 2.563267E+02
P = 0.000000E+00 0.000000E+00 -2.563267E+02
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 6.906439E+02
P = 0.000000E+00 0.000000E+00 6.906439E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 6.243673E+03
P = 0.000000E+00 0.000000E+00 -6.243673E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.654262E+02
P = 3.219238E+01 4.852398E+00 -2.471354E+02
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 5.726470E+03
P = -3.205918E+01 -4.867852E+00 5.726378E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 7.378676E+01
P = -1.332036E-01 1.545430E-02 7.378664E+01
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 5.809356E+03
P = 0.000000E+00 0.000000E+00 5.809356E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 2.563267E+02
P = 0.000000E+00 0.000000E+00 -2.563267E+02
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 6.906439E+02
P = 0.000000E+00 0.000000E+00 6.906439E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 6.243673E+03
P = 0.000000E+00 0.000000E+00 -6.243673E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.654262E+02
P = 3.219238E+01 4.852398E+00 -2.471354E+02
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 5.726470E+03
P = -3.205918E+01 -4.867852E+00 5.726378E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 7.378676E+01
P = -1.332036E-01 1.545430E-02 7.378664E+01
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 5.735569E+03
P = 0.000000E+00 0.000000E+00 5.735569E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 2.563267E+02
P = 0.000000E+00 0.000000E+00 -2.563267E+02
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 7.644306E+02
P = 0.000000E+00 0.000000E+00 7.644306E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 6.243673E+03
P = 0.000000E+00 0.000000E+00 -6.243673E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.654214E+02
P = 3.212563E+01 4.860127E+00 -2.471388E+02
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 5.108014E+03
P = -2.892105E+01 -3.361472E+00 5.107931E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 6.184604E+02
P = -3.204586E+00 -1.498655E+00 6.184503E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 5.809356E+03
P = 0.000000E+00 0.000000E+00 5.809356E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 2.563267E+02
P = 0.000000E+00 0.000000E+00 -2.563267E+02
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 6.906439E+02
P = 0.000000E+00 0.000000E+00 6.906439E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 6.243673E+03
P = 0.000000E+00 0.000000E+00 -6.243673E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.654262E+02
P = 3.219238E+01 4.852398E+00 -2.471354E+02
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 5.726470E+03
P = -3.205918E+01 -4.867852E+00 5.726378E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 7.378676E+01
P = -1.332036E-01 1.545430E-02 7.378664E+01
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 2.42502E+03
n_in* => 2
n_out* => 5
n_tot* => 7
$process_id* => "nlo_ppzj_sim_1_p1"
process_num_id* => [unknown integer]
sqme* => 0.00000E+00
sqme_ref* => 0.00000E+00
event_index* => 10
event_weight* => 0.00000E+00
event_weight_ref* => 0.00000E+00
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:-3|-5.7355694E+03; 0.0000000E+00, 0.0000000E+00,-5.7355694E+03| 0.0000000E+00| 3)
4 prt(i:-3|-2.5632667E+02; 0.0000000E+00, 0.0000000E+00, 2.5632667E+02| 0.0000000E+00| 4)
5 prt(o:92| 7.6443065E+02; 0.0000000E+00, 0.0000000E+00, 7.6443065E+02| 0.0000000E+00| 5)
6 prt(o:92| 6.2436733E+03; 0.0000000E+00, 0.0000000E+00,-6.2436733E+03| 0.0000000E+00| 6)
7 prt(o:23| 2.6542142E+02; 3.2125631E+01, 4.8601272E+00,-2.4713883E+02| 8.3152513E+03| 7)
8 prt(o:-3| 5.1080142E+03;-2.8921045E+01,-3.3614720E+00, 5.1079312E+03| 0.0000000E+00| 8)
9 prt(o:-3| 6.1846040E+02;-3.2045856E+00,-1.4986553E+00, 6.1845028E+02| 0.0000000E+00| 9)
========================================================================
========================================================================
Event #10
------------------------------------------------------------------------
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 = 6
Selected channel = 4
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
2196095161.0, 2277555156.0, 2833279767.0,
600270049.0, 2643161231.0, 2906444566.0,
]
Beginning substream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Initial stream = [
2091398231.0, 2586890635.0, 66744427.0,
1368566941.0, 3200083260.0, 3514012191.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 5.735569E+03
P = 0.000000E+00 0.000000E+00 5.735569E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(21)
E = 2.563267E+02
P = 0.000000E+00 0.000000E+00 -2.563267E+02
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 7.644306E+02
P = 0.000000E+00 0.000000E+00 7.644306E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(93*)
E = 6.243673E+03
P = 0.000000E+00 0.000000E+00 -6.243673E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.654219E+02
P = 3.212569E+01 4.860136E+00 -2.471393E+02
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 5.726474E+03
P = -3.212569E+01 -4.860136E+00 5.726382E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_1_p1'
RNG Stream generator
Current position = [
2846212510.0, 1789958399.0, 3272525225.0,
4086594042.0, 2216429131.0, 510754329.0,
]
Beginning substream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Initial stream = [
3234158684.0, 189525900.0, 1822003179.0,
4203435039.0, 4118646620.0, 1525689562.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 5.809356E+03
P = 0.000000E+00 0.000000E+00 5.809356E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 2.563267E+02
P = 0.000000E+00 0.000000E+00 -2.563267E+02
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 6.906439E+02
P = 0.000000E+00 0.000000E+00 6.906439E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 6.243673E+03
P = 0.000000E+00 0.000000E+00 -6.243673E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.654262E+02
P = 3.219238E+01 4.852398E+00 -2.471354E+02
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 5.726470E+03
P = -3.205918E+01 -4.867852E+00 5.726378E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 7.378676E+01
P = -1.332036E-01 1.545430E-02 7.378664E+01
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 1.191543374E-02
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 5.735569E+03
P = 0.000000E+00 0.000000E+00 5.735569E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 2.563267E+02
P = 0.000000E+00 0.000000E+00 -2.563267E+02
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 7.644306E+02
P = 0.000000E+00 0.000000E+00 7.644306E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 6.243673E+03
P = 0.000000E+00 0.000000E+00 -6.243673E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.654219E+02
P = 3.212569E+01 4.860136E+00 -2.471393E+02
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 5.726474E+03
P = -3.212569E+01 -4.860136E+00 5.726382E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 5.809356E+03
P = 0.000000E+00 0.000000E+00 5.809356E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 2.563267E+02
P = 0.000000E+00 0.000000E+00 -2.563267E+02
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 6.906439E+02
P = 0.000000E+00 0.000000E+00 6.906439E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 6.243673E+03
P = 0.000000E+00 0.000000E+00 -6.243673E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.654262E+02
P = 3.219238E+01 4.852398E+00 -2.471354E+02
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 5.726470E+03
P = -3.205918E+01 -4.867852E+00 5.726378E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 7.378676E+01
P = -1.332036E-01 1.545430E-02 7.378664E+01
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 5.809356E+03
P = 0.000000E+00 0.000000E+00 5.809356E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 2.563267E+02
P = 0.000000E+00 0.000000E+00 -2.563267E+02
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 6.906439E+02
P = 0.000000E+00 0.000000E+00 6.906439E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 6.243673E+03
P = 0.000000E+00 0.000000E+00 -6.243673E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.654262E+02
P = 3.219238E+01 4.852398E+00 -2.471354E+02
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 5.726470E+03
P = -3.205918E+01 -4.867852E+00 5.726378E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 7.378676E+01
P = -1.332036E-01 1.545430E-02 7.378664E+01
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 5.735569E+03
P = 0.000000E+00 0.000000E+00 5.735569E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 2.563267E+02
P = 0.000000E+00 0.000000E+00 -2.563267E+02
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 7.644306E+02
P = 0.000000E+00 0.000000E+00 7.644306E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 6.243673E+03
P = 0.000000E+00 0.000000E+00 -6.243673E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.654214E+02
P = 3.212563E+01 4.860127E+00 -2.471388E+02
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 5.108014E+03
P = -2.892105E+01 -3.361472E+00 5.107931E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 6.184604E+02
P = -3.204586E+00 -1.498655E+00 6.184503E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 5.809356E+03
P = 0.000000E+00 0.000000E+00 5.809356E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 2.563267E+02
P = 0.000000E+00 0.000000E+00 -2.563267E+02
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 6.906439E+02
P = 0.000000E+00 0.000000E+00 6.906439E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 6.243673E+03
P = 0.000000E+00 0.000000E+00 -6.243673E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.654262E+02
P = 3.219238E+01 4.852398E+00 -2.471354E+02
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 5.726470E+03
P = -3.205918E+01 -4.867852E+00 5.726378E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 7.378676E+01
P = -1.332036E-01 1.545430E-02 7.378664E+01
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 2.44057E+03
n_in* => 2
n_out* => 5
n_tot* => 7
$process_id* => "nlo_ppzj_sim_1_p1"
process_num_id* => [unknown integer]
sqme* => 0.00000E+00
sqme_ref* => 0.00000E+00
event_index* => 10
event_weight* => 0.00000E+00
event_weight_ref* => 0.00000E+00
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:-3|-5.8093561E+03; 0.0000000E+00, 0.0000000E+00,-5.8093561E+03| 0.0000000E+00| 3)
4 prt(i:-3|-2.5632673E+02; 0.0000000E+00, 0.0000000E+00, 2.5632673E+02| 0.0000000E+00| 4)
5 prt(o:92| 6.9064394E+02; 0.0000000E+00, 0.0000000E+00, 6.9064394E+02| 0.0000000E+00| 5)
6 prt(o:92| 6.2436733E+03; 0.0000000E+00, 0.0000000E+00,-6.2436733E+03| 0.0000000E+00| 6)
7 prt(o:23| 2.6542615E+02; 3.2192385E+01, 4.8523979E+00,-2.4713538E+02| 8.3152513E+03| 7)
8 prt(o:-3| 5.7264699E+03;-3.2059181E+01,-4.8678522E+00, 5.7263781E+03| 0.0000000E+00| 8)
9 prt(o:-3| 7.3786758E+01;-1.3320361E-01, 1.5454297E-02, 7.3786636E+01| 0.0000000E+00| 9)
========================================================================
Index: trunk/share/tests/ext_tests_nlo/ref-output/nlo_ee4tj.ref
===================================================================
--- trunk/share/tests/ext_tests_nlo/ref-output/nlo_ee4tj.ref (revision 8482)
+++ trunk/share/tests/ext_tests_nlo/ref-output/nlo_ee4tj.ref (revision 8483)
@@ -1,165 +1,167 @@
?openmp_logging = false
?vis_history = false
?integration_timer = false
openmp_num_threads = 1
?debug_decay = false
?debug_process = false
?debug_verbose = false
?write_raw = false
| Switching to model 'SM', scheme 'GF_MW_MZ'
$blha_ew_scheme = "alpha_qed"
SM.mZ => 9.118800000000E+01
SM.mW => 8.041900200000E+01
SM.mH => 1.250000000000E+02
SM.GF => 1.166390000000E-05
SM.wZ => 0.000000000000E+00
SM.wtop => 0.000000000000E+00
SM.wW => 0.000000000000E+00
SM.wH => 0.000000000000E+00
SM.ms => 0.000000000000E+00
SM.mc => 0.000000000000E+00
SM.mb => 0.000000000000E+00
SM.mtop => 1.732000000000E+02
SM.me => 0.000000000000E+00
SM.mmu => 0.000000000000E+00
SM.mtau => 1.777000000000E+00
SM.alphas => 1.180000000000E-01
?alphas_is_fixed = false
?alphas_from_mz = true
?alphas_from_lambda_qcd = false
alphas_nf = 5
alphas_order = 2
[user variable] jet = PDG(2, -2, 1, -1, 3, -3, 4, -4, 5, -5, 21)
$exclude_gauge_splittings = "t"
$method = "openloops"
seed = 8131
sqrts = 1.000000000000E+03
jet_algorithm = 2
jet_r = 5.000000000000E-01
-?use_vamp_equivalences = false
$integration_method = "vamp2"
$rng_method = "rng_stream"
| End of included 'nlo_settings.sin'
alpha_power = 2
alphas_power = 3
| Process library 'nlo_ee4tj_lib': recorded process 'nlo_ee4tj_p1'
| Integrate: current process library needs compilation
| Process library 'nlo_ee4tj_lib': compiling ...
| Process library 'nlo_ee4tj_lib': writing makefile
| Process library 'nlo_ee4tj_lib': removing old files
| Process library 'nlo_ee4tj_lib': writing driver
| Process library 'nlo_ee4tj_lib': creating source code
| Process library 'nlo_ee4tj_lib': compiling sources
| Process library 'nlo_ee4tj_lib': linking
| Process library 'nlo_ee4tj_lib': loading
| Process library 'nlo_ee4tj_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 8131
| Initializing integration for process nlo_ee4tj_p1:
| Beam structure: [any particles]
| Beam data (collision):
| e- (mass = 0.0000000E+00 GeV)
| e+ (mass = 0.0000000E+00 GeV)
| sqrts = 1.000000000000E+03 GeV
| Phase space: generating configuration ...
| Phase space: ... failed. Increasing phs_off_shell ...
| Phase space: ... success.
| Phase space: writing configuration file 'nlo_ee4tj_p1.i1.phs'
| Phase space: generating configuration ...
| Phase space: ... failed. Increasing phs_off_shell ...
| Phase space: ... success.
| Phase space: writing configuration file 'nlo_ee4tj_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: [...]
| 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]: 'nlo_ee4tj_p1'
| Library name = 'nlo_ee4tj_lib'
| Process index = 1
| Process components:
| 1: 'nlo_ee4tj_p1_i1': e-, e+ => t, tbar, t, tbar, u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl [openloops]
| 2: 'nlo_ee4tj_p1_i2': e-, e+ => t, tbar, t, tbar, d:dbar:u:ubar:s:sbar:c:cbar:b:bbar:gl, d:dbar:u:ubar:s:sbar:c:cbar:b:bbar:gl [openloops], [real]
| 3: 'nlo_ee4tj_p1_i3': e-, e+ => t, tbar, t, tbar, u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl [openloops], [virtual]
| 4: 'nlo_ee4tj_p1_i4': e-, e+ => t, tbar, t, tbar, u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl [inactive], [subtraction]
| ------------------------------------------------------------------------
| Phase space: 64 channels, 11 dimensions
| Phase space: found 64 channels, collected in 2 groves.
-| Phase space: no equivalences between channels used.
+| Phase space: Using 384 equivalences between channels.
| Phase space: wood
| Phase space: 64 channels, 14 dimensions
| Phase space: found 64 channels, collected in 2 groves.
-| Phase space: no equivalences between channels used.
+| Phase space: Using 384 equivalences between channels.
| Phase space: wood
| Phase space: 64 channels, 11 dimensions
| Phase space: found 64 channels, collected in 2 groves.
-| Phase space: no equivalences between channels used.
+| Phase space: Using 384 equivalences between channels.
| Phase space: wood
| Applying user-defined cuts.
| Using user-defined general scale.
| Starting integration for process 'nlo_ee4tj_p1' part 'born'
| Integrate: iterations = 1:640:"gw"
| Integrator: 2 chains, 64 channels, 11 dimensions
+| Integrator: Using VAMP2 channel equivalences
| Integrator: 640 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 'nlo_ee4tj_p1.m1.vg2'.
| VAMP2: set chain: use chained weights.
1 640 3.3015681E-05 6.26E-06 18.95 4.80* 12.71
|-----------------------------------------------------------------------------|
1 640 3.3015681E-05 6.26E-06 18.95 4.80 12.71
|=============================================================================|
| Starting integration for process 'nlo_ee4tj_p1' part 'real'
| Integrate: iterations = 1:640:"gw"
| Integrator: 2 chains, 64 channels, 14 dimensions
+| Integrator: Using VAMP2 channel equivalences
| Integrator: 640 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 'nlo_ee4tj_p1.m2.vg2'.
| VAMP2: set chain: use chained weights.
1 640 -6.1255904E-06 3.37E-06 55.00 13.91* 11.45
|-----------------------------------------------------------------------------|
1 640 -6.1255904E-06 3.37E-06 55.00 13.91 11.45
|=============================================================================|
| Starting integration for process 'nlo_ee4tj_p1' part 'virtual'
| Integrate: iterations = 1:640:"gw"
| Integrator: 2 chains, 64 channels, 11 dimensions
+| Integrator: Using VAMP2 channel equivalences
| Integrator: 640 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 'nlo_ee4tj_p1.m3.vg2'.
| VAMP2: set chain: use chained weights.
1 640 2.5286924E-05 4.40E-06 17.39 4.40* 12.13
|-----------------------------------------------------------------------------|
1 640 2.5286924E-05 4.40E-06 17.39 4.40 12.13
|=============================================================================|
| Integrate: sum of all components
|=============================================================================|
| It Calls Integral[fb] Error[fb] Err[%] Acc Eff[%] Chi2 N[It] |
|=============================================================================|
1 0 5.2177015E-05 8.36E-06 16.02 0.00* 11.14
| NLO Correction: [O(alpha_s+1)/O(alpha_s)]
| ( 58.0371 +- 20.06396 ) %
|=============================================================================|
| WHIZARD run finished.
|=============================================================================|
Index: trunk/share/tests/ext_tests_nlo/ref-output/nlo_eettj.ref
===================================================================
--- trunk/share/tests/ext_tests_nlo/ref-output/nlo_eettj.ref (revision 8482)
+++ trunk/share/tests/ext_tests_nlo/ref-output/nlo_eettj.ref (revision 8483)
@@ -1,163 +1,165 @@
?openmp_logging = false
?vis_history = false
?integration_timer = false
openmp_num_threads = 1
?debug_decay = false
?debug_process = false
?debug_verbose = false
?write_raw = false
| Switching to model 'SM', scheme 'GF_MW_MZ'
$blha_ew_scheme = "alpha_qed"
SM.mZ => 9.118800000000E+01
SM.mW => 8.041900200000E+01
SM.mH => 1.250000000000E+02
SM.GF => 1.166390000000E-05
SM.wZ => 0.000000000000E+00
SM.wtop => 0.000000000000E+00
SM.wW => 0.000000000000E+00
SM.wH => 0.000000000000E+00
SM.ms => 0.000000000000E+00
SM.mc => 0.000000000000E+00
SM.mb => 0.000000000000E+00
SM.mtop => 1.732000000000E+02
SM.me => 0.000000000000E+00
SM.mmu => 0.000000000000E+00
SM.mtau => 1.777000000000E+00
SM.alphas => 1.180000000000E-01
?alphas_is_fixed = false
?alphas_from_mz = true
?alphas_from_lambda_qcd = false
alphas_nf = 5
alphas_order = 2
[user variable] jet = PDG(2, -2, 1, -1, 3, -3, 4, -4, 5, -5, 21)
$exclude_gauge_splittings = "t"
$method = "openloops"
seed = 8131
sqrts = 1.000000000000E+03
jet_algorithm = 2
jet_r = 5.000000000000E-01
-?use_vamp_equivalences = false
$integration_method = "vamp2"
$rng_method = "rng_stream"
| End of included 'nlo_settings.sin'
alpha_power = 2
alphas_power = 1
| Process library 'nlo_eettj_lib': recorded process 'nlo_eettj_p1'
| Integrate: current process library needs compilation
| Process library 'nlo_eettj_lib': compiling ...
| Process library 'nlo_eettj_lib': writing makefile
| Process library 'nlo_eettj_lib': removing old files
| Process library 'nlo_eettj_lib': writing driver
| Process library 'nlo_eettj_lib': creating source code
| Process library 'nlo_eettj_lib': compiling sources
| Process library 'nlo_eettj_lib': linking
| Process library 'nlo_eettj_lib': loading
| Process library 'nlo_eettj_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 8131
| Initializing integration for process nlo_eettj_p1:
| Beam structure: [any particles]
| Beam data (collision):
| e- (mass = 0.0000000E+00 GeV)
| e+ (mass = 0.0000000E+00 GeV)
| sqrts = 1.000000000000E+03 GeV
| Phase space: generating configuration ...
| Phase space: ... success.
| Phase space: writing configuration file 'nlo_eettj_p1.i1.phs'
| Phase space: generating configuration ...
| Phase space: ... success.
| Phase space: writing configuration file 'nlo_eettj_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: [...]
| 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]: 'nlo_eettj_p1'
| Library name = 'nlo_eettj_lib'
| Process index = 1
| Process components:
| 1: 'nlo_eettj_p1_i1': e-, e+ => t, tbar, u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl [openloops]
| 2: 'nlo_eettj_p1_i2': e-, e+ => t, tbar, d:dbar:u:ubar:s:sbar:c:cbar:b:bbar:gl, d:dbar:u:ubar:s:sbar:c:cbar:b:bbar:gl [openloops], [real]
| 3: 'nlo_eettj_p1_i3': e-, e+ => t, tbar, u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl [openloops], [virtual]
| 4: 'nlo_eettj_p1_i4': e-, e+ => t, tbar, u:ubar:d:dbar:s:sbar:c:cbar:b:bbar: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: Using 2 equivalences between channels.
| 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: Using 2 equivalences between channels.
| 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: Using 2 equivalences between channels.
| Phase space: wood
| Applying user-defined cuts.
| Using user-defined general scale.
| Starting integration for process 'nlo_eettj_p1' part 'born'
| Integrate: iterations = 1:100:"gw"
| Integrator: 1 chains, 2 channels, 5 dimensions
+| Integrator: Using VAMP2 channel equivalences
| 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 'nlo_eettj_p1.m1.vg2'.
| VAMP2: set chain: use chained weights.
1 100 4.4113189E+01 8.43E+00 19.11 1.91* 11.29
|-----------------------------------------------------------------------------|
1 100 4.4113189E+01 8.43E+00 19.11 1.91 11.29
|=============================================================================|
| Starting integration for process 'nlo_eettj_p1' part 'real'
| Integrate: iterations = 1:100:"gw"
| Integrator: 1 chains, 2 channels, 8 dimensions
+| Integrator: Using VAMP2 channel equivalences
| 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 'nlo_eettj_p1.m2.vg2'.
| VAMP2: set chain: use chained weights.
1 100 -1.0155418E+01 7.25E+00 71.36 7.14* 8.97
|-----------------------------------------------------------------------------|
1 100 -1.0155418E+01 7.25E+00 71.36 7.14 8.97
|=============================================================================|
| Starting integration for process 'nlo_eettj_p1' part 'virtual'
| Integrate: iterations = 1:100:"gw"
| Integrator: 1 chains, 2 channels, 5 dimensions
+| Integrator: Using VAMP2 channel equivalences
| 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 'nlo_eettj_p1.m3.vg2'.
| VAMP2: set chain: use chained weights.
1 100 1.0827676E+01 3.35E+00 30.98 3.10* 5.85
|-----------------------------------------------------------------------------|
1 100 1.0827676E+01 3.35E+00 30.98 3.10 5.85
|=============================================================================|
| Integrate: sum of all components
|=============================================================================|
| It Calls Integral[fb] Error[fb] Err[%] Acc Eff[%] Chi2 N[It] |
|=============================================================================|
1 0 4.4785447E+01 1.16E+01 25.93 0.00* 7.78
| NLO Correction: [O(alpha_s+1)/O(alpha_s)]
| ( 1.5239 +- 18.10505 ) %
|=============================================================================|
| WHIZARD run finished.
|=============================================================================|
Index: trunk/share/tests/ext_tests_nlo/ref-output/nlo_ppzj_sim_2.ref
===================================================================
--- trunk/share/tests/ext_tests_nlo/ref-output/nlo_ppzj_sim_2.ref (revision 8482)
+++ trunk/share/tests/ext_tests_nlo/ref-output/nlo_ppzj_sim_2.ref (revision 8483)
@@ -1,748 +1,748 @@
?openmp_logging = false
?vis_history = false
?integration_timer = false
?pacify = true
openmp_num_threads = 1
SM.mZ => 9.11880E+01
SM.wZ => 0.00000E+00
SM.ms => 0.00000E+00
[user variable] pr = PDG(2, -2, 1, -1, 3, -3, 21)
[user variable] jet = PDG(2, -2, 1, -1, 3, -3, 21)
[user variable] elec = PDG(11, -11)
$exclude_gauge_splittings = "c:b:t"
jet_algorithm = 2
jet_r = 5.00000E-01
$method = "openloops"
alpha_power = 1
alphas_power = 1
$rng_method = "rng_stream"
$integration_method = "vamp2"
sqrts = 1.30000E+04
?combined_nlo_integration = false
-?use_vamp_equivalences = false
seed = 3991
$restrictions = "!W+:W-"
| Process library 'nlo_ppzj_sim_2_lib': recorded process 'nlo_ppzj_sim_2_p1'
| Integrate: current process library needs compilation
| Process library 'nlo_ppzj_sim_2_lib': compiling ...
| Process library 'nlo_ppzj_sim_2_lib': writing makefile
| Process library 'nlo_ppzj_sim_2_lib': removing old files
| Process library 'nlo_ppzj_sim_2_lib': writing driver
| Process library 'nlo_ppzj_sim_2_lib': creating source code
| Process library 'nlo_ppzj_sim_2_lib': compiling sources
| Process library 'nlo_ppzj_sim_2_lib': linking
| Process library 'nlo_ppzj_sim_2_lib': loading
| Process library 'nlo_ppzj_sim_2_lib': ... success.
| Integrate: compilation done
| RNG: Initializing RNG Stream random-number generator
| RNG: Setting seed for random-number generator to 3991
| Initializing integration for process nlo_ppzj_sim_2_p1:
| Beam structure: p, p => pdf_builtin
| Beam data (collision):
| p (mass = 0.0000000E+00 GeV)
| p (mass = 0.0000000E+00 GeV)
| sqrts = 1.300000000000E+04 GeV
| Initialized builtin PDF CTEQ6L
| Phase space: generating configuration ...
| Phase space: ... success.
| Phase space: writing configuration file 'nlo_ppzj_sim_2_p1.i1.phs'
| Phase space: generating configuration ...
| Phase space: ... success.
| Phase space: writing configuration file 'nlo_ppzj_sim_2_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: [...]
| One-Loop-Provider: Using OpenLoops
| Loading library: [...]
| One-Loop-Provider: Using OpenLoops
| Loading library: [...]
| ------------------------------------------------------------------------
| Process [scattering]: 'nlo_ppzj_sim_2_p1'
| Library name = 'nlo_ppzj_sim_2_lib'
| Process index = 1
| Process components:
| 1: 'nlo_ppzj_sim_2_p1_i1': u:ubar:d:dbar:s:sbar:gl, u:ubar:d:dbar:s:sbar:gl => Z, u:ubar:d:dbar:s:sbar:gl [inactive]
| 2: 'nlo_ppzj_sim_2_p1_i2': dbar:d:ubar:u:sbar:s:gl, dbar:d:ubar:u:sbar:s:gl => Z, d:dbar:u:ubar:s:sbar:gl, d:dbar:u:ubar:s:sbar:gl [inactive], [real]
| 3: 'nlo_ppzj_sim_2_p1_i3': u:ubar:d:dbar:s:sbar:gl, u:ubar:d:dbar:s:sbar:gl => Z, u:ubar:d:dbar:s:sbar:gl [openloops], [virtual]
| 4: 'nlo_ppzj_sim_2_p1_i4': u:ubar:d:dbar:s:sbar:gl, u:ubar:d:dbar:s:sbar:gl => Z, u:ubar:d:dbar:s:sbar:gl [inactive], [subtraction]
| 5: 'nlo_ppzj_sim_2_p1_i5': u:ubar:d:dbar:s:sbar:gl, u:ubar:d:dbar:s:sbar:gl => Z, u:ubar:d:dbar:s:sbar:gl [inactive], [dglap]
| ------------------------------------------------------------------------
| Phase space: 5 channels, 2 dimensions
| Phase space: found 5 channels, collected in 2 groves.
-| Phase space: no equivalences between channels used.
+| Phase space: Using 9 equivalences between channels.
| Phase space: wood
| Phase space: 5 channels, 5 dimensions
| Phase space: found 5 channels, collected in 2 groves.
-| Phase space: no equivalences between channels used.
+| Phase space: Using 9 equivalences between channels.
| Phase space: wood
| Phase space: 5 channels, 2 dimensions
| Phase space: found 5 channels, collected in 2 groves.
-| Phase space: no equivalences between channels used.
+| Phase space: Using 9 equivalences between channels.
| Phase space: wood
| Phase space: 5 channels, 3 dimensions
| Phase space: found 5 channels, collected in 2 groves.
-| Phase space: no equivalences between channels used.
+| Phase space: Using 9 equivalences between channels.
| Phase space: wood
| Beam structure: pdf_builtin, none => none, pdf_builtin
| Beam structure: 1 channels, 2 dimensions
| Applying user-defined cuts.
| Using user-defined general scale.
| Starting integration for process 'nlo_ppzj_sim_2_p1' part 'virtual'
| Integrate: iterations = 1:100
| Integrator: 2 chains, 5 channels, 4 dimensions
+| Integrator: Using VAMP2 channel equivalences
| 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 'nlo_ppzj_sim_2_p1.m3.vg2'.
| VAMP2: set chain: use chained weights.
1 100 -7.985E+02 8.11E+02 101.56 10.16 5.0
|-----------------------------------------------------------------------------|
1 100 -7.985E+02 8.11E+02 101.56 10.16 5.0
|=============================================================================|
| Integrate: sum of all components
|=============================================================================|
| It Calls Integral[fb] Error[fb] Err[%] Acc Eff[%] Chi2 N[It] |
|=============================================================================|
1 0 -7.985E+02 8.11E+02 101.56 0.00 0.0
|=============================================================================|
n_events = 2
$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 'nlo_ppzj_sim_2_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: [...]
| One-Loop-Provider: Using OpenLoops
| Loading library: [...]
| One-Loop-Provider: Using OpenLoops
| Loading library: [...]
| Simulate: activating fixed-order NLO events
| RNG: Initializing RNG Stream random-number generator
| RNG: Setting seed for random-number generator to 3992
| Events: writing to ASCII file 'nlo_ppzj_sim_2_p1.debug'
| Events: generating 2 weighted, unpolarized events ...
| Events: event normalization mode 'sigma'
| ... event sample complete.
| Events: closing ASCII file 'nlo_ppzj_sim_2_p1.debug'
| WHIZARD run finished.
|=============================================================================|
Total number of regions: 150
alr || flst_real || i_real || em || mul || nreg || ftuples || flst_born || i_born
1 || [ -2, -2, 23, -2, -2] || 1 || 2 || 2 || 4 || {(1,4),(1,5),(2,4),(2,5)} || [ -2, 21, 23, -2] || 2
2 || [ -2, -2, 23, -2, -2] || 1 || 1 || 2 || 4 || {(1,4),(1,5),(2,4),(2,5)} || [ 21, -2, 23, -2] || 13
3 || [ -2, 2, 23, -2, 2] || 2 || 4 || 1 || 3 || {(1,4),(2,5),(4,5)} || [ -2, 2, 23, 21] || 1
4 || [ -2, 2, 23, -2, 2] || 2 || 2 || 1 || 3 || {(1,4),(2,5),(4,5)} || [ -2, 21, 23, -2] || 2
5 || [ -2, 2, 23, 2, -2] || 3 || 1 || 1 || 3 || {(1,5),(2,4),(4,5)} || [ 21, 2, 23, 2] || 14
6 || [ -2, 2, 23, -3, 3] || 4 || 4 || 1 || 1 || {(4,5)} || [ -2, 2, 23, 21] || 1
7 || [ -2, 2, 23, -1, 1] || 5 || 4 || 1 || 1 || {(4,5)} || [ -2, 2, 23, 21] || 1
8 || [ -2, 2, 23, 21, 21] || 6 || 4 || 1 || 3 || {(0,4),(0,5),(4,5)} || [ -2, 2, 23, 21] || 1
9 || [ -2, 2, 23, 21, 21] || 6 || 0 || 2 || 3 || {(0,4),(0,5),(4,5)} || [ -2, 2, 23, 21] || 1
10 || [ -2, -3, 23, -2, -3] || 7 || 2 || 1 || 2 || {(1,4),(2,5)} || [ -2, 21, 23, -2] || 2
11 || [ -2, -3, 23, -3, -2] || 8 || 1 || 1 || 2 || {(1,5),(2,4)} || [ 21, -3, 23, -3] || 15
12 || [ -2, -1, 23, -2, -1] || 9 || 2 || 1 || 2 || {(1,4),(2,5)} || [ -2, 21, 23, -2] || 2
13 || [ -2, -1, 23, -1, -2] || 10 || 1 || 1 || 2 || {(1,5),(2,4)} || [ 21, -1, 23, -1] || 16
14 || [ -2, 1, 23, -2, 1] || 11 || 2 || 1 || 2 || {(1,4),(2,5)} || [ -2, 21, 23, -2] || 2
15 || [ -2, 1, 23, 1, -2] || 12 || 1 || 1 || 2 || {(1,5),(2,4)} || [ 21, 1, 23, 1] || 17
16 || [ -2, 3, 23, -2, 3] || 13 || 2 || 1 || 2 || {(1,4),(2,5)} || [ -2, 21, 23, -2] || 2
17 || [ -2, 3, 23, 3, -2] || 14 || 1 || 1 || 2 || {(1,5),(2,4)} || [ 21, 3, 23, 3] || 18
18 || [ -2, 21, 23, 21, -2] || 15 || 2 || 1 || 3 || {(0,4),(2,5),(4,5)} || [ -2, 2, 23, 21] || 1
19 || [ -2, 21, 23, -2, 21] || 16 || 4 || 1 || 3 || {(0,5),(2,4),(4,5)} || [ -2, 21, 23, -2] || 2
20 || [ -2, 21, 23, -2, 21] || 16 || 0 || 1 || 3 || {(0,5),(2,4),(4,5)} || [ -2, 21, 23, -2] || 2
21 || [ 2, -2, 23, -2, 2] || 17 || 4 || 1 || 3 || {(1,5),(2,4),(4,5)} || [ 2, -2, 23, 21] || 3
22 || [ 2, -2, 23, 2, -2] || 18 || 2 || 1 || 3 || {(1,4),(2,5),(4,5)} || [ 2, 21, 23, 2] || 4
23 || [ 2, -2, 23, -2, 2] || 17 || 1 || 1 || 3 || {(1,5),(2,4),(4,5)} || [ 21, -2, 23, -2] || 13
24 || [ 2, -2, 23, -3, 3] || 19 || 4 || 1 || 1 || {(4,5)} || [ 2, -2, 23, 21] || 3
25 || [ 2, -2, 23, -1, 1] || 20 || 4 || 1 || 1 || {(4,5)} || [ 2, -2, 23, 21] || 3
26 || [ 2, -2, 23, 21, 21] || 21 || 4 || 1 || 3 || {(0,4),(0,5),(4,5)} || [ 2, -2, 23, 21] || 3
27 || [ 2, -2, 23, 21, 21] || 21 || 0 || 2 || 3 || {(0,4),(0,5),(4,5)} || [ 2, -2, 23, 21] || 3
28 || [ 2, 2, 23, 2, 2] || 22 || 2 || 2 || 4 || {(1,4),(1,5),(2,4),(2,5)} || [ 2, 21, 23, 2] || 4
29 || [ 2, 2, 23, 2, 2] || 22 || 1 || 2 || 4 || {(1,4),(1,5),(2,4),(2,5)} || [ 21, 2, 23, 2] || 14
30 || [ 2, -3, 23, 2, -3] || 23 || 2 || 1 || 2 || {(1,4),(2,5)} || [ 2, 21, 23, 2] || 4
31 || [ 2, -3, 23, -3, 2] || 24 || 1 || 1 || 2 || {(1,5),(2,4)} || [ 21, -3, 23, -3] || 15
32 || [ 2, -1, 23, 2, -1] || 25 || 2 || 1 || 2 || {(1,4),(2,5)} || [ 2, 21, 23, 2] || 4
33 || [ 2, -1, 23, -1, 2] || 26 || 1 || 1 || 2 || {(1,5),(2,4)} || [ 21, -1, 23, -1] || 16
34 || [ 2, 1, 23, 2, 1] || 27 || 2 || 1 || 2 || {(1,4),(2,5)} || [ 2, 21, 23, 2] || 4
35 || [ 2, 1, 23, 1, 2] || 28 || 1 || 1 || 2 || {(1,5),(2,4)} || [ 21, 1, 23, 1] || 17
36 || [ 2, 3, 23, 2, 3] || 29 || 2 || 1 || 2 || {(1,4),(2,5)} || [ 2, 21, 23, 2] || 4
37 || [ 2, 3, 23, 3, 2] || 30 || 1 || 1 || 2 || {(1,5),(2,4)} || [ 21, 3, 23, 3] || 18
38 || [ 2, 21, 23, 21, 2] || 31 || 2 || 1 || 3 || {(0,4),(2,5),(4,5)} || [ 2, -2, 23, 21] || 3
39 || [ 2, 21, 23, 2, 21] || 32 || 4 || 1 || 3 || {(0,5),(2,4),(4,5)} || [ 2, 21, 23, 2] || 4
40 || [ 2, 21, 23, 2, 21] || 32 || 0 || 1 || 3 || {(0,5),(2,4),(4,5)} || [ 2, 21, 23, 2] || 4
41 || [ -3, -2, 23, -3, -2] || 33 || 2 || 1 || 2 || {(1,4),(2,5)} || [ -3, 21, 23, -3] || 6
42 || [ -3, -2, 23, -2, -3] || 34 || 1 || 1 || 2 || {(1,5),(2,4)} || [ 21, -2, 23, -2] || 13
43 || [ -3, 2, 23, -3, 2] || 35 || 2 || 1 || 2 || {(1,4),(2,5)} || [ -3, 21, 23, -3] || 6
44 || [ -3, 2, 23, 2, -3] || 36 || 1 || 1 || 2 || {(1,5),(2,4)} || [ 21, 2, 23, 2] || 14
45 || [ -3, -3, 23, -3, -3] || 37 || 2 || 2 || 4 || {(1,4),(1,5),(2,4),(2,5)} || [ -3, 21, 23, -3] || 6
46 || [ -3, -3, 23, -3, -3] || 37 || 1 || 2 || 4 || {(1,4),(1,5),(2,4),(2,5)} || [ 21, -3, 23, -3] || 15
47 || [ -3, -1, 23, -3, -1] || 38 || 2 || 1 || 2 || {(1,4),(2,5)} || [ -3, 21, 23, -3] || 6
48 || [ -3, -1, 23, -1, -3] || 39 || 1 || 1 || 2 || {(1,5),(2,4)} || [ 21, -1, 23, -1] || 16
49 || [ -3, 1, 23, -3, 1] || 40 || 2 || 1 || 2 || {(1,4),(2,5)} || [ -3, 21, 23, -3] || 6
50 || [ -3, 1, 23, 1, -3] || 41 || 1 || 1 || 2 || {(1,5),(2,4)} || [ 21, 1, 23, 1] || 17
51 || [ -3, 3, 23, -2, 2] || 42 || 4 || 1 || 1 || {(4,5)} || [ -3, 3, 23, 21] || 5
52 || [ -3, 3, 23, -3, 3] || 43 || 4 || 1 || 3 || {(1,4),(2,5),(4,5)} || [ -3, 3, 23, 21] || 5
53 || [ -3, 3, 23, -3, 3] || 43 || 2 || 1 || 3 || {(1,4),(2,5),(4,5)} || [ -3, 21, 23, -3] || 6
54 || [ -3, 3, 23, 3, -3] || 44 || 1 || 1 || 3 || {(1,5),(2,4),(4,5)} || [ 21, 3, 23, 3] || 18
55 || [ -3, 3, 23, -1, 1] || 45 || 4 || 1 || 1 || {(4,5)} || [ -3, 3, 23, 21] || 5
56 || [ -3, 3, 23, 21, 21] || 46 || 4 || 1 || 3 || {(0,4),(0,5),(4,5)} || [ -3, 3, 23, 21] || 5
57 || [ -3, 3, 23, 21, 21] || 46 || 0 || 2 || 3 || {(0,4),(0,5),(4,5)} || [ -3, 3, 23, 21] || 5
58 || [ -3, 21, 23, 21, -3] || 47 || 2 || 1 || 3 || {(0,4),(2,5),(4,5)} || [ -3, 3, 23, 21] || 5
59 || [ -3, 21, 23, -3, 21] || 48 || 4 || 1 || 3 || {(0,5),(2,4),(4,5)} || [ -3, 21, 23, -3] || 6
60 || [ -3, 21, 23, -3, 21] || 48 || 0 || 1 || 3 || {(0,5),(2,4),(4,5)} || [ -3, 21, 23, -3] || 6
61 || [ -1, -2, 23, -1, -2] || 49 || 2 || 1 || 2 || {(1,4),(2,5)} || [ -1, 21, 23, -1] || 8
62 || [ -1, -2, 23, -2, -1] || 50 || 1 || 1 || 2 || {(1,5),(2,4)} || [ 21, -2, 23, -2] || 13
63 || [ -1, 2, 23, -1, 2] || 51 || 2 || 1 || 2 || {(1,4),(2,5)} || [ -1, 21, 23, -1] || 8
64 || [ -1, 2, 23, 2, -1] || 52 || 1 || 1 || 2 || {(1,5),(2,4)} || [ 21, 2, 23, 2] || 14
65 || [ -1, -3, 23, -1, -3] || 53 || 2 || 1 || 2 || {(1,4),(2,5)} || [ -1, 21, 23, -1] || 8
66 || [ -1, -3, 23, -3, -1] || 54 || 1 || 1 || 2 || {(1,5),(2,4)} || [ 21, -3, 23, -3] || 15
67 || [ -1, -1, 23, -1, -1] || 55 || 2 || 2 || 4 || {(1,4),(1,5),(2,4),(2,5)} || [ -1, 21, 23, -1] || 8
68 || [ -1, -1, 23, -1, -1] || 55 || 1 || 2 || 4 || {(1,4),(1,5),(2,4),(2,5)} || [ 21, -1, 23, -1] || 16
69 || [ -1, 1, 23, -2, 2] || 56 || 4 || 1 || 1 || {(4,5)} || [ -1, 1, 23, 21] || 7
70 || [ -1, 1, 23, -3, 3] || 57 || 4 || 1 || 1 || {(4,5)} || [ -1, 1, 23, 21] || 7
71 || [ -1, 1, 23, -1, 1] || 58 || 4 || 1 || 3 || {(1,4),(2,5),(4,5)} || [ -1, 1, 23, 21] || 7
72 || [ -1, 1, 23, -1, 1] || 58 || 2 || 1 || 3 || {(1,4),(2,5),(4,5)} || [ -1, 21, 23, -1] || 8
73 || [ -1, 1, 23, 1, -1] || 59 || 1 || 1 || 3 || {(1,5),(2,4),(4,5)} || [ 21, 1, 23, 1] || 17
74 || [ -1, 1, 23, 21, 21] || 60 || 4 || 1 || 3 || {(0,4),(0,5),(4,5)} || [ -1, 1, 23, 21] || 7
75 || [ -1, 1, 23, 21, 21] || 60 || 0 || 2 || 3 || {(0,4),(0,5),(4,5)} || [ -1, 1, 23, 21] || 7
76 || [ -1, 3, 23, -1, 3] || 61 || 2 || 1 || 2 || {(1,4),(2,5)} || [ -1, 21, 23, -1] || 8
77 || [ -1, 3, 23, 3, -1] || 62 || 1 || 1 || 2 || {(1,5),(2,4)} || [ 21, 3, 23, 3] || 18
78 || [ -1, 21, 23, 21, -1] || 63 || 2 || 1 || 3 || {(0,4),(2,5),(4,5)} || [ -1, 1, 23, 21] || 7
79 || [ -1, 21, 23, -1, 21] || 64 || 4 || 1 || 3 || {(0,5),(2,4),(4,5)} || [ -1, 21, 23, -1] || 8
80 || [ -1, 21, 23, -1, 21] || 64 || 0 || 1 || 3 || {(0,5),(2,4),(4,5)} || [ -1, 21, 23, -1] || 8
81 || [ 1, -2, 23, 1, -2] || 65 || 2 || 1 || 2 || {(1,4),(2,5)} || [ 1, 21, 23, 1] || 10
82 || [ 1, -2, 23, -2, 1] || 66 || 1 || 1 || 2 || {(1,5),(2,4)} || [ 21, -2, 23, -2] || 13
83 || [ 1, 2, 23, 1, 2] || 67 || 2 || 1 || 2 || {(1,4),(2,5)} || [ 1, 21, 23, 1] || 10
84 || [ 1, 2, 23, 2, 1] || 68 || 1 || 1 || 2 || {(1,5),(2,4)} || [ 21, 2, 23, 2] || 14
85 || [ 1, -3, 23, 1, -3] || 69 || 2 || 1 || 2 || {(1,4),(2,5)} || [ 1, 21, 23, 1] || 10
86 || [ 1, -3, 23, -3, 1] || 70 || 1 || 1 || 2 || {(1,5),(2,4)} || [ 21, -3, 23, -3] || 15
87 || [ 1, -1, 23, -2, 2] || 71 || 4 || 1 || 1 || {(4,5)} || [ 1, -1, 23, 21] || 9
88 || [ 1, -1, 23, -3, 3] || 72 || 4 || 1 || 1 || {(4,5)} || [ 1, -1, 23, 21] || 9
89 || [ 1, -1, 23, -1, 1] || 73 || 4 || 1 || 3 || {(1,5),(2,4),(4,5)} || [ 1, -1, 23, 21] || 9
90 || [ 1, -1, 23, 1, -1] || 74 || 2 || 1 || 3 || {(1,4),(2,5),(4,5)} || [ 1, 21, 23, 1] || 10
91 || [ 1, -1, 23, -1, 1] || 73 || 1 || 1 || 3 || {(1,5),(2,4),(4,5)} || [ 21, -1, 23, -1] || 16
92 || [ 1, -1, 23, 21, 21] || 75 || 4 || 1 || 3 || {(0,4),(0,5),(4,5)} || [ 1, -1, 23, 21] || 9
93 || [ 1, -1, 23, 21, 21] || 75 || 0 || 2 || 3 || {(0,4),(0,5),(4,5)} || [ 1, -1, 23, 21] || 9
94 || [ 1, 1, 23, 1, 1] || 76 || 2 || 2 || 4 || {(1,4),(1,5),(2,4),(2,5)} || [ 1, 21, 23, 1] || 10
95 || [ 1, 1, 23, 1, 1] || 76 || 1 || 2 || 4 || {(1,4),(1,5),(2,4),(2,5)} || [ 21, 1, 23, 1] || 17
96 || [ 1, 3, 23, 1, 3] || 77 || 2 || 1 || 2 || {(1,4),(2,5)} || [ 1, 21, 23, 1] || 10
97 || [ 1, 3, 23, 3, 1] || 78 || 1 || 1 || 2 || {(1,5),(2,4)} || [ 21, 3, 23, 3] || 18
98 || [ 1, 21, 23, 21, 1] || 79 || 2 || 1 || 3 || {(0,4),(2,5),(4,5)} || [ 1, -1, 23, 21] || 9
99 || [ 1, 21, 23, 1, 21] || 80 || 4 || 1 || 3 || {(0,5),(2,4),(4,5)} || [ 1, 21, 23, 1] || 10
100 || [ 1, 21, 23, 1, 21] || 80 || 0 || 1 || 3 || {(0,5),(2,4),(4,5)} || [ 1, 21, 23, 1] || 10
101 || [ 3, -2, 23, 3, -2] || 81 || 2 || 1 || 2 || {(1,4),(2,5)} || [ 3, 21, 23, 3] || 12
102 || [ 3, -2, 23, -2, 3] || 82 || 1 || 1 || 2 || {(1,5),(2,4)} || [ 21, -2, 23, -2] || 13
103 || [ 3, 2, 23, 3, 2] || 83 || 2 || 1 || 2 || {(1,4),(2,5)} || [ 3, 21, 23, 3] || 12
104 || [ 3, 2, 23, 2, 3] || 84 || 1 || 1 || 2 || {(1,5),(2,4)} || [ 21, 2, 23, 2] || 14
105 || [ 3, -3, 23, -2, 2] || 85 || 4 || 1 || 1 || {(4,5)} || [ 3, -3, 23, 21] || 11
106 || [ 3, -3, 23, -3, 3] || 86 || 4 || 1 || 3 || {(1,5),(2,4),(4,5)} || [ 3, -3, 23, 21] || 11
107 || [ 3, -3, 23, 3, -3] || 87 || 2 || 1 || 3 || {(1,4),(2,5),(4,5)} || [ 3, 21, 23, 3] || 12
108 || [ 3, -3, 23, -3, 3] || 86 || 1 || 1 || 3 || {(1,5),(2,4),(4,5)} || [ 21, -3, 23, -3] || 15
109 || [ 3, -3, 23, -1, 1] || 88 || 4 || 1 || 1 || {(4,5)} || [ 3, -3, 23, 21] || 11
110 || [ 3, -3, 23, 21, 21] || 89 || 4 || 1 || 3 || {(0,4),(0,5),(4,5)} || [ 3, -3, 23, 21] || 11
111 || [ 3, -3, 23, 21, 21] || 89 || 0 || 2 || 3 || {(0,4),(0,5),(4,5)} || [ 3, -3, 23, 21] || 11
112 || [ 3, -1, 23, 3, -1] || 90 || 2 || 1 || 2 || {(1,4),(2,5)} || [ 3, 21, 23, 3] || 12
113 || [ 3, -1, 23, -1, 3] || 91 || 1 || 1 || 2 || {(1,5),(2,4)} || [ 21, -1, 23, -1] || 16
114 || [ 3, 1, 23, 3, 1] || 92 || 2 || 1 || 2 || {(1,4),(2,5)} || [ 3, 21, 23, 3] || 12
115 || [ 3, 1, 23, 1, 3] || 93 || 1 || 1 || 2 || {(1,5),(2,4)} || [ 21, 1, 23, 1] || 17
116 || [ 3, 3, 23, 3, 3] || 94 || 2 || 2 || 4 || {(1,4),(1,5),(2,4),(2,5)} || [ 3, 21, 23, 3] || 12
117 || [ 3, 3, 23, 3, 3] || 94 || 1 || 2 || 4 || {(1,4),(1,5),(2,4),(2,5)} || [ 21, 3, 23, 3] || 18
118 || [ 3, 21, 23, 21, 3] || 95 || 2 || 1 || 3 || {(0,4),(2,5),(4,5)} || [ 3, -3, 23, 21] || 11
119 || [ 3, 21, 23, 3, 21] || 96 || 4 || 1 || 3 || {(0,5),(2,4),(4,5)} || [ 3, 21, 23, 3] || 12
120 || [ 3, 21, 23, 3, 21] || 96 || 0 || 1 || 3 || {(0,5),(2,4),(4,5)} || [ 3, 21, 23, 3] || 12
121 || [ 21, -2, 23, 21, -2] || 97 || 1 || 1 || 3 || {(0,4),(1,5),(4,5)} || [ 2, -2, 23, 21] || 3
122 || [ 21, -2, 23, -2, 21] || 98 || 4 || 1 || 3 || {(0,5),(1,4),(4,5)} || [ 21, -2, 23, -2] || 13
123 || [ 21, -2, 23, -2, 21] || 98 || 0 || 1 || 3 || {(0,5),(1,4),(4,5)} || [ 21, -2, 23, -2] || 13
124 || [ 21, 2, 23, 21, 2] || 99 || 1 || 1 || 3 || {(0,4),(1,5),(4,5)} || [ -2, 2, 23, 21] || 1
125 || [ 21, 2, 23, 2, 21] || 100 || 4 || 1 || 3 || {(0,5),(1,4),(4,5)} || [ 21, 2, 23, 2] || 14
126 || [ 21, 2, 23, 2, 21] || 100 || 0 || 1 || 3 || {(0,5),(1,4),(4,5)} || [ 21, 2, 23, 2] || 14
127 || [ 21, -3, 23, 21, -3] || 101 || 1 || 1 || 3 || {(0,4),(1,5),(4,5)} || [ 3, -3, 23, 21] || 11
128 || [ 21, -3, 23, -3, 21] || 102 || 4 || 1 || 3 || {(0,5),(1,4),(4,5)} || [ 21, -3, 23, -3] || 15
129 || [ 21, -3, 23, -3, 21] || 102 || 0 || 1 || 3 || {(0,5),(1,4),(4,5)} || [ 21, -3, 23, -3] || 15
130 || [ 21, -1, 23, 21, -1] || 103 || 1 || 1 || 3 || {(0,4),(1,5),(4,5)} || [ 1, -1, 23, 21] || 9
131 || [ 21, -1, 23, -1, 21] || 104 || 4 || 1 || 3 || {(0,5),(1,4),(4,5)} || [ 21, -1, 23, -1] || 16
132 || [ 21, -1, 23, -1, 21] || 104 || 0 || 1 || 3 || {(0,5),(1,4),(4,5)} || [ 21, -1, 23, -1] || 16
133 || [ 21, 1, 23, 21, 1] || 105 || 1 || 1 || 3 || {(0,4),(1,5),(4,5)} || [ -1, 1, 23, 21] || 7
134 || [ 21, 1, 23, 1, 21] || 106 || 4 || 1 || 3 || {(0,5),(1,4),(4,5)} || [ 21, 1, 23, 1] || 17
135 || [ 21, 1, 23, 1, 21] || 106 || 0 || 1 || 3 || {(0,5),(1,4),(4,5)} || [ 21, 1, 23, 1] || 17
136 || [ 21, 3, 23, 21, 3] || 107 || 1 || 1 || 3 || {(0,4),(1,5),(4,5)} || [ -3, 3, 23, 21] || 5
137 || [ 21, 3, 23, 3, 21] || 108 || 4 || 1 || 3 || {(0,5),(1,4),(4,5)} || [ 21, 3, 23, 3] || 18
138 || [ 21, 3, 23, 3, 21] || 108 || 0 || 1 || 3 || {(0,5),(1,4),(4,5)} || [ 21, 3, 23, 3] || 18
139 || [ 21, 21, 23, -2, 2] || 109 || 1 || 1 || 4 || {(1,4),(1,5),(2,4),(2,5)} || [ -2, 21, 23, -2] || 2
140 || [ 21, 21, 23, 2, -2] || 110 || 1 || 1 || 4 || {(1,4),(1,5),(2,4),(2,5)} || [ 2, 21, 23, 2] || 4
141 || [ 21, 21, 23, -2, 2] || 109 || 2 || 1 || 4 || {(1,4),(1,5),(2,4),(2,5)} || [ 21, -2, 23, -2] || 13
142 || [ 21, 21, 23, 2, -2] || 110 || 2 || 1 || 4 || {(1,4),(1,5),(2,4),(2,5)} || [ 21, 2, 23, 2] || 14
143 || [ 21, 21, 23, -3, 3] || 111 || 1 || 1 || 4 || {(1,4),(1,5),(2,4),(2,5)} || [ -3, 21, 23, -3] || 6
144 || [ 21, 21, 23, 3, -3] || 112 || 1 || 1 || 4 || {(1,4),(1,5),(2,4),(2,5)} || [ 3, 21, 23, 3] || 12
145 || [ 21, 21, 23, -3, 3] || 111 || 2 || 1 || 4 || {(1,4),(1,5),(2,4),(2,5)} || [ 21, -3, 23, -3] || 15
146 || [ 21, 21, 23, 3, -3] || 112 || 2 || 1 || 4 || {(1,4),(1,5),(2,4),(2,5)} || [ 21, 3, 23, 3] || 18
147 || [ 21, 21, 23, -1, 1] || 113 || 1 || 1 || 4 || {(1,4),(1,5),(2,4),(2,5)} || [ -1, 21, 23, -1] || 8
148 || [ 21, 21, 23, 1, -1] || 114 || 1 || 1 || 4 || {(1,4),(1,5),(2,4),(2,5)} || [ 1, 21, 23, 1] || 10
149 || [ 21, 21, 23, -1, 1] || 113 || 2 || 1 || 4 || {(1,4),(1,5),(2,4),(2,5)} || [ 21, -1, 23, -1] || 16
150 || [ 21, 21, 23, 1, -1] || 114 || 2 || 1 || 4 || {(1,4),(1,5),(2,4),(2,5)} || [ 21, 1, 23, 1] || 17
------------------------------------------------------------------------
Contents of nlo_ppzj_sim_2_p1.debug:
========================================================================
Event #1
------------------------------------------------------------------------
Unweighted = F
Normalization = 'sigma'
Helicity handling = drop
Keep correlations = F
------------------------------------------------------------------------
Squared matrix el. (ref) = 4.33883E-04
Squared matrix el. (prc) = 4.33883E-04
Event weight (ref) = 1.19663E-02
Event weight (prc) = 1.19663E-02
------------------------------------------------------------------------
Selected MCI group = 3
Selected term = 7
Selected channel = 2
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_2_p1'
RNG Stream generator
Current position = [
3270494107.0, 1218490942.0, 3220277207.0,
2821320218.0, 4220147848.0, 1218259235.0,
]
Beginning substream = [
4226523048.0, 3065015250.0, 1182429328.0,
1392969535.0, 3625333239.0, 3251691171.0,
]
Initial stream = [
4226523048.0, 3065015250.0, 1182429328.0,
1392969535.0, 3625333239.0, 3251691171.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-1)
E = 1.568458E+03
P = 0.000000E+00 0.000000E+00 1.568458E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(1)
E = 5.319254E+03
P = 0.000000E+00 0.000000E+00 -5.319254E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 4.931542E+03
P = 0.000000E+00 0.000000E+00 4.931542E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 1.180746E+03
P = 0.000000E+00 0.000000E+00 -1.180746E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 5.266905E+03
P = -5.326147E+02 -4.229092E+02 -5.222015E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 1.620807E+03
P = 5.326147E+02 4.229092E+02 1.471219E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_2_p1'
RNG Stream generator
Current position = [
870276730.0, 1525774502.0, 3988227742.0,
3787208568.0, 2984262882.0, 2541051477.0,
]
Beginning substream = [
3013866238.0, 581103679.0, 3358998661.0,
3484764854.0, 532756457.0, 2693721620.0,
]
Initial stream = [
3013866238.0, 581103679.0, 3358998661.0,
3484764854.0, 532756457.0, 2693721620.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 1.568458E+03
P = 0.000000E+00 0.000000E+00 1.568458E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 5.319254E+03
P = 0.000000E+00 0.000000E+00 -5.319254E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 4.931542E+03
P = 0.000000E+00 0.000000E+00 4.931542E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 1.180746E+03
P = 0.000000E+00 0.000000E+00 -1.180746E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 5.266905E+03
P = -5.326147E+02 -4.229092E+02 -5.222015E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 1.620807E+03
P = 5.326147E+02 4.229092E+02 1.471219E+03
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 0.000000000E+00
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 1.568458E+03
P = 0.000000E+00 0.000000E+00 1.568458E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 5.319254E+03
P = 0.000000E+00 0.000000E+00 -5.319254E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 4.931542E+03
P = 0.000000E+00 0.000000E+00 4.931542E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 1.180746E+03
P = 0.000000E+00 0.000000E+00 -1.180746E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 5.266905E+03
P = -5.326147E+02 -4.229092E+02 -5.222015E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 1.620807E+03
P = 5.326147E+02 4.229092E+02 1.471219E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 5.77686E+03
n_in* => 2
n_out* => 4
n_tot* => 6
$process_id* => "nlo_ppzj_sim_2_p1"
process_num_id* => [unknown integer]
sqme* => 4.33883E-04
sqme_ref* => 4.33883E-04
event_index* => 1
event_weight* => 1.19663E-02
event_weight_ref* => 1.19663E-02
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:-2|-1.5684580E+03; 0.0000000E+00, 0.0000000E+00,-1.5684580E+03| 0.0000000E+00| 3)
4 prt(i:2|-5.3192539E+03; 0.0000000E+00, 0.0000000E+00, 5.3192539E+03| 0.0000000E+00| 4)
5 prt(o:92| 4.9315420E+03; 0.0000000E+00, 0.0000000E+00, 4.9315420E+03| 0.0000000E+00| 5)
6 prt(o:-92| 1.1807461E+03; 0.0000000E+00, 0.0000000E+00,-1.1807461E+03| 0.0000000E+00| 6)
7 prt(o:23| 5.2669048E+03;-5.3261469E+02,-4.2290925E+02,-5.2220149E+03| 8.3152513E+03| 7)
8 prt(o:21| 1.6208072E+03; 5.3261469E+02, 4.2290925E+02, 1.4712190E+03| 0.0000000E+00| 8)
========================================================================
========================================================================
Event #2
------------------------------------------------------------------------
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 = 3
Selected term = 7
Selected channel = 2
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_2_p1'
RNG Stream generator
Current position = [
1817174340.0, 4169406181.0, 394187331.0,
860033000.0, 2212227538.0, 3653581942.0,
]
Beginning substream = [
4226523048.0, 3065015250.0, 1182429328.0,
1392969535.0, 3625333239.0, 3251691171.0,
]
Initial stream = [
4226523048.0, 3065015250.0, 1182429328.0,
1392969535.0, 3625333239.0, 3251691171.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 1.899352E+03
P = 0.000000E+00 0.000000E+00 1.899352E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(21)
E = 3.183072E+03
P = 0.000000E+00 0.000000E+00 -3.183072E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 4.600648E+03
P = 0.000000E+00 0.000000E+00 4.600648E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(93*)
E = 3.316928E+03
P = 0.000000E+00 0.000000E+00 -3.316928E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 3.183710E+03
P = 1.224589E+01 1.141052E+01 -3.182360E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 1.898713E+03
P = -1.224589E+01 -1.141052E+01 1.898640E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_2_p1'
RNG Stream generator
Current position = [
976955966.0, 3946182281.0, 2474115998.0,
1111192673.0, 3759619853.0, 3640289132.0,
]
Beginning substream = [
3013866238.0, 581103679.0, 3358998661.0,
3484764854.0, 532756457.0, 2693721620.0,
]
Initial stream = [
3013866238.0, 581103679.0, 3358998661.0,
3484764854.0, 532756457.0, 2693721620.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 1.899352E+03
P = 0.000000E+00 0.000000E+00 1.899352E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 3.183072E+03
P = 0.000000E+00 0.000000E+00 -3.183072E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 4.600648E+03
P = 0.000000E+00 0.000000E+00 4.600648E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 3.316928E+03
P = 0.000000E+00 0.000000E+00 -3.316928E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 3.183710E+03
P = 1.224589E+01 1.141052E+01 -3.182360E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 1.898713E+03
P = -1.224589E+01 -1.141052E+01 1.898640E+03
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 0.000000000E+00
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 1.899352E+03
P = 0.000000E+00 0.000000E+00 1.899352E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 3.183072E+03
P = 0.000000E+00 0.000000E+00 -3.183072E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 4.600648E+03
P = 0.000000E+00 0.000000E+00 4.600648E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 3.316928E+03
P = 0.000000E+00 0.000000E+00 -3.316928E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 3.183710E+03
P = 1.224589E+01 1.141052E+01 -3.182360E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 1.898713E+03
P = -1.224589E+01 -1.141052E+01 1.898640E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 4.91763E+03
n_in* => 2
n_out* => 4
n_tot* => 6
$process_id* => "nlo_ppzj_sim_2_p1"
process_num_id* => [unknown integer]
sqme* => 0.00000E+00
sqme_ref* => 0.00000E+00
event_index* => 2
event_weight* => 0.00000E+00
event_weight_ref* => 0.00000E+00
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:-2|-1.8993516E+03; 0.0000000E+00, 0.0000000E+00,-1.8993516E+03| 0.0000000E+00| 3)
4 prt(i:2|-3.1830721E+03; 0.0000000E+00, 0.0000000E+00, 3.1830721E+03| 0.0000000E+00| 4)
5 prt(o:92| 4.6006484E+03; 0.0000000E+00, 0.0000000E+00, 4.6006484E+03| 0.0000000E+00| 5)
6 prt(o:-92| 3.3169279E+03; 0.0000000E+00, 0.0000000E+00,-3.3169279E+03| 0.0000000E+00| 6)
7 prt(o:23| 3.1837103E+03; 1.2245890E+01, 1.1410517E+01,-3.1823601E+03| 8.3152513E+03| 7)
8 prt(o:21| 1.8987134E+03;-1.2245890E+01,-1.1410517E+01, 1.8986396E+03| 0.0000000E+00| 8)
========================================================================
Index: trunk/share/tests/ext_tests_nlo/ref-output/nlo_eettwjj.ref
===================================================================
--- trunk/share/tests/ext_tests_nlo/ref-output/nlo_eettwjj.ref (revision 8482)
+++ trunk/share/tests/ext_tests_nlo/ref-output/nlo_eettwjj.ref (revision 8483)
@@ -1,170 +1,172 @@
?openmp_logging = false
?vis_history = false
?integration_timer = false
openmp_num_threads = 1
?debug_decay = false
?debug_process = false
?debug_verbose = false
?write_raw = false
| Switching to model 'SM', scheme 'GF_MW_MZ'
$blha_ew_scheme = "alpha_qed"
SM.mZ => 9.118800000000E+01
SM.mW => 8.041900200000E+01
SM.mH => 1.250000000000E+02
SM.GF => 1.166390000000E-05
SM.wZ => 0.000000000000E+00
SM.wtop => 0.000000000000E+00
SM.wW => 0.000000000000E+00
SM.wH => 0.000000000000E+00
SM.ms => 0.000000000000E+00
SM.mc => 0.000000000000E+00
SM.mb => 0.000000000000E+00
SM.mtop => 1.732000000000E+02
SM.me => 0.000000000000E+00
SM.mmu => 0.000000000000E+00
SM.mtau => 1.777000000000E+00
SM.alphas => 1.180000000000E-01
?alphas_is_fixed = false
?alphas_from_mz = true
?alphas_from_lambda_qcd = false
alphas_nf = 5
alphas_order = 2
[user variable] jet = PDG(2, -2, 1, -1, 3, -3, 4, -4, 5, -5, 21)
$exclude_gauge_splittings = "t"
$method = "openloops"
seed = 8131
sqrts = 1.000000000000E+03
jet_algorithm = 2
jet_r = 5.000000000000E-01
-?use_vamp_equivalences = false
$integration_method = "vamp2"
$rng_method = "rng_stream"
| End of included 'nlo_settings.sin'
alpha_power = 3
alphas_power = 2
[user variable] W = PDG(24, -24)
mult_call_real = 2.000000000000E+00
| Process library 'nlo_eettwjj_lib': recorded process 'nlo_eettwjj_p1'
| Integrate: current process library needs compilation
| Process library 'nlo_eettwjj_lib': compiling ...
| Process library 'nlo_eettwjj_lib': writing makefile
| Process library 'nlo_eettwjj_lib': removing old files
| Process library 'nlo_eettwjj_lib': writing driver
| Process library 'nlo_eettwjj_lib': creating source code
| Process library 'nlo_eettwjj_lib': compiling sources
| Process library 'nlo_eettwjj_lib': linking
| Process library 'nlo_eettwjj_lib': loading
| Process library 'nlo_eettwjj_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 8131
| Initializing integration for process nlo_eettwjj_p1:
| Beam structure: [any particles]
| Beam data (collision):
| e- (mass = 0.0000000E+00 GeV)
| e+ (mass = 0.0000000E+00 GeV)
| sqrts = 1.000000000000E+03 GeV
| Phase space: generating configuration ...
Warning: Intermediate decay of zero-width particle W+ may be possible.
Warning: Intermediate decay of zero-width particle Z may be possible.
Warning: Intermediate decay of zero-width particle H may be possible.
Warning: Intermediate decay of zero-width particle W- may be possible.
| Phase space: ... success.
| Phase space: writing configuration file 'nlo_eettwjj_p1.i1.phs'
| Phase space: generating configuration ...
| Phase space: ... success.
| Phase space: writing configuration file 'nlo_eettwjj_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: [...]
| 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]: 'nlo_eettwjj_p1'
| Library name = 'nlo_eettwjj_lib'
| Process index = 1
| Process components:
| 1: 'nlo_eettwjj_p1_i1': e-, e+ => t, tbar, W+:W-, u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl, u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl [openloops]
| 2: 'nlo_eettwjj_p1_i2': e-, e+ => t, tbar, W+:W-, d:dbar:u:ubar:s:sbar:c:cbar:b:bbar:gl, d:dbar:u:ubar:s:sbar:c:cbar:b:bbar:gl, d:dbar:u:ubar:s:sbar:c:cbar:b:bbar:gl [openloops], [real]
| 3: 'nlo_eettwjj_p1_i3': e-, e+ => t, tbar, W+:W-, u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl, u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl [openloops], [virtual]
| 4: 'nlo_eettwjj_p1_i4': e-, e+ => t, tbar, W+:W-, u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl, u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl [inactive], [subtraction]
| ------------------------------------------------------------------------
| Phase space: 4 channels, 11 dimensions
| Phase space: found 4 channels, collected in 1 grove.
-| Phase space: no equivalences between channels used.
+| Phase space: Using 4 equivalences between channels.
| Phase space: wood
| Phase space: 4 channels, 14 dimensions
| Phase space: found 4 channels, collected in 1 grove.
-| Phase space: no equivalences between channels used.
+| Phase space: Using 4 equivalences between channels.
| Phase space: wood
| Phase space: 4 channels, 11 dimensions
| Phase space: found 4 channels, collected in 1 grove.
-| Phase space: no equivalences between channels used.
+| Phase space: Using 4 equivalences between channels.
| Phase space: wood
| Applying user-defined cuts.
| Using user-defined general scale.
| Starting integration for process 'nlo_eettwjj_p1' part 'born'
| Integrate: iterations = 1:100:"gw"
| Integrator: 1 chains, 4 channels, 11 dimensions
+| Integrator: Using VAMP2 channel equivalences
| 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 'nlo_eettwjj_p1.m1.vg2'.
| VAMP2: set chain: use chained weights.
1 100 7.2691124E-05 7.38E-05 101.49 10.15* 4.00
|-----------------------------------------------------------------------------|
1 100 7.2691124E-05 7.38E-05 101.49 10.15 4.00
|=============================================================================|
| Starting integration for process 'nlo_eettwjj_p1' part 'real'
| Integrate: iterations = 1:200:"gw"
| Integrator: 1 chains, 4 channels, 14 dimensions
+| Integrator: Using VAMP2 channel equivalences
| Integrator: 200 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 'nlo_eettwjj_p1.m2.vg2'.
| VAMP2: set chain: use chained weights.
1 200 -6.7419305E-05 2.46E-04 364.49 51.55* 2.02
|-----------------------------------------------------------------------------|
1 200 -6.7419305E-05 2.46E-04 364.49 51.55 2.02
|=============================================================================|
| Starting integration for process 'nlo_eettwjj_p1' part 'virtual'
| Integrate: iterations = 1:100:"gw"
| Integrator: 1 chains, 4 channels, 11 dimensions
+| Integrator: Using VAMP2 channel equivalences
| 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 'nlo_eettwjj_p1.m3.vg2'.
| VAMP2: set chain: use chained weights.
1 100 4.5824693E-03 4.65E-03 101.41 10.14* 4.00
|-----------------------------------------------------------------------------|
1 100 4.5824693E-03 4.65E-03 101.41 10.14 4.00
|=============================================================================|
| Integrate: sum of all components
|=============================================================================|
| It Calls Integral[fb] Error[fb] Err[%] Acc Eff[%] Chi2 N[It] |
|=============================================================================|
1 0 4.5877411E-03 4.65E-03 101.45 0.00* 3.94
| NLO Correction: [O(alpha_s+1)/O(alpha_s)]
| (******** +- ********* ) %
|=============================================================================|
| There were no errors and 4 warning(s).
| WHIZARD run finished.
|=============================================================================|
Index: trunk/share/tests/ext_tests_nlo/ref-output/nlo_eejj.ref
===================================================================
--- trunk/share/tests/ext_tests_nlo/ref-output/nlo_eejj.ref (revision 8482)
+++ trunk/share/tests/ext_tests_nlo/ref-output/nlo_eejj.ref (revision 8483)
@@ -1,166 +1,168 @@
?openmp_logging = false
?vis_history = false
?integration_timer = false
openmp_num_threads = 1
?debug_decay = false
?debug_process = false
?debug_verbose = false
?write_raw = false
| Switching to model 'SM', scheme 'GF_MW_MZ'
$blha_ew_scheme = "alpha_qed"
SM.mZ => 9.118800000000E+01
SM.mW => 8.041900200000E+01
SM.mH => 1.250000000000E+02
SM.GF => 1.166390000000E-05
SM.wZ => 0.000000000000E+00
SM.wtop => 0.000000000000E+00
SM.wW => 0.000000000000E+00
SM.wH => 0.000000000000E+00
SM.ms => 0.000000000000E+00
SM.mc => 0.000000000000E+00
SM.mb => 0.000000000000E+00
SM.mtop => 1.732000000000E+02
SM.me => 0.000000000000E+00
SM.mmu => 0.000000000000E+00
SM.mtau => 1.777000000000E+00
SM.alphas => 1.180000000000E-01
?alphas_is_fixed = false
?alphas_from_mz = true
?alphas_from_lambda_qcd = false
alphas_nf = 5
alphas_order = 2
[user variable] jet = PDG(2, -2, 1, -1, 3, -3, 4, -4, 5, -5, 21)
$exclude_gauge_splittings = "t"
$method = "openloops"
seed = 8131
sqrts = 1.000000000000E+03
jet_algorithm = 2
jet_r = 5.000000000000E-01
-?use_vamp_equivalences = false
$integration_method = "vamp2"
$rng_method = "rng_stream"
| End of included 'nlo_settings.sin'
alpha_power = 2
alphas_power = 0
| Process library 'nlo_eejj_lib': recorded process 'nlo_eejj_p1'
| Integrate: current process library needs compilation
| Process library 'nlo_eejj_lib': compiling ...
| Process library 'nlo_eejj_lib': writing makefile
| Process library 'nlo_eejj_lib': removing old files
| Process library 'nlo_eejj_lib': writing driver
| Process library 'nlo_eejj_lib': creating source code
| Process library 'nlo_eejj_lib': compiling sources
| Process library 'nlo_eejj_lib': linking
| Process library 'nlo_eejj_lib': loading
| Process library 'nlo_eejj_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 8131
| Initializing integration for process nlo_eejj_p1:
| Beam structure: [any particles]
| Beam data (collision):
| e- (mass = 0.0000000E+00 GeV)
| e+ (mass = 0.0000000E+00 GeV)
| sqrts = 1.000000000000E+03 GeV
| Phase space: generating configuration ...
Warning: Intermediate decay of zero-width particle Z may be possible.
Warning: Intermediate decay of zero-width particle H may be possible.
| Phase space: ... success.
| Phase space: writing configuration file 'nlo_eejj_p1.i1.phs'
| Phase space: generating configuration ...
| Phase space: ... success.
| Phase space: writing configuration file 'nlo_eejj_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: [...]
| 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]: 'nlo_eejj_p1'
| Library name = 'nlo_eejj_lib'
| Process index = 1
| Process components:
| 1: 'nlo_eejj_p1_i1': e-, e+ => u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl, u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl [openloops]
| 2: 'nlo_eejj_p1_i2': e-, e+ => d:dbar:u:ubar:s:sbar:c:cbar:b:bbar:gl, d:dbar:u:ubar:s:sbar:c:cbar:b:bbar:gl, d:dbar:u:ubar:s:sbar:c:cbar:b:bbar:gl [openloops], [real]
| 3: 'nlo_eejj_p1_i3': e-, e+ => u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl, u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl [openloops], [virtual]
| 4: 'nlo_eejj_p1_i4': e-, e+ => u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl, u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl [inactive], [subtraction]
| ------------------------------------------------------------------------
| Phase space: 1 channels, 2 dimensions
| Phase space: found 1 channel, collected in 1 grove.
-| Phase space: no equivalences between channels used.
+| Phase space: Using 1 equivalence between channels.
| Phase space: wood
| Phase space: 1 channels, 5 dimensions
| Phase space: found 1 channel, collected in 1 grove.
-| Phase space: no equivalences between channels used.
+| Phase space: Using 1 equivalence between channels.
| Phase space: wood
| Phase space: 1 channels, 2 dimensions
| Phase space: found 1 channel, collected in 1 grove.
-| Phase space: no equivalences between channels used.
+| Phase space: Using 1 equivalence between channels.
| Phase space: wood
| Applying user-defined cuts.
| Using user-defined general scale.
| Starting integration for process 'nlo_eejj_p1' part 'born'
| Integrate: iterations = 1:100:"gw"
| Integrator: 1 chains, 1 channels, 2 dimensions
+| Integrator: Using VAMP2 channel equivalences
| 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 'nlo_eejj_p1.m1.vg2'.
| VAMP2: set chain: use chained weights.
1 98 6.2062491E+02 5.03E+00 0.81 0.08* 37.53
|-----------------------------------------------------------------------------|
1 98 6.2062491E+02 5.03E+00 0.81 0.08 37.53
|=============================================================================|
| Starting integration for process 'nlo_eejj_p1' part 'real'
| Integrate: iterations = 1:100:"gw"
| Integrator: 1 chains, 1 channels, 5 dimensions
+| Integrator: Using VAMP2 channel equivalences
| 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 'nlo_eejj_p1.m2.vg2'.
| VAMP2: set chain: use chained weights.
1 96 3.2589839E+01 6.75E+00 20.71 2.03* 8.16
|-----------------------------------------------------------------------------|
1 96 3.2589839E+01 6.75E+00 20.71 2.03 8.16
|=============================================================================|
| Starting integration for process 'nlo_eejj_p1' part 'virtual'
| Integrate: iterations = 1:100:"gw"
| Integrator: 1 chains, 1 channels, 2 dimensions
+| Integrator: Using VAMP2 channel equivalences
| 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 'nlo_eejj_p1.m3.vg2'.
| VAMP2: set chain: use chained weights.
1 98 -2.0692689E+01 3.90E-01 1.88 0.19* 28.35
|-----------------------------------------------------------------------------|
1 98 -2.0692689E+01 3.90E-01 1.88 0.19 28.35
|=============================================================================|
| Integrate: sum of all components
|=============================================================================|
| It Calls Integral[fb] Error[fb] Err[%] Acc Eff[%] Chi2 N[It] |
|=============================================================================|
1 0 6.3252206E+02 8.43E+00 1.33 0.00* 30.80
| NLO Correction: [O(alpha_s+1)/O(alpha_s)]
| ( 1.9170 +- 1.08920 ) %
|=============================================================================|
| There were no errors and 2 warning(s).
| WHIZARD run finished.
|=============================================================================|
Index: trunk/share/tests/ext_tests_nlo/ref-output/nlo_ppzj_sim_3.ref
===================================================================
--- trunk/share/tests/ext_tests_nlo/ref-output/nlo_ppzj_sim_3.ref (revision 8482)
+++ trunk/share/tests/ext_tests_nlo/ref-output/nlo_ppzj_sim_3.ref (revision 8483)
@@ -1,748 +1,748 @@
?openmp_logging = false
?vis_history = false
?integration_timer = false
?pacify = true
openmp_num_threads = 1
SM.mZ => 9.11880E+01
SM.wZ => 0.00000E+00
SM.ms => 0.00000E+00
[user variable] pr = PDG(2, -2, 1, -1, 3, -3, 21)
[user variable] jet = PDG(2, -2, 1, -1, 3, -3, 21)
[user variable] elec = PDG(11, -11)
$exclude_gauge_splittings = "c:b:t"
jet_algorithm = 2
jet_r = 5.00000E-01
$method = "openloops"
alpha_power = 1
alphas_power = 1
$rng_method = "rng_stream"
$integration_method = "vamp2"
sqrts = 1.30000E+04
?combined_nlo_integration = false
-?use_vamp_equivalences = false
seed = 3991
$restrictions = "!W+:W-"
| Process library 'nlo_ppzj_sim_3_lib': recorded process 'nlo_ppzj_sim_3_p1'
| Integrate: current process library needs compilation
| Process library 'nlo_ppzj_sim_3_lib': compiling ...
| Process library 'nlo_ppzj_sim_3_lib': writing makefile
| Process library 'nlo_ppzj_sim_3_lib': removing old files
| Process library 'nlo_ppzj_sim_3_lib': writing driver
| Process library 'nlo_ppzj_sim_3_lib': creating source code
| Process library 'nlo_ppzj_sim_3_lib': compiling sources
| Process library 'nlo_ppzj_sim_3_lib': linking
| Process library 'nlo_ppzj_sim_3_lib': loading
| Process library 'nlo_ppzj_sim_3_lib': ... success.
| Integrate: compilation done
| RNG: Initializing RNG Stream random-number generator
| RNG: Setting seed for random-number generator to 3991
| Initializing integration for process nlo_ppzj_sim_3_p1:
| Beam structure: p, p => pdf_builtin
| Beam data (collision):
| p (mass = 0.0000000E+00 GeV)
| p (mass = 0.0000000E+00 GeV)
| sqrts = 1.300000000000E+04 GeV
| Initialized builtin PDF CTEQ6L
| Phase space: generating configuration ...
| Phase space: ... success.
| Phase space: writing configuration file 'nlo_ppzj_sim_3_p1.i1.phs'
| Phase space: generating configuration ...
| Phase space: ... success.
| Phase space: writing configuration file 'nlo_ppzj_sim_3_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: [...]
| One-Loop-Provider: Using OpenLoops
| Loading library: [...]
| One-Loop-Provider: Using OpenLoops
| Loading library: [...]
| ------------------------------------------------------------------------
| Process [scattering]: 'nlo_ppzj_sim_3_p1'
| Library name = 'nlo_ppzj_sim_3_lib'
| Process index = 1
| Process components:
| 1: 'nlo_ppzj_sim_3_p1_i1': u:ubar:d:dbar:s:sbar:gl, u:ubar:d:dbar:s:sbar:gl => Z, u:ubar:d:dbar:s:sbar:gl [inactive]
| 2: 'nlo_ppzj_sim_3_p1_i2': dbar:d:ubar:u:sbar:s:gl, dbar:d:ubar:u:sbar:s:gl => Z, d:dbar:u:ubar:s:sbar:gl, d:dbar:u:ubar:s:sbar:gl [inactive], [real]
| 3: 'nlo_ppzj_sim_3_p1_i3': u:ubar:d:dbar:s:sbar:gl, u:ubar:d:dbar:s:sbar:gl => Z, u:ubar:d:dbar:s:sbar:gl [inactive], [virtual]
| 4: 'nlo_ppzj_sim_3_p1_i4': u:ubar:d:dbar:s:sbar:gl, u:ubar:d:dbar:s:sbar:gl => Z, u:ubar:d:dbar:s:sbar:gl [inactive], [subtraction]
| 5: 'nlo_ppzj_sim_3_p1_i5': u:ubar:d:dbar:s:sbar:gl, u:ubar:d:dbar:s:sbar:gl => Z, u:ubar:d:dbar:s:sbar:gl [openloops], [dglap]
| ------------------------------------------------------------------------
| Phase space: 5 channels, 2 dimensions
| Phase space: found 5 channels, collected in 2 groves.
-| Phase space: no equivalences between channels used.
+| Phase space: Using 9 equivalences between channels.
| Phase space: wood
| Phase space: 5 channels, 5 dimensions
| Phase space: found 5 channels, collected in 2 groves.
-| Phase space: no equivalences between channels used.
+| Phase space: Using 9 equivalences between channels.
| Phase space: wood
| Phase space: 5 channels, 2 dimensions
| Phase space: found 5 channels, collected in 2 groves.
-| Phase space: no equivalences between channels used.
+| Phase space: Using 9 equivalences between channels.
| Phase space: wood
| Phase space: 5 channels, 3 dimensions
| Phase space: found 5 channels, collected in 2 groves.
-| Phase space: no equivalences between channels used.
+| Phase space: Using 9 equivalences between channels.
| Phase space: wood
| Beam structure: pdf_builtin, none => none, pdf_builtin
| Beam structure: 1 channels, 2 dimensions
| Applying user-defined cuts.
| Using user-defined general scale.
| Starting integration for process 'nlo_ppzj_sim_3_p1' part 'dglap'
| Integrate: iterations = 1:100
| Integrator: 2 chains, 5 channels, 5 dimensions
+| Integrator: Using VAMP2 channel equivalences
| 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 'nlo_ppzj_sim_3_p1.m4.vg2'.
| VAMP2: set chain: use chained weights.
1 100 3.560E+03 2.99E+03 83.99 8.40 5.2
|-----------------------------------------------------------------------------|
1 100 3.560E+03 2.99E+03 83.99 8.40 5.2
|=============================================================================|
| Integrate: sum of all components
|=============================================================================|
| It Calls Integral[fb] Error[fb] Err[%] Acc Eff[%] Chi2 N[It] |
|=============================================================================|
1 0 3.560E+03 2.99E+03 83.99 0.00 5.2
|=============================================================================|
n_events = 2
$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 'nlo_ppzj_sim_3_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: [...]
| One-Loop-Provider: Using OpenLoops
| Loading library: [...]
| One-Loop-Provider: Using OpenLoops
| Loading library: [...]
| Simulate: activating fixed-order NLO events
| RNG: Initializing RNG Stream random-number generator
| RNG: Setting seed for random-number generator to 3992
| Events: writing to ASCII file 'nlo_ppzj_sim_3_p1.debug'
| Events: generating 2 weighted, unpolarized events ...
| Events: event normalization mode 'sigma'
| ... event sample complete.
| Events: closing ASCII file 'nlo_ppzj_sim_3_p1.debug'
| WHIZARD run finished.
|=============================================================================|
Total number of regions: 150
alr || flst_real || i_real || em || mul || nreg || ftuples || flst_born || i_born
1 || [ -2, -2, 23, -2, -2] || 1 || 2 || 2 || 4 || {(1,4),(1,5),(2,4),(2,5)} || [ -2, 21, 23, -2] || 2
2 || [ -2, -2, 23, -2, -2] || 1 || 1 || 2 || 4 || {(1,4),(1,5),(2,4),(2,5)} || [ 21, -2, 23, -2] || 13
3 || [ -2, 2, 23, -2, 2] || 2 || 4 || 1 || 3 || {(1,4),(2,5),(4,5)} || [ -2, 2, 23, 21] || 1
4 || [ -2, 2, 23, -2, 2] || 2 || 2 || 1 || 3 || {(1,4),(2,5),(4,5)} || [ -2, 21, 23, -2] || 2
5 || [ -2, 2, 23, 2, -2] || 3 || 1 || 1 || 3 || {(1,5),(2,4),(4,5)} || [ 21, 2, 23, 2] || 14
6 || [ -2, 2, 23, -3, 3] || 4 || 4 || 1 || 1 || {(4,5)} || [ -2, 2, 23, 21] || 1
7 || [ -2, 2, 23, -1, 1] || 5 || 4 || 1 || 1 || {(4,5)} || [ -2, 2, 23, 21] || 1
8 || [ -2, 2, 23, 21, 21] || 6 || 4 || 1 || 3 || {(0,4),(0,5),(4,5)} || [ -2, 2, 23, 21] || 1
9 || [ -2, 2, 23, 21, 21] || 6 || 0 || 2 || 3 || {(0,4),(0,5),(4,5)} || [ -2, 2, 23, 21] || 1
10 || [ -2, -3, 23, -2, -3] || 7 || 2 || 1 || 2 || {(1,4),(2,5)} || [ -2, 21, 23, -2] || 2
11 || [ -2, -3, 23, -3, -2] || 8 || 1 || 1 || 2 || {(1,5),(2,4)} || [ 21, -3, 23, -3] || 15
12 || [ -2, -1, 23, -2, -1] || 9 || 2 || 1 || 2 || {(1,4),(2,5)} || [ -2, 21, 23, -2] || 2
13 || [ -2, -1, 23, -1, -2] || 10 || 1 || 1 || 2 || {(1,5),(2,4)} || [ 21, -1, 23, -1] || 16
14 || [ -2, 1, 23, -2, 1] || 11 || 2 || 1 || 2 || {(1,4),(2,5)} || [ -2, 21, 23, -2] || 2
15 || [ -2, 1, 23, 1, -2] || 12 || 1 || 1 || 2 || {(1,5),(2,4)} || [ 21, 1, 23, 1] || 17
16 || [ -2, 3, 23, -2, 3] || 13 || 2 || 1 || 2 || {(1,4),(2,5)} || [ -2, 21, 23, -2] || 2
17 || [ -2, 3, 23, 3, -2] || 14 || 1 || 1 || 2 || {(1,5),(2,4)} || [ 21, 3, 23, 3] || 18
18 || [ -2, 21, 23, 21, -2] || 15 || 2 || 1 || 3 || {(0,4),(2,5),(4,5)} || [ -2, 2, 23, 21] || 1
19 || [ -2, 21, 23, -2, 21] || 16 || 4 || 1 || 3 || {(0,5),(2,4),(4,5)} || [ -2, 21, 23, -2] || 2
20 || [ -2, 21, 23, -2, 21] || 16 || 0 || 1 || 3 || {(0,5),(2,4),(4,5)} || [ -2, 21, 23, -2] || 2
21 || [ 2, -2, 23, -2, 2] || 17 || 4 || 1 || 3 || {(1,5),(2,4),(4,5)} || [ 2, -2, 23, 21] || 3
22 || [ 2, -2, 23, 2, -2] || 18 || 2 || 1 || 3 || {(1,4),(2,5),(4,5)} || [ 2, 21, 23, 2] || 4
23 || [ 2, -2, 23, -2, 2] || 17 || 1 || 1 || 3 || {(1,5),(2,4),(4,5)} || [ 21, -2, 23, -2] || 13
24 || [ 2, -2, 23, -3, 3] || 19 || 4 || 1 || 1 || {(4,5)} || [ 2, -2, 23, 21] || 3
25 || [ 2, -2, 23, -1, 1] || 20 || 4 || 1 || 1 || {(4,5)} || [ 2, -2, 23, 21] || 3
26 || [ 2, -2, 23, 21, 21] || 21 || 4 || 1 || 3 || {(0,4),(0,5),(4,5)} || [ 2, -2, 23, 21] || 3
27 || [ 2, -2, 23, 21, 21] || 21 || 0 || 2 || 3 || {(0,4),(0,5),(4,5)} || [ 2, -2, 23, 21] || 3
28 || [ 2, 2, 23, 2, 2] || 22 || 2 || 2 || 4 || {(1,4),(1,5),(2,4),(2,5)} || [ 2, 21, 23, 2] || 4
29 || [ 2, 2, 23, 2, 2] || 22 || 1 || 2 || 4 || {(1,4),(1,5),(2,4),(2,5)} || [ 21, 2, 23, 2] || 14
30 || [ 2, -3, 23, 2, -3] || 23 || 2 || 1 || 2 || {(1,4),(2,5)} || [ 2, 21, 23, 2] || 4
31 || [ 2, -3, 23, -3, 2] || 24 || 1 || 1 || 2 || {(1,5),(2,4)} || [ 21, -3, 23, -3] || 15
32 || [ 2, -1, 23, 2, -1] || 25 || 2 || 1 || 2 || {(1,4),(2,5)} || [ 2, 21, 23, 2] || 4
33 || [ 2, -1, 23, -1, 2] || 26 || 1 || 1 || 2 || {(1,5),(2,4)} || [ 21, -1, 23, -1] || 16
34 || [ 2, 1, 23, 2, 1] || 27 || 2 || 1 || 2 || {(1,4),(2,5)} || [ 2, 21, 23, 2] || 4
35 || [ 2, 1, 23, 1, 2] || 28 || 1 || 1 || 2 || {(1,5),(2,4)} || [ 21, 1, 23, 1] || 17
36 || [ 2, 3, 23, 2, 3] || 29 || 2 || 1 || 2 || {(1,4),(2,5)} || [ 2, 21, 23, 2] || 4
37 || [ 2, 3, 23, 3, 2] || 30 || 1 || 1 || 2 || {(1,5),(2,4)} || [ 21, 3, 23, 3] || 18
38 || [ 2, 21, 23, 21, 2] || 31 || 2 || 1 || 3 || {(0,4),(2,5),(4,5)} || [ 2, -2, 23, 21] || 3
39 || [ 2, 21, 23, 2, 21] || 32 || 4 || 1 || 3 || {(0,5),(2,4),(4,5)} || [ 2, 21, 23, 2] || 4
40 || [ 2, 21, 23, 2, 21] || 32 || 0 || 1 || 3 || {(0,5),(2,4),(4,5)} || [ 2, 21, 23, 2] || 4
41 || [ -3, -2, 23, -3, -2] || 33 || 2 || 1 || 2 || {(1,4),(2,5)} || [ -3, 21, 23, -3] || 6
42 || [ -3, -2, 23, -2, -3] || 34 || 1 || 1 || 2 || {(1,5),(2,4)} || [ 21, -2, 23, -2] || 13
43 || [ -3, 2, 23, -3, 2] || 35 || 2 || 1 || 2 || {(1,4),(2,5)} || [ -3, 21, 23, -3] || 6
44 || [ -3, 2, 23, 2, -3] || 36 || 1 || 1 || 2 || {(1,5),(2,4)} || [ 21, 2, 23, 2] || 14
45 || [ -3, -3, 23, -3, -3] || 37 || 2 || 2 || 4 || {(1,4),(1,5),(2,4),(2,5)} || [ -3, 21, 23, -3] || 6
46 || [ -3, -3, 23, -3, -3] || 37 || 1 || 2 || 4 || {(1,4),(1,5),(2,4),(2,5)} || [ 21, -3, 23, -3] || 15
47 || [ -3, -1, 23, -3, -1] || 38 || 2 || 1 || 2 || {(1,4),(2,5)} || [ -3, 21, 23, -3] || 6
48 || [ -3, -1, 23, -1, -3] || 39 || 1 || 1 || 2 || {(1,5),(2,4)} || [ 21, -1, 23, -1] || 16
49 || [ -3, 1, 23, -3, 1] || 40 || 2 || 1 || 2 || {(1,4),(2,5)} || [ -3, 21, 23, -3] || 6
50 || [ -3, 1, 23, 1, -3] || 41 || 1 || 1 || 2 || {(1,5),(2,4)} || [ 21, 1, 23, 1] || 17
51 || [ -3, 3, 23, -2, 2] || 42 || 4 || 1 || 1 || {(4,5)} || [ -3, 3, 23, 21] || 5
52 || [ -3, 3, 23, -3, 3] || 43 || 4 || 1 || 3 || {(1,4),(2,5),(4,5)} || [ -3, 3, 23, 21] || 5
53 || [ -3, 3, 23, -3, 3] || 43 || 2 || 1 || 3 || {(1,4),(2,5),(4,5)} || [ -3, 21, 23, -3] || 6
54 || [ -3, 3, 23, 3, -3] || 44 || 1 || 1 || 3 || {(1,5),(2,4),(4,5)} || [ 21, 3, 23, 3] || 18
55 || [ -3, 3, 23, -1, 1] || 45 || 4 || 1 || 1 || {(4,5)} || [ -3, 3, 23, 21] || 5
56 || [ -3, 3, 23, 21, 21] || 46 || 4 || 1 || 3 || {(0,4),(0,5),(4,5)} || [ -3, 3, 23, 21] || 5
57 || [ -3, 3, 23, 21, 21] || 46 || 0 || 2 || 3 || {(0,4),(0,5),(4,5)} || [ -3, 3, 23, 21] || 5
58 || [ -3, 21, 23, 21, -3] || 47 || 2 || 1 || 3 || {(0,4),(2,5),(4,5)} || [ -3, 3, 23, 21] || 5
59 || [ -3, 21, 23, -3, 21] || 48 || 4 || 1 || 3 || {(0,5),(2,4),(4,5)} || [ -3, 21, 23, -3] || 6
60 || [ -3, 21, 23, -3, 21] || 48 || 0 || 1 || 3 || {(0,5),(2,4),(4,5)} || [ -3, 21, 23, -3] || 6
61 || [ -1, -2, 23, -1, -2] || 49 || 2 || 1 || 2 || {(1,4),(2,5)} || [ -1, 21, 23, -1] || 8
62 || [ -1, -2, 23, -2, -1] || 50 || 1 || 1 || 2 || {(1,5),(2,4)} || [ 21, -2, 23, -2] || 13
63 || [ -1, 2, 23, -1, 2] || 51 || 2 || 1 || 2 || {(1,4),(2,5)} || [ -1, 21, 23, -1] || 8
64 || [ -1, 2, 23, 2, -1] || 52 || 1 || 1 || 2 || {(1,5),(2,4)} || [ 21, 2, 23, 2] || 14
65 || [ -1, -3, 23, -1, -3] || 53 || 2 || 1 || 2 || {(1,4),(2,5)} || [ -1, 21, 23, -1] || 8
66 || [ -1, -3, 23, -3, -1] || 54 || 1 || 1 || 2 || {(1,5),(2,4)} || [ 21, -3, 23, -3] || 15
67 || [ -1, -1, 23, -1, -1] || 55 || 2 || 2 || 4 || {(1,4),(1,5),(2,4),(2,5)} || [ -1, 21, 23, -1] || 8
68 || [ -1, -1, 23, -1, -1] || 55 || 1 || 2 || 4 || {(1,4),(1,5),(2,4),(2,5)} || [ 21, -1, 23, -1] || 16
69 || [ -1, 1, 23, -2, 2] || 56 || 4 || 1 || 1 || {(4,5)} || [ -1, 1, 23, 21] || 7
70 || [ -1, 1, 23, -3, 3] || 57 || 4 || 1 || 1 || {(4,5)} || [ -1, 1, 23, 21] || 7
71 || [ -1, 1, 23, -1, 1] || 58 || 4 || 1 || 3 || {(1,4),(2,5),(4,5)} || [ -1, 1, 23, 21] || 7
72 || [ -1, 1, 23, -1, 1] || 58 || 2 || 1 || 3 || {(1,4),(2,5),(4,5)} || [ -1, 21, 23, -1] || 8
73 || [ -1, 1, 23, 1, -1] || 59 || 1 || 1 || 3 || {(1,5),(2,4),(4,5)} || [ 21, 1, 23, 1] || 17
74 || [ -1, 1, 23, 21, 21] || 60 || 4 || 1 || 3 || {(0,4),(0,5),(4,5)} || [ -1, 1, 23, 21] || 7
75 || [ -1, 1, 23, 21, 21] || 60 || 0 || 2 || 3 || {(0,4),(0,5),(4,5)} || [ -1, 1, 23, 21] || 7
76 || [ -1, 3, 23, -1, 3] || 61 || 2 || 1 || 2 || {(1,4),(2,5)} || [ -1, 21, 23, -1] || 8
77 || [ -1, 3, 23, 3, -1] || 62 || 1 || 1 || 2 || {(1,5),(2,4)} || [ 21, 3, 23, 3] || 18
78 || [ -1, 21, 23, 21, -1] || 63 || 2 || 1 || 3 || {(0,4),(2,5),(4,5)} || [ -1, 1, 23, 21] || 7
79 || [ -1, 21, 23, -1, 21] || 64 || 4 || 1 || 3 || {(0,5),(2,4),(4,5)} || [ -1, 21, 23, -1] || 8
80 || [ -1, 21, 23, -1, 21] || 64 || 0 || 1 || 3 || {(0,5),(2,4),(4,5)} || [ -1, 21, 23, -1] || 8
81 || [ 1, -2, 23, 1, -2] || 65 || 2 || 1 || 2 || {(1,4),(2,5)} || [ 1, 21, 23, 1] || 10
82 || [ 1, -2, 23, -2, 1] || 66 || 1 || 1 || 2 || {(1,5),(2,4)} || [ 21, -2, 23, -2] || 13
83 || [ 1, 2, 23, 1, 2] || 67 || 2 || 1 || 2 || {(1,4),(2,5)} || [ 1, 21, 23, 1] || 10
84 || [ 1, 2, 23, 2, 1] || 68 || 1 || 1 || 2 || {(1,5),(2,4)} || [ 21, 2, 23, 2] || 14
85 || [ 1, -3, 23, 1, -3] || 69 || 2 || 1 || 2 || {(1,4),(2,5)} || [ 1, 21, 23, 1] || 10
86 || [ 1, -3, 23, -3, 1] || 70 || 1 || 1 || 2 || {(1,5),(2,4)} || [ 21, -3, 23, -3] || 15
87 || [ 1, -1, 23, -2, 2] || 71 || 4 || 1 || 1 || {(4,5)} || [ 1, -1, 23, 21] || 9
88 || [ 1, -1, 23, -3, 3] || 72 || 4 || 1 || 1 || {(4,5)} || [ 1, -1, 23, 21] || 9
89 || [ 1, -1, 23, -1, 1] || 73 || 4 || 1 || 3 || {(1,5),(2,4),(4,5)} || [ 1, -1, 23, 21] || 9
90 || [ 1, -1, 23, 1, -1] || 74 || 2 || 1 || 3 || {(1,4),(2,5),(4,5)} || [ 1, 21, 23, 1] || 10
91 || [ 1, -1, 23, -1, 1] || 73 || 1 || 1 || 3 || {(1,5),(2,4),(4,5)} || [ 21, -1, 23, -1] || 16
92 || [ 1, -1, 23, 21, 21] || 75 || 4 || 1 || 3 || {(0,4),(0,5),(4,5)} || [ 1, -1, 23, 21] || 9
93 || [ 1, -1, 23, 21, 21] || 75 || 0 || 2 || 3 || {(0,4),(0,5),(4,5)} || [ 1, -1, 23, 21] || 9
94 || [ 1, 1, 23, 1, 1] || 76 || 2 || 2 || 4 || {(1,4),(1,5),(2,4),(2,5)} || [ 1, 21, 23, 1] || 10
95 || [ 1, 1, 23, 1, 1] || 76 || 1 || 2 || 4 || {(1,4),(1,5),(2,4),(2,5)} || [ 21, 1, 23, 1] || 17
96 || [ 1, 3, 23, 1, 3] || 77 || 2 || 1 || 2 || {(1,4),(2,5)} || [ 1, 21, 23, 1] || 10
97 || [ 1, 3, 23, 3, 1] || 78 || 1 || 1 || 2 || {(1,5),(2,4)} || [ 21, 3, 23, 3] || 18
98 || [ 1, 21, 23, 21, 1] || 79 || 2 || 1 || 3 || {(0,4),(2,5),(4,5)} || [ 1, -1, 23, 21] || 9
99 || [ 1, 21, 23, 1, 21] || 80 || 4 || 1 || 3 || {(0,5),(2,4),(4,5)} || [ 1, 21, 23, 1] || 10
100 || [ 1, 21, 23, 1, 21] || 80 || 0 || 1 || 3 || {(0,5),(2,4),(4,5)} || [ 1, 21, 23, 1] || 10
101 || [ 3, -2, 23, 3, -2] || 81 || 2 || 1 || 2 || {(1,4),(2,5)} || [ 3, 21, 23, 3] || 12
102 || [ 3, -2, 23, -2, 3] || 82 || 1 || 1 || 2 || {(1,5),(2,4)} || [ 21, -2, 23, -2] || 13
103 || [ 3, 2, 23, 3, 2] || 83 || 2 || 1 || 2 || {(1,4),(2,5)} || [ 3, 21, 23, 3] || 12
104 || [ 3, 2, 23, 2, 3] || 84 || 1 || 1 || 2 || {(1,5),(2,4)} || [ 21, 2, 23, 2] || 14
105 || [ 3, -3, 23, -2, 2] || 85 || 4 || 1 || 1 || {(4,5)} || [ 3, -3, 23, 21] || 11
106 || [ 3, -3, 23, -3, 3] || 86 || 4 || 1 || 3 || {(1,5),(2,4),(4,5)} || [ 3, -3, 23, 21] || 11
107 || [ 3, -3, 23, 3, -3] || 87 || 2 || 1 || 3 || {(1,4),(2,5),(4,5)} || [ 3, 21, 23, 3] || 12
108 || [ 3, -3, 23, -3, 3] || 86 || 1 || 1 || 3 || {(1,5),(2,4),(4,5)} || [ 21, -3, 23, -3] || 15
109 || [ 3, -3, 23, -1, 1] || 88 || 4 || 1 || 1 || {(4,5)} || [ 3, -3, 23, 21] || 11
110 || [ 3, -3, 23, 21, 21] || 89 || 4 || 1 || 3 || {(0,4),(0,5),(4,5)} || [ 3, -3, 23, 21] || 11
111 || [ 3, -3, 23, 21, 21] || 89 || 0 || 2 || 3 || {(0,4),(0,5),(4,5)} || [ 3, -3, 23, 21] || 11
112 || [ 3, -1, 23, 3, -1] || 90 || 2 || 1 || 2 || {(1,4),(2,5)} || [ 3, 21, 23, 3] || 12
113 || [ 3, -1, 23, -1, 3] || 91 || 1 || 1 || 2 || {(1,5),(2,4)} || [ 21, -1, 23, -1] || 16
114 || [ 3, 1, 23, 3, 1] || 92 || 2 || 1 || 2 || {(1,4),(2,5)} || [ 3, 21, 23, 3] || 12
115 || [ 3, 1, 23, 1, 3] || 93 || 1 || 1 || 2 || {(1,5),(2,4)} || [ 21, 1, 23, 1] || 17
116 || [ 3, 3, 23, 3, 3] || 94 || 2 || 2 || 4 || {(1,4),(1,5),(2,4),(2,5)} || [ 3, 21, 23, 3] || 12
117 || [ 3, 3, 23, 3, 3] || 94 || 1 || 2 || 4 || {(1,4),(1,5),(2,4),(2,5)} || [ 21, 3, 23, 3] || 18
118 || [ 3, 21, 23, 21, 3] || 95 || 2 || 1 || 3 || {(0,4),(2,5),(4,5)} || [ 3, -3, 23, 21] || 11
119 || [ 3, 21, 23, 3, 21] || 96 || 4 || 1 || 3 || {(0,5),(2,4),(4,5)} || [ 3, 21, 23, 3] || 12
120 || [ 3, 21, 23, 3, 21] || 96 || 0 || 1 || 3 || {(0,5),(2,4),(4,5)} || [ 3, 21, 23, 3] || 12
121 || [ 21, -2, 23, 21, -2] || 97 || 1 || 1 || 3 || {(0,4),(1,5),(4,5)} || [ 2, -2, 23, 21] || 3
122 || [ 21, -2, 23, -2, 21] || 98 || 4 || 1 || 3 || {(0,5),(1,4),(4,5)} || [ 21, -2, 23, -2] || 13
123 || [ 21, -2, 23, -2, 21] || 98 || 0 || 1 || 3 || {(0,5),(1,4),(4,5)} || [ 21, -2, 23, -2] || 13
124 || [ 21, 2, 23, 21, 2] || 99 || 1 || 1 || 3 || {(0,4),(1,5),(4,5)} || [ -2, 2, 23, 21] || 1
125 || [ 21, 2, 23, 2, 21] || 100 || 4 || 1 || 3 || {(0,5),(1,4),(4,5)} || [ 21, 2, 23, 2] || 14
126 || [ 21, 2, 23, 2, 21] || 100 || 0 || 1 || 3 || {(0,5),(1,4),(4,5)} || [ 21, 2, 23, 2] || 14
127 || [ 21, -3, 23, 21, -3] || 101 || 1 || 1 || 3 || {(0,4),(1,5),(4,5)} || [ 3, -3, 23, 21] || 11
128 || [ 21, -3, 23, -3, 21] || 102 || 4 || 1 || 3 || {(0,5),(1,4),(4,5)} || [ 21, -3, 23, -3] || 15
129 || [ 21, -3, 23, -3, 21] || 102 || 0 || 1 || 3 || {(0,5),(1,4),(4,5)} || [ 21, -3, 23, -3] || 15
130 || [ 21, -1, 23, 21, -1] || 103 || 1 || 1 || 3 || {(0,4),(1,5),(4,5)} || [ 1, -1, 23, 21] || 9
131 || [ 21, -1, 23, -1, 21] || 104 || 4 || 1 || 3 || {(0,5),(1,4),(4,5)} || [ 21, -1, 23, -1] || 16
132 || [ 21, -1, 23, -1, 21] || 104 || 0 || 1 || 3 || {(0,5),(1,4),(4,5)} || [ 21, -1, 23, -1] || 16
133 || [ 21, 1, 23, 21, 1] || 105 || 1 || 1 || 3 || {(0,4),(1,5),(4,5)} || [ -1, 1, 23, 21] || 7
134 || [ 21, 1, 23, 1, 21] || 106 || 4 || 1 || 3 || {(0,5),(1,4),(4,5)} || [ 21, 1, 23, 1] || 17
135 || [ 21, 1, 23, 1, 21] || 106 || 0 || 1 || 3 || {(0,5),(1,4),(4,5)} || [ 21, 1, 23, 1] || 17
136 || [ 21, 3, 23, 21, 3] || 107 || 1 || 1 || 3 || {(0,4),(1,5),(4,5)} || [ -3, 3, 23, 21] || 5
137 || [ 21, 3, 23, 3, 21] || 108 || 4 || 1 || 3 || {(0,5),(1,4),(4,5)} || [ 21, 3, 23, 3] || 18
138 || [ 21, 3, 23, 3, 21] || 108 || 0 || 1 || 3 || {(0,5),(1,4),(4,5)} || [ 21, 3, 23, 3] || 18
139 || [ 21, 21, 23, -2, 2] || 109 || 1 || 1 || 4 || {(1,4),(1,5),(2,4),(2,5)} || [ -2, 21, 23, -2] || 2
140 || [ 21, 21, 23, 2, -2] || 110 || 1 || 1 || 4 || {(1,4),(1,5),(2,4),(2,5)} || [ 2, 21, 23, 2] || 4
141 || [ 21, 21, 23, -2, 2] || 109 || 2 || 1 || 4 || {(1,4),(1,5),(2,4),(2,5)} || [ 21, -2, 23, -2] || 13
142 || [ 21, 21, 23, 2, -2] || 110 || 2 || 1 || 4 || {(1,4),(1,5),(2,4),(2,5)} || [ 21, 2, 23, 2] || 14
143 || [ 21, 21, 23, -3, 3] || 111 || 1 || 1 || 4 || {(1,4),(1,5),(2,4),(2,5)} || [ -3, 21, 23, -3] || 6
144 || [ 21, 21, 23, 3, -3] || 112 || 1 || 1 || 4 || {(1,4),(1,5),(2,4),(2,5)} || [ 3, 21, 23, 3] || 12
145 || [ 21, 21, 23, -3, 3] || 111 || 2 || 1 || 4 || {(1,4),(1,5),(2,4),(2,5)} || [ 21, -3, 23, -3] || 15
146 || [ 21, 21, 23, 3, -3] || 112 || 2 || 1 || 4 || {(1,4),(1,5),(2,4),(2,5)} || [ 21, 3, 23, 3] || 18
147 || [ 21, 21, 23, -1, 1] || 113 || 1 || 1 || 4 || {(1,4),(1,5),(2,4),(2,5)} || [ -1, 21, 23, -1] || 8
148 || [ 21, 21, 23, 1, -1] || 114 || 1 || 1 || 4 || {(1,4),(1,5),(2,4),(2,5)} || [ 1, 21, 23, 1] || 10
149 || [ 21, 21, 23, -1, 1] || 113 || 2 || 1 || 4 || {(1,4),(1,5),(2,4),(2,5)} || [ 21, -1, 23, -1] || 16
150 || [ 21, 21, 23, 1, -1] || 114 || 2 || 1 || 4 || {(1,4),(1,5),(2,4),(2,5)} || [ 21, 1, 23, 1] || 17
------------------------------------------------------------------------
Contents of nlo_ppzj_sim_3_p1.debug:
========================================================================
Event #1
------------------------------------------------------------------------
Unweighted = F
Normalization = 'sigma'
Helicity handling = drop
Keep correlations = F
------------------------------------------------------------------------
Squared matrix el. (ref) = 2.96674E-07
Squared matrix el. (prc) = 2.96674E-07
Event weight (ref) = 5.43601E-05
Event weight (prc) = 5.43601E-05
------------------------------------------------------------------------
Selected MCI group = 4
Selected term = 8
Selected channel = 5
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_3_p1'
RNG Stream generator
Current position = [
3270494107.0, 1218490942.0, 3220277207.0,
2821320218.0, 4220147848.0, 1218259235.0,
]
Beginning substream = [
4226523048.0, 3065015250.0, 1182429328.0,
1392969535.0, 3625333239.0, 3251691171.0,
]
Initial stream = [
4226523048.0, 3065015250.0, 1182429328.0,
1392969535.0, 3625333239.0, 3251691171.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 4.498418E+03
P = 0.000000E+00 0.000000E+00 4.498418E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 2.870154E+03
P = 0.000000E+00 0.000000E+00 -2.870154E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 2.001582E+03
P = 0.000000E+00 0.000000E+00 2.001582E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 3.629846E+03
P = 0.000000E+00 0.000000E+00 -3.629846E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 3.637726E+03
P = -9.148657E+02 3.467954E+03 6.008740E+02
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 3.730846E+03
P = 9.148657E+02 -3.467954E+03 1.027390E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_3_p1'
RNG Stream generator
Current position = [
870276730.0, 1525774502.0, 3988227742.0,
3787208568.0, 2984262882.0, 2541051477.0,
]
Beginning substream = [
3013866238.0, 581103679.0, 3358998661.0,
3484764854.0, 532756457.0, 2693721620.0,
]
Initial stream = [
3013866238.0, 581103679.0, 3358998661.0,
3484764854.0, 532756457.0, 2693721620.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 4.498418E+03
P = 0.000000E+00 0.000000E+00 4.498418E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 2.870154E+03
P = 0.000000E+00 0.000000E+00 -2.870154E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 2.001582E+03
P = 0.000000E+00 0.000000E+00 2.001582E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 3.629846E+03
P = 0.000000E+00 0.000000E+00 -3.629846E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 3.637726E+03
P = -9.148657E+02 3.467954E+03 6.008740E+02
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 3.730846E+03
P = 9.148657E+02 -3.467954E+03 1.027390E+03
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 0.000000000E+00
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 4.498418E+03
P = 0.000000E+00 0.000000E+00 4.498418E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 2.870154E+03
P = 0.000000E+00 0.000000E+00 -2.870154E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 2.001582E+03
P = 0.000000E+00 0.000000E+00 2.001582E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 3.629846E+03
P = 0.000000E+00 0.000000E+00 -3.629846E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 3.637726E+03
P = -9.148657E+02 3.467954E+03 6.008740E+02
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 3.730846E+03
P = 9.148657E+02 -3.467954E+03 1.027390E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 7.18642E+03
n_in* => 2
n_out* => 4
n_tot* => 6
$process_id* => "nlo_ppzj_sim_3_p1"
process_num_id* => [unknown integer]
sqme* => 2.96674E-07
sqme_ref* => 2.96674E-07
event_index* => 1
event_weight* => 5.43601E-05
event_weight_ref* => 5.43601E-05
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:-2|-4.4984178E+03; 0.0000000E+00, 0.0000000E+00,-4.4984178E+03| 0.0000000E+00| 3)
4 prt(i:2|-2.8701542E+03; 0.0000000E+00, 0.0000000E+00, 2.8701542E+03| 0.0000000E+00| 4)
5 prt(o:92| 2.0015822E+03; 0.0000000E+00, 0.0000000E+00, 2.0015822E+03| 0.0000000E+00| 5)
6 prt(o:-92| 3.6298458E+03; 0.0000000E+00, 0.0000000E+00,-3.6298458E+03| 0.0000000E+00| 6)
7 prt(o:23| 3.6377257E+03;-9.1486574E+02, 3.4679539E+03, 6.0087396E+02| 8.3152513E+03| 7)
8 prt(o:21| 3.7308462E+03; 9.1486574E+02,-3.4679539E+03, 1.0273896E+03| 0.0000000E+00| 8)
========================================================================
========================================================================
Event #2
------------------------------------------------------------------------
Unweighted = F
Normalization = 'sigma'
Helicity handling = drop
Keep correlations = F
------------------------------------------------------------------------
Squared matrix el. (ref) = -9.77711E-06
Squared matrix el. (prc) = -9.77711E-06
Event weight (ref) = -2.37563E-04
Event weight (prc) = -2.37563E-04
------------------------------------------------------------------------
Selected MCI group = 4
Selected term = 8
Selected channel = 5
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_3_p1'
RNG Stream generator
Current position = [
1817174340.0, 4169406181.0, 394187331.0,
860033000.0, 2212227538.0, 3653581942.0,
]
Beginning substream = [
4226523048.0, 3065015250.0, 1182429328.0,
1392969535.0, 3625333239.0, 3251691171.0,
]
Initial stream = [
4226523048.0, 3065015250.0, 1182429328.0,
1392969535.0, 3625333239.0, 3251691171.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(21)
E = 4.457158E+03
P = 0.000000E+00 0.000000E+00 4.457158E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 4.123509E+03
P = 0.000000E+00 0.000000E+00 -4.123509E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(93*)
E = 2.042842E+03
P = 0.000000E+00 0.000000E+00 2.042842E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 2.376491E+03
P = 0.000000E+00 0.000000E+00 -2.376491E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 4.447483E+03
P = 1.278196E+03 -7.297981E+02 4.195879E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 4.133184E+03
P = -1.278196E+03 7.297981E+02 -3.862230E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_3_p1'
RNG Stream generator
Current position = [
976955966.0, 3946182281.0, 2474115998.0,
1111192673.0, 3759619853.0, 3640289132.0,
]
Beginning substream = [
3013866238.0, 581103679.0, 3358998661.0,
3484764854.0, 532756457.0, 2693721620.0,
]
Initial stream = [
3013866238.0, 581103679.0, 3358998661.0,
3484764854.0, 532756457.0, 2693721620.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 4.457158E+03
P = 0.000000E+00 0.000000E+00 4.457158E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 4.123509E+03
P = 0.000000E+00 0.000000E+00 -4.123509E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 2.042842E+03
P = 0.000000E+00 0.000000E+00 2.042842E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 2.376491E+03
P = 0.000000E+00 0.000000E+00 -2.376491E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 4.447483E+03
P = 1.278196E+03 -7.297981E+02 4.195879E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 4.133184E+03
P = -1.278196E+03 7.297981E+02 -3.862230E+03
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 0.000000000E+00
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 4.457158E+03
P = 0.000000E+00 0.000000E+00 4.457158E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 4.123509E+03
P = 0.000000E+00 0.000000E+00 -4.123509E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 2.042842E+03
P = 0.000000E+00 0.000000E+00 2.042842E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 2.376491E+03
P = 0.000000E+00 0.000000E+00 -2.376491E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 4.447483E+03
P = 1.278196E+03 -7.297981E+02 4.195879E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 4.133184E+03
P = -1.278196E+03 7.297981E+02 -3.862230E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 8.57418E+03
n_in* => 2
n_out* => 4
n_tot* => 6
$process_id* => "nlo_ppzj_sim_3_p1"
process_num_id* => [unknown integer]
sqme* => -9.77711E-06
sqme_ref* => -9.77711E-06
event_index* => 2
event_weight* => -2.37563E-04
event_weight_ref* => -2.37563E-04
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:-2|-4.4571580E+03; 0.0000000E+00, 0.0000000E+00,-4.4571580E+03| 0.0000000E+00| 3)
4 prt(i:2|-4.1235091E+03; 0.0000000E+00, 0.0000000E+00, 4.1235091E+03| 0.0000000E+00| 4)
5 prt(o:92| 2.0428420E+03; 0.0000000E+00, 0.0000000E+00, 2.0428420E+03| 0.0000000E+00| 5)
6 prt(o:-92| 2.3764909E+03; 0.0000000E+00, 0.0000000E+00,-2.3764909E+03| 0.0000000E+00| 6)
7 prt(o:23| 4.4474830E+03; 1.2781957E+03,-7.2979813E+02, 4.1958789E+03| 8.3152513E+03| 7)
8 prt(o:21| 4.1331841E+03;-1.2781957E+03, 7.2979813E+02,-3.8622300E+03| 0.0000000E+00| 8)
========================================================================
Index: trunk/share/tests/ext_tests_nlo/ref-output/nlo_ppzj_sim_4.ref
===================================================================
--- trunk/share/tests/ext_tests_nlo/ref-output/nlo_ppzj_sim_4.ref (revision 8482)
+++ trunk/share/tests/ext_tests_nlo/ref-output/nlo_ppzj_sim_4.ref (revision 8483)
@@ -1,21752 +1,21752 @@
?openmp_logging = false
?vis_history = false
?integration_timer = false
?pacify = true
openmp_num_threads = 1
SM.mZ => 9.11880E+01
SM.wZ => 0.00000E+00
SM.ms => 0.00000E+00
[user variable] pr = PDG(2, -2, 1, -1, 3, -3, 21)
[user variable] jet = PDG(2, -2, 1, -1, 3, -3, 21)
[user variable] elec = PDG(11, -11)
$exclude_gauge_splittings = "c:b:t"
jet_algorithm = 2
jet_r = 5.00000E-01
$method = "openloops"
alpha_power = 1
alphas_power = 1
$rng_method = "rng_stream"
$integration_method = "vamp2"
sqrts = 1.30000E+04
?combined_nlo_integration = true
-?use_vamp_equivalences = false
seed = 4466
$restrictions = "!W+:W-"
| Process library 'nlo_ppzj_sim_4_lib': recorded process 'nlo_ppzj_sim_4_p1'
| Integrate: current process library needs compilation
| Process library 'nlo_ppzj_sim_4_lib': compiling ...
| Process library 'nlo_ppzj_sim_4_lib': writing makefile
| Process library 'nlo_ppzj_sim_4_lib': removing old files
| Process library 'nlo_ppzj_sim_4_lib': writing driver
| Process library 'nlo_ppzj_sim_4_lib': creating source code
| Process library 'nlo_ppzj_sim_4_lib': compiling sources
| Process library 'nlo_ppzj_sim_4_lib': linking
| Process library 'nlo_ppzj_sim_4_lib': loading
| Process library 'nlo_ppzj_sim_4_lib': ... success.
| Integrate: compilation done
| RNG: Initializing RNG Stream random-number generator
| RNG: Setting seed for random-number generator to 4466
| Initializing integration for process nlo_ppzj_sim_4_p1:
| Beam structure: p, p => pdf_builtin
| Beam data (collision):
| p (mass = 0.0000000E+00 GeV)
| p (mass = 0.0000000E+00 GeV)
| sqrts = 1.300000000000E+04 GeV
| Initialized builtin PDF CTEQ6L
| Phase space: generating configuration ...
| Phase space: ... success.
| Phase space: writing configuration file 'nlo_ppzj_sim_4_p1.i1.phs'
| Phase space: generating configuration ...
| Phase space: ... success.
| Phase space: writing configuration file 'nlo_ppzj_sim_4_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: [...]
| 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: [...]
| One-Loop-Provider: Using OpenLoops
| Loading library: [...]
| One-Loop-Provider: Using OpenLoops
| Loading library: [...]
| ------------------------------------------------------------------------
| Process [scattering]: 'nlo_ppzj_sim_4_p1'
| Library name = 'nlo_ppzj_sim_4_lib'
| Process index = 1
| Process components:
| 1: 'nlo_ppzj_sim_4_p1_i1': u:ubar:d:dbar:s:sbar:gl, u:ubar:d:dbar:s:sbar:gl => Z, u:ubar:d:dbar:s:sbar:gl [openloops]
| 2: 'nlo_ppzj_sim_4_p1_i2': dbar:d:ubar:u:sbar:s:gl, dbar:d:ubar:u:sbar:s:gl => Z, d:dbar:u:ubar:s:sbar:gl, d:dbar:u:ubar:s:sbar:gl [openloops], [real]
| 3: 'nlo_ppzj_sim_4_p1_i3': u:ubar:d:dbar:s:sbar:gl, u:ubar:d:dbar:s:sbar:gl => Z, u:ubar:d:dbar:s:sbar:gl [openloops], [virtual]
| 4: 'nlo_ppzj_sim_4_p1_i4': u:ubar:d:dbar:s:sbar:gl, u:ubar:d:dbar:s:sbar:gl => Z, u:ubar:d:dbar:s:sbar:gl [inactive], [subtraction]
| 5: 'nlo_ppzj_sim_4_p1_i5': u:ubar:d:dbar:s:sbar:gl, u:ubar:d:dbar:s:sbar:gl => Z, u:ubar:d:dbar:s:sbar:gl [openloops], [dglap]
| ------------------------------------------------------------------------
| Phase space: 5 channels, 5 dimensions
| Phase space: found 5 channels, collected in 2 groves.
-| Phase space: no equivalences between channels used.
+| Phase space: Using 9 equivalences between channels.
| Phase space: wood
| Phase space: 5 channels, 5 dimensions
| Phase space: found 5 channels, collected in 2 groves.
-| Phase space: no equivalences between channels used.
+| Phase space: Using 9 equivalences between channels.
| Phase space: wood
| Phase space: 5 channels, 5 dimensions
| Phase space: found 5 channels, collected in 2 groves.
-| Phase space: no equivalences between channels used.
+| Phase space: Using 9 equivalences between channels.
| Phase space: wood
| Phase space: 5 channels, 5 dimensions
| Phase space: found 5 channels, collected in 2 groves.
-| Phase space: no equivalences between channels used.
+| Phase space: Using 9 equivalences between channels.
| Phase space: wood
| Beam structure: pdf_builtin, none => none, pdf_builtin
| Beam structure: 1 channels, 2 dimensions
| Applying user-defined cuts.
| Using user-defined general scale.
| Starting integration for process 'nlo_ppzj_sim_4_p1'
| Integrate: iterations = 1:100
| Integrator: 2 chains, 5 channels, 7 dimensions
+| Integrator: Using VAMP2 channel equivalences
| 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 'nlo_ppzj_sim_4_p1.m1.vg2'.
| VAMP2: set chain: use chained weights.
1 100 1.549E+04 1.43E+04 92.10 9.21 5.0
|-----------------------------------------------------------------------------|
1 100 1.549E+04 1.43E+04 92.10 9.21 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 'nlo_ppzj_sim_4_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: [...]
| 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: [...]
| One-Loop-Provider: Using OpenLoops
| Loading library: [...]
| One-Loop-Provider: Using OpenLoops
| Loading library: [...]
| Simulate: activating fixed-order NLO events
| RNG: Initializing RNG Stream random-number generator
| RNG: Setting seed for random-number generator to 4467
| Events: writing to ASCII file 'nlo_ppzj_sim_4_p1.debug'
| Events: generating 50 weighted, unpolarized NLO events ...
| Events: event normalization mode 'sigma'
| ... event sample complete.
| Events: closing ASCII file 'nlo_ppzj_sim_4_p1.debug'
| WHIZARD run finished.
|=============================================================================|
Total number of regions: 150
alr || flst_real || i_real || em || mul || nreg || ftuples || flst_born || i_born
1 || [ -2, -2, 23, -2, -2] || 1 || 2 || 2 || 4 || {(1,4),(1,5),(2,4),(2,5)} || [ -2, 21, 23, -2] || 2
2 || [ -2, -2, 23, -2, -2] || 1 || 1 || 2 || 4 || {(1,4),(1,5),(2,4),(2,5)} || [ 21, -2, 23, -2] || 13
3 || [ -2, 2, 23, -2, 2] || 2 || 4 || 1 || 3 || {(1,4),(2,5),(4,5)} || [ -2, 2, 23, 21] || 1
4 || [ -2, 2, 23, -2, 2] || 2 || 2 || 1 || 3 || {(1,4),(2,5),(4,5)} || [ -2, 21, 23, -2] || 2
5 || [ -2, 2, 23, 2, -2] || 3 || 1 || 1 || 3 || {(1,5),(2,4),(4,5)} || [ 21, 2, 23, 2] || 14
6 || [ -2, 2, 23, -3, 3] || 4 || 4 || 1 || 1 || {(4,5)} || [ -2, 2, 23, 21] || 1
7 || [ -2, 2, 23, -1, 1] || 5 || 4 || 1 || 1 || {(4,5)} || [ -2, 2, 23, 21] || 1
8 || [ -2, 2, 23, 21, 21] || 6 || 4 || 1 || 3 || {(0,4),(0,5),(4,5)} || [ -2, 2, 23, 21] || 1
9 || [ -2, 2, 23, 21, 21] || 6 || 0 || 2 || 3 || {(0,4),(0,5),(4,5)} || [ -2, 2, 23, 21] || 1
10 || [ -2, -3, 23, -2, -3] || 7 || 2 || 1 || 2 || {(1,4),(2,5)} || [ -2, 21, 23, -2] || 2
11 || [ -2, -3, 23, -3, -2] || 8 || 1 || 1 || 2 || {(1,5),(2,4)} || [ 21, -3, 23, -3] || 15
12 || [ -2, -1, 23, -2, -1] || 9 || 2 || 1 || 2 || {(1,4),(2,5)} || [ -2, 21, 23, -2] || 2
13 || [ -2, -1, 23, -1, -2] || 10 || 1 || 1 || 2 || {(1,5),(2,4)} || [ 21, -1, 23, -1] || 16
14 || [ -2, 1, 23, -2, 1] || 11 || 2 || 1 || 2 || {(1,4),(2,5)} || [ -2, 21, 23, -2] || 2
15 || [ -2, 1, 23, 1, -2] || 12 || 1 || 1 || 2 || {(1,5),(2,4)} || [ 21, 1, 23, 1] || 17
16 || [ -2, 3, 23, -2, 3] || 13 || 2 || 1 || 2 || {(1,4),(2,5)} || [ -2, 21, 23, -2] || 2
17 || [ -2, 3, 23, 3, -2] || 14 || 1 || 1 || 2 || {(1,5),(2,4)} || [ 21, 3, 23, 3] || 18
18 || [ -2, 21, 23, 21, -2] || 15 || 2 || 1 || 3 || {(0,4),(2,5),(4,5)} || [ -2, 2, 23, 21] || 1
19 || [ -2, 21, 23, -2, 21] || 16 || 4 || 1 || 3 || {(0,5),(2,4),(4,5)} || [ -2, 21, 23, -2] || 2
20 || [ -2, 21, 23, -2, 21] || 16 || 0 || 1 || 3 || {(0,5),(2,4),(4,5)} || [ -2, 21, 23, -2] || 2
21 || [ 2, -2, 23, -2, 2] || 17 || 4 || 1 || 3 || {(1,5),(2,4),(4,5)} || [ 2, -2, 23, 21] || 3
22 || [ 2, -2, 23, 2, -2] || 18 || 2 || 1 || 3 || {(1,4),(2,5),(4,5)} || [ 2, 21, 23, 2] || 4
23 || [ 2, -2, 23, -2, 2] || 17 || 1 || 1 || 3 || {(1,5),(2,4),(4,5)} || [ 21, -2, 23, -2] || 13
24 || [ 2, -2, 23, -3, 3] || 19 || 4 || 1 || 1 || {(4,5)} || [ 2, -2, 23, 21] || 3
25 || [ 2, -2, 23, -1, 1] || 20 || 4 || 1 || 1 || {(4,5)} || [ 2, -2, 23, 21] || 3
26 || [ 2, -2, 23, 21, 21] || 21 || 4 || 1 || 3 || {(0,4),(0,5),(4,5)} || [ 2, -2, 23, 21] || 3
27 || [ 2, -2, 23, 21, 21] || 21 || 0 || 2 || 3 || {(0,4),(0,5),(4,5)} || [ 2, -2, 23, 21] || 3
28 || [ 2, 2, 23, 2, 2] || 22 || 2 || 2 || 4 || {(1,4),(1,5),(2,4),(2,5)} || [ 2, 21, 23, 2] || 4
29 || [ 2, 2, 23, 2, 2] || 22 || 1 || 2 || 4 || {(1,4),(1,5),(2,4),(2,5)} || [ 21, 2, 23, 2] || 14
30 || [ 2, -3, 23, 2, -3] || 23 || 2 || 1 || 2 || {(1,4),(2,5)} || [ 2, 21, 23, 2] || 4
31 || [ 2, -3, 23, -3, 2] || 24 || 1 || 1 || 2 || {(1,5),(2,4)} || [ 21, -3, 23, -3] || 15
32 || [ 2, -1, 23, 2, -1] || 25 || 2 || 1 || 2 || {(1,4),(2,5)} || [ 2, 21, 23, 2] || 4
33 || [ 2, -1, 23, -1, 2] || 26 || 1 || 1 || 2 || {(1,5),(2,4)} || [ 21, -1, 23, -1] || 16
34 || [ 2, 1, 23, 2, 1] || 27 || 2 || 1 || 2 || {(1,4),(2,5)} || [ 2, 21, 23, 2] || 4
35 || [ 2, 1, 23, 1, 2] || 28 || 1 || 1 || 2 || {(1,5),(2,4)} || [ 21, 1, 23, 1] || 17
36 || [ 2, 3, 23, 2, 3] || 29 || 2 || 1 || 2 || {(1,4),(2,5)} || [ 2, 21, 23, 2] || 4
37 || [ 2, 3, 23, 3, 2] || 30 || 1 || 1 || 2 || {(1,5),(2,4)} || [ 21, 3, 23, 3] || 18
38 || [ 2, 21, 23, 21, 2] || 31 || 2 || 1 || 3 || {(0,4),(2,5),(4,5)} || [ 2, -2, 23, 21] || 3
39 || [ 2, 21, 23, 2, 21] || 32 || 4 || 1 || 3 || {(0,5),(2,4),(4,5)} || [ 2, 21, 23, 2] || 4
40 || [ 2, 21, 23, 2, 21] || 32 || 0 || 1 || 3 || {(0,5),(2,4),(4,5)} || [ 2, 21, 23, 2] || 4
41 || [ -3, -2, 23, -3, -2] || 33 || 2 || 1 || 2 || {(1,4),(2,5)} || [ -3, 21, 23, -3] || 6
42 || [ -3, -2, 23, -2, -3] || 34 || 1 || 1 || 2 || {(1,5),(2,4)} || [ 21, -2, 23, -2] || 13
43 || [ -3, 2, 23, -3, 2] || 35 || 2 || 1 || 2 || {(1,4),(2,5)} || [ -3, 21, 23, -3] || 6
44 || [ -3, 2, 23, 2, -3] || 36 || 1 || 1 || 2 || {(1,5),(2,4)} || [ 21, 2, 23, 2] || 14
45 || [ -3, -3, 23, -3, -3] || 37 || 2 || 2 || 4 || {(1,4),(1,5),(2,4),(2,5)} || [ -3, 21, 23, -3] || 6
46 || [ -3, -3, 23, -3, -3] || 37 || 1 || 2 || 4 || {(1,4),(1,5),(2,4),(2,5)} || [ 21, -3, 23, -3] || 15
47 || [ -3, -1, 23, -3, -1] || 38 || 2 || 1 || 2 || {(1,4),(2,5)} || [ -3, 21, 23, -3] || 6
48 || [ -3, -1, 23, -1, -3] || 39 || 1 || 1 || 2 || {(1,5),(2,4)} || [ 21, -1, 23, -1] || 16
49 || [ -3, 1, 23, -3, 1] || 40 || 2 || 1 || 2 || {(1,4),(2,5)} || [ -3, 21, 23, -3] || 6
50 || [ -3, 1, 23, 1, -3] || 41 || 1 || 1 || 2 || {(1,5),(2,4)} || [ 21, 1, 23, 1] || 17
51 || [ -3, 3, 23, -2, 2] || 42 || 4 || 1 || 1 || {(4,5)} || [ -3, 3, 23, 21] || 5
52 || [ -3, 3, 23, -3, 3] || 43 || 4 || 1 || 3 || {(1,4),(2,5),(4,5)} || [ -3, 3, 23, 21] || 5
53 || [ -3, 3, 23, -3, 3] || 43 || 2 || 1 || 3 || {(1,4),(2,5),(4,5)} || [ -3, 21, 23, -3] || 6
54 || [ -3, 3, 23, 3, -3] || 44 || 1 || 1 || 3 || {(1,5),(2,4),(4,5)} || [ 21, 3, 23, 3] || 18
55 || [ -3, 3, 23, -1, 1] || 45 || 4 || 1 || 1 || {(4,5)} || [ -3, 3, 23, 21] || 5
56 || [ -3, 3, 23, 21, 21] || 46 || 4 || 1 || 3 || {(0,4),(0,5),(4,5)} || [ -3, 3, 23, 21] || 5
57 || [ -3, 3, 23, 21, 21] || 46 || 0 || 2 || 3 || {(0,4),(0,5),(4,5)} || [ -3, 3, 23, 21] || 5
58 || [ -3, 21, 23, 21, -3] || 47 || 2 || 1 || 3 || {(0,4),(2,5),(4,5)} || [ -3, 3, 23, 21] || 5
59 || [ -3, 21, 23, -3, 21] || 48 || 4 || 1 || 3 || {(0,5),(2,4),(4,5)} || [ -3, 21, 23, -3] || 6
60 || [ -3, 21, 23, -3, 21] || 48 || 0 || 1 || 3 || {(0,5),(2,4),(4,5)} || [ -3, 21, 23, -3] || 6
61 || [ -1, -2, 23, -1, -2] || 49 || 2 || 1 || 2 || {(1,4),(2,5)} || [ -1, 21, 23, -1] || 8
62 || [ -1, -2, 23, -2, -1] || 50 || 1 || 1 || 2 || {(1,5),(2,4)} || [ 21, -2, 23, -2] || 13
63 || [ -1, 2, 23, -1, 2] || 51 || 2 || 1 || 2 || {(1,4),(2,5)} || [ -1, 21, 23, -1] || 8
64 || [ -1, 2, 23, 2, -1] || 52 || 1 || 1 || 2 || {(1,5),(2,4)} || [ 21, 2, 23, 2] || 14
65 || [ -1, -3, 23, -1, -3] || 53 || 2 || 1 || 2 || {(1,4),(2,5)} || [ -1, 21, 23, -1] || 8
66 || [ -1, -3, 23, -3, -1] || 54 || 1 || 1 || 2 || {(1,5),(2,4)} || [ 21, -3, 23, -3] || 15
67 || [ -1, -1, 23, -1, -1] || 55 || 2 || 2 || 4 || {(1,4),(1,5),(2,4),(2,5)} || [ -1, 21, 23, -1] || 8
68 || [ -1, -1, 23, -1, -1] || 55 || 1 || 2 || 4 || {(1,4),(1,5),(2,4),(2,5)} || [ 21, -1, 23, -1] || 16
69 || [ -1, 1, 23, -2, 2] || 56 || 4 || 1 || 1 || {(4,5)} || [ -1, 1, 23, 21] || 7
70 || [ -1, 1, 23, -3, 3] || 57 || 4 || 1 || 1 || {(4,5)} || [ -1, 1, 23, 21] || 7
71 || [ -1, 1, 23, -1, 1] || 58 || 4 || 1 || 3 || {(1,4),(2,5),(4,5)} || [ -1, 1, 23, 21] || 7
72 || [ -1, 1, 23, -1, 1] || 58 || 2 || 1 || 3 || {(1,4),(2,5),(4,5)} || [ -1, 21, 23, -1] || 8
73 || [ -1, 1, 23, 1, -1] || 59 || 1 || 1 || 3 || {(1,5),(2,4),(4,5)} || [ 21, 1, 23, 1] || 17
74 || [ -1, 1, 23, 21, 21] || 60 || 4 || 1 || 3 || {(0,4),(0,5),(4,5)} || [ -1, 1, 23, 21] || 7
75 || [ -1, 1, 23, 21, 21] || 60 || 0 || 2 || 3 || {(0,4),(0,5),(4,5)} || [ -1, 1, 23, 21] || 7
76 || [ -1, 3, 23, -1, 3] || 61 || 2 || 1 || 2 || {(1,4),(2,5)} || [ -1, 21, 23, -1] || 8
77 || [ -1, 3, 23, 3, -1] || 62 || 1 || 1 || 2 || {(1,5),(2,4)} || [ 21, 3, 23, 3] || 18
78 || [ -1, 21, 23, 21, -1] || 63 || 2 || 1 || 3 || {(0,4),(2,5),(4,5)} || [ -1, 1, 23, 21] || 7
79 || [ -1, 21, 23, -1, 21] || 64 || 4 || 1 || 3 || {(0,5),(2,4),(4,5)} || [ -1, 21, 23, -1] || 8
80 || [ -1, 21, 23, -1, 21] || 64 || 0 || 1 || 3 || {(0,5),(2,4),(4,5)} || [ -1, 21, 23, -1] || 8
81 || [ 1, -2, 23, 1, -2] || 65 || 2 || 1 || 2 || {(1,4),(2,5)} || [ 1, 21, 23, 1] || 10
82 || [ 1, -2, 23, -2, 1] || 66 || 1 || 1 || 2 || {(1,5),(2,4)} || [ 21, -2, 23, -2] || 13
83 || [ 1, 2, 23, 1, 2] || 67 || 2 || 1 || 2 || {(1,4),(2,5)} || [ 1, 21, 23, 1] || 10
84 || [ 1, 2, 23, 2, 1] || 68 || 1 || 1 || 2 || {(1,5),(2,4)} || [ 21, 2, 23, 2] || 14
85 || [ 1, -3, 23, 1, -3] || 69 || 2 || 1 || 2 || {(1,4),(2,5)} || [ 1, 21, 23, 1] || 10
86 || [ 1, -3, 23, -3, 1] || 70 || 1 || 1 || 2 || {(1,5),(2,4)} || [ 21, -3, 23, -3] || 15
87 || [ 1, -1, 23, -2, 2] || 71 || 4 || 1 || 1 || {(4,5)} || [ 1, -1, 23, 21] || 9
88 || [ 1, -1, 23, -3, 3] || 72 || 4 || 1 || 1 || {(4,5)} || [ 1, -1, 23, 21] || 9
89 || [ 1, -1, 23, -1, 1] || 73 || 4 || 1 || 3 || {(1,5),(2,4),(4,5)} || [ 1, -1, 23, 21] || 9
90 || [ 1, -1, 23, 1, -1] || 74 || 2 || 1 || 3 || {(1,4),(2,5),(4,5)} || [ 1, 21, 23, 1] || 10
91 || [ 1, -1, 23, -1, 1] || 73 || 1 || 1 || 3 || {(1,5),(2,4),(4,5)} || [ 21, -1, 23, -1] || 16
92 || [ 1, -1, 23, 21, 21] || 75 || 4 || 1 || 3 || {(0,4),(0,5),(4,5)} || [ 1, -1, 23, 21] || 9
93 || [ 1, -1, 23, 21, 21] || 75 || 0 || 2 || 3 || {(0,4),(0,5),(4,5)} || [ 1, -1, 23, 21] || 9
94 || [ 1, 1, 23, 1, 1] || 76 || 2 || 2 || 4 || {(1,4),(1,5),(2,4),(2,5)} || [ 1, 21, 23, 1] || 10
95 || [ 1, 1, 23, 1, 1] || 76 || 1 || 2 || 4 || {(1,4),(1,5),(2,4),(2,5)} || [ 21, 1, 23, 1] || 17
96 || [ 1, 3, 23, 1, 3] || 77 || 2 || 1 || 2 || {(1,4),(2,5)} || [ 1, 21, 23, 1] || 10
97 || [ 1, 3, 23, 3, 1] || 78 || 1 || 1 || 2 || {(1,5),(2,4)} || [ 21, 3, 23, 3] || 18
98 || [ 1, 21, 23, 21, 1] || 79 || 2 || 1 || 3 || {(0,4),(2,5),(4,5)} || [ 1, -1, 23, 21] || 9
99 || [ 1, 21, 23, 1, 21] || 80 || 4 || 1 || 3 || {(0,5),(2,4),(4,5)} || [ 1, 21, 23, 1] || 10
100 || [ 1, 21, 23, 1, 21] || 80 || 0 || 1 || 3 || {(0,5),(2,4),(4,5)} || [ 1, 21, 23, 1] || 10
101 || [ 3, -2, 23, 3, -2] || 81 || 2 || 1 || 2 || {(1,4),(2,5)} || [ 3, 21, 23, 3] || 12
102 || [ 3, -2, 23, -2, 3] || 82 || 1 || 1 || 2 || {(1,5),(2,4)} || [ 21, -2, 23, -2] || 13
103 || [ 3, 2, 23, 3, 2] || 83 || 2 || 1 || 2 || {(1,4),(2,5)} || [ 3, 21, 23, 3] || 12
104 || [ 3, 2, 23, 2, 3] || 84 || 1 || 1 || 2 || {(1,5),(2,4)} || [ 21, 2, 23, 2] || 14
105 || [ 3, -3, 23, -2, 2] || 85 || 4 || 1 || 1 || {(4,5)} || [ 3, -3, 23, 21] || 11
106 || [ 3, -3, 23, -3, 3] || 86 || 4 || 1 || 3 || {(1,5),(2,4),(4,5)} || [ 3, -3, 23, 21] || 11
107 || [ 3, -3, 23, 3, -3] || 87 || 2 || 1 || 3 || {(1,4),(2,5),(4,5)} || [ 3, 21, 23, 3] || 12
108 || [ 3, -3, 23, -3, 3] || 86 || 1 || 1 || 3 || {(1,5),(2,4),(4,5)} || [ 21, -3, 23, -3] || 15
109 || [ 3, -3, 23, -1, 1] || 88 || 4 || 1 || 1 || {(4,5)} || [ 3, -3, 23, 21] || 11
110 || [ 3, -3, 23, 21, 21] || 89 || 4 || 1 || 3 || {(0,4),(0,5),(4,5)} || [ 3, -3, 23, 21] || 11
111 || [ 3, -3, 23, 21, 21] || 89 || 0 || 2 || 3 || {(0,4),(0,5),(4,5)} || [ 3, -3, 23, 21] || 11
112 || [ 3, -1, 23, 3, -1] || 90 || 2 || 1 || 2 || {(1,4),(2,5)} || [ 3, 21, 23, 3] || 12
113 || [ 3, -1, 23, -1, 3] || 91 || 1 || 1 || 2 || {(1,5),(2,4)} || [ 21, -1, 23, -1] || 16
114 || [ 3, 1, 23, 3, 1] || 92 || 2 || 1 || 2 || {(1,4),(2,5)} || [ 3, 21, 23, 3] || 12
115 || [ 3, 1, 23, 1, 3] || 93 || 1 || 1 || 2 || {(1,5),(2,4)} || [ 21, 1, 23, 1] || 17
116 || [ 3, 3, 23, 3, 3] || 94 || 2 || 2 || 4 || {(1,4),(1,5),(2,4),(2,5)} || [ 3, 21, 23, 3] || 12
117 || [ 3, 3, 23, 3, 3] || 94 || 1 || 2 || 4 || {(1,4),(1,5),(2,4),(2,5)} || [ 21, 3, 23, 3] || 18
118 || [ 3, 21, 23, 21, 3] || 95 || 2 || 1 || 3 || {(0,4),(2,5),(4,5)} || [ 3, -3, 23, 21] || 11
119 || [ 3, 21, 23, 3, 21] || 96 || 4 || 1 || 3 || {(0,5),(2,4),(4,5)} || [ 3, 21, 23, 3] || 12
120 || [ 3, 21, 23, 3, 21] || 96 || 0 || 1 || 3 || {(0,5),(2,4),(4,5)} || [ 3, 21, 23, 3] || 12
121 || [ 21, -2, 23, 21, -2] || 97 || 1 || 1 || 3 || {(0,4),(1,5),(4,5)} || [ 2, -2, 23, 21] || 3
122 || [ 21, -2, 23, -2, 21] || 98 || 4 || 1 || 3 || {(0,5),(1,4),(4,5)} || [ 21, -2, 23, -2] || 13
123 || [ 21, -2, 23, -2, 21] || 98 || 0 || 1 || 3 || {(0,5),(1,4),(4,5)} || [ 21, -2, 23, -2] || 13
124 || [ 21, 2, 23, 21, 2] || 99 || 1 || 1 || 3 || {(0,4),(1,5),(4,5)} || [ -2, 2, 23, 21] || 1
125 || [ 21, 2, 23, 2, 21] || 100 || 4 || 1 || 3 || {(0,5),(1,4),(4,5)} || [ 21, 2, 23, 2] || 14
126 || [ 21, 2, 23, 2, 21] || 100 || 0 || 1 || 3 || {(0,5),(1,4),(4,5)} || [ 21, 2, 23, 2] || 14
127 || [ 21, -3, 23, 21, -3] || 101 || 1 || 1 || 3 || {(0,4),(1,5),(4,5)} || [ 3, -3, 23, 21] || 11
128 || [ 21, -3, 23, -3, 21] || 102 || 4 || 1 || 3 || {(0,5),(1,4),(4,5)} || [ 21, -3, 23, -3] || 15
129 || [ 21, -3, 23, -3, 21] || 102 || 0 || 1 || 3 || {(0,5),(1,4),(4,5)} || [ 21, -3, 23, -3] || 15
130 || [ 21, -1, 23, 21, -1] || 103 || 1 || 1 || 3 || {(0,4),(1,5),(4,5)} || [ 1, -1, 23, 21] || 9
131 || [ 21, -1, 23, -1, 21] || 104 || 4 || 1 || 3 || {(0,5),(1,4),(4,5)} || [ 21, -1, 23, -1] || 16
132 || [ 21, -1, 23, -1, 21] || 104 || 0 || 1 || 3 || {(0,5),(1,4),(4,5)} || [ 21, -1, 23, -1] || 16
133 || [ 21, 1, 23, 21, 1] || 105 || 1 || 1 || 3 || {(0,4),(1,5),(4,5)} || [ -1, 1, 23, 21] || 7
134 || [ 21, 1, 23, 1, 21] || 106 || 4 || 1 || 3 || {(0,5),(1,4),(4,5)} || [ 21, 1, 23, 1] || 17
135 || [ 21, 1, 23, 1, 21] || 106 || 0 || 1 || 3 || {(0,5),(1,4),(4,5)} || [ 21, 1, 23, 1] || 17
136 || [ 21, 3, 23, 21, 3] || 107 || 1 || 1 || 3 || {(0,4),(1,5),(4,5)} || [ -3, 3, 23, 21] || 5
137 || [ 21, 3, 23, 3, 21] || 108 || 4 || 1 || 3 || {(0,5),(1,4),(4,5)} || [ 21, 3, 23, 3] || 18
138 || [ 21, 3, 23, 3, 21] || 108 || 0 || 1 || 3 || {(0,5),(1,4),(4,5)} || [ 21, 3, 23, 3] || 18
139 || [ 21, 21, 23, -2, 2] || 109 || 1 || 1 || 4 || {(1,4),(1,5),(2,4),(2,5)} || [ -2, 21, 23, -2] || 2
140 || [ 21, 21, 23, 2, -2] || 110 || 1 || 1 || 4 || {(1,4),(1,5),(2,4),(2,5)} || [ 2, 21, 23, 2] || 4
141 || [ 21, 21, 23, -2, 2] || 109 || 2 || 1 || 4 || {(1,4),(1,5),(2,4),(2,5)} || [ 21, -2, 23, -2] || 13
142 || [ 21, 21, 23, 2, -2] || 110 || 2 || 1 || 4 || {(1,4),(1,5),(2,4),(2,5)} || [ 21, 2, 23, 2] || 14
143 || [ 21, 21, 23, -3, 3] || 111 || 1 || 1 || 4 || {(1,4),(1,5),(2,4),(2,5)} || [ -3, 21, 23, -3] || 6
144 || [ 21, 21, 23, 3, -3] || 112 || 1 || 1 || 4 || {(1,4),(1,5),(2,4),(2,5)} || [ 3, 21, 23, 3] || 12
145 || [ 21, 21, 23, -3, 3] || 111 || 2 || 1 || 4 || {(1,4),(1,5),(2,4),(2,5)} || [ 21, -3, 23, -3] || 15
146 || [ 21, 21, 23, 3, -3] || 112 || 2 || 1 || 4 || {(1,4),(1,5),(2,4),(2,5)} || [ 21, 3, 23, 3] || 18
147 || [ 21, 21, 23, -1, 1] || 113 || 1 || 1 || 4 || {(1,4),(1,5),(2,4),(2,5)} || [ -1, 21, 23, -1] || 8
148 || [ 21, 21, 23, 1, -1] || 114 || 1 || 1 || 4 || {(1,4),(1,5),(2,4),(2,5)} || [ 1, 21, 23, 1] || 10
149 || [ 21, 21, 23, -1, 1] || 113 || 2 || 1 || 4 || {(1,4),(1,5),(2,4),(2,5)} || [ 21, -1, 23, -1] || 16
150 || [ 21, 21, 23, 1, -1] || 114 || 2 || 1 || 4 || {(1,4),(1,5),(2,4),(2,5)} || [ 21, 1, 23, 1] || 17
------------------------------------------------------------------------
Contents of nlo_ppzj_sim_4_p1.debug:
========================================================================
Event #1
------------------------------------------------------------------------
Unweighted = F
Normalization = 'sigma'
Helicity handling = drop
Keep correlations = F
------------------------------------------------------------------------
Squared matrix el. (ref) = 2.59218E-11
Squared matrix el. (prc) = 5.48665E-12
Event weight (ref) = 1.08513E-10
Event weight (prc) = 2.29680E-11
------------------------------------------------------------------------
Selected MCI group = 1
Selected term = 1
Selected channel = 1
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
3918711470.0, 3219671117.0, 1835215485.0,
910317989.0, 2956387936.0, 953139539.0,
]
Beginning substream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Initial stream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 5.577290E+03
P = 0.000000E+00 0.000000E+00 5.577290E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 6.352061E+03
P = 0.000000E+00 0.000000E+00 -6.352061E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 9.227103E+02
P = 0.000000E+00 0.000000E+00 9.227103E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 1.479386E+02
P = 0.000000E+00 0.000000E+00 -1.479386E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.322367E+03
P = -6.190191E+02 -2.212434E+03 -5.889478E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 5.606984E+03
P = 6.190191E+02 2.212434E+03 5.114707E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
3837183517.0, 863385439.0, 3750118422.0,
1573947479.0, 1398293379.0, 2353965585.0,
]
Beginning substream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Initial stream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.719467E+03
P = 0.000000E+00 0.000000E+00 5.719467E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 6.483048E+03
P = 0.000000E+00 0.000000E+00 -6.483048E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 7.805329E+02
P = 0.000000E+00 0.000000E+00 7.805329E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.695224E+01
P = 0.000000E+00 0.000000E+00 -1.695224E+01
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.365877E+03
P = -7.258503E+02 -2.295642E+03 -5.892304E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 5.566539E+03
P = 5.129495E+02 2.129820E+03 5.117334E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 2.700989E+02
P = 2.129009E+02 1.658219E+02 1.139005E+01
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 6.567700474E-14
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 5.577290E+03
P = 0.000000E+00 0.000000E+00 5.577290E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 6.352061E+03
P = 0.000000E+00 0.000000E+00 -6.352061E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 9.227103E+02
P = 0.000000E+00 0.000000E+00 9.227103E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 1.479386E+02
P = 0.000000E+00 0.000000E+00 -1.479386E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.322367E+03
P = -6.190191E+02 -2.212434E+03 -5.889478E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 5.606984E+03
P = 6.190191E+02 2.212434E+03 5.114707E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(1)
E = 5.719467E+03
P = 0.000000E+00 0.000000E+00 5.719467E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 6.483048E+03
P = 0.000000E+00 0.000000E+00 -6.483048E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 7.805329E+02
P = 0.000000E+00 0.000000E+00 7.805329E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 1.695224E+01
P = 0.000000E+00 0.000000E+00 -1.695224E+01
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.365877E+03
P = -7.258503E+02 -2.295642E+03 -5.892304E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(1)
E = 5.566539E+03
P = 5.129495E+02 2.129820E+03 5.117334E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 2.700989E+02
P = 2.129009E+02 1.658219E+02 1.139005E+01
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.719467E+03
P = 0.000000E+00 0.000000E+00 5.719467E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 6.483048E+03
P = 0.000000E+00 0.000000E+00 -6.483048E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 7.805329E+02
P = 0.000000E+00 0.000000E+00 7.805329E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 1.695224E+01
P = 0.000000E+00 0.000000E+00 -1.695224E+01
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.365877E+03
P = -7.258503E+02 -2.295642E+03 -5.892304E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 5.566539E+03
P = 5.129495E+02 2.129820E+03 5.117334E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 2.700989E+02
P = 2.129009E+02 1.658219E+02 1.139005E+01
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.577290E+03
P = 0.000000E+00 0.000000E+00 5.577290E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 6.352061E+03
P = 0.000000E+00 0.000000E+00 -6.352061E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 9.227103E+02
P = 0.000000E+00 0.000000E+00 9.227103E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.479386E+02
P = 0.000000E+00 0.000000E+00 -1.479386E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 5.858846E+03
P = -5.736256E+02 -2.050193E+03 -5.457602E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 1.094967E+03
P = -6.008776E+02 9.152101E+02 -1.699223E+01
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 4.975538E+03
P = 1.174503E+03 1.134983E+03 4.699823E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.719467E+03
P = 0.000000E+00 0.000000E+00 5.719467E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 6.483048E+03
P = 0.000000E+00 0.000000E+00 -6.483048E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 7.805329E+02
P = 0.000000E+00 0.000000E+00 7.805329E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.695224E+01
P = 0.000000E+00 0.000000E+00 -1.695224E+01
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.365877E+03
P = -7.258503E+02 -2.295642E+03 -5.892304E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 5.566539E+03
P = 5.129495E+02 2.129820E+03 5.117334E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 2.700989E+02
P = 2.129009E+02 1.658219E+02 1.139005E+01
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 1.19042E+04
n_in* => 2
n_out* => 4
n_tot* => 6
$process_id* => "nlo_ppzj_sim_4_p1"
process_num_id* => [unknown integer]
sqme* => 5.48665E-12
sqme_ref* => 2.59218E-11
event_index* => 1
event_weight* => 2.29680E-11
event_weight_ref* => 1.08513E-10
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:-2|-5.5772897E+03; 0.0000000E+00, 0.0000000E+00,-5.5772897E+03| 0.0000000E+00| 3)
4 prt(i:2|-6.3520614E+03; 0.0000000E+00, 0.0000000E+00, 6.3520614E+03| 0.0000000E+00| 4)
5 prt(o:92| 9.2271026E+02; 0.0000000E+00, 0.0000000E+00, 9.2271026E+02| 0.0000000E+00| 5)
6 prt(o:-92| 1.4793862E+02; 0.0000000E+00, 0.0000000E+00,-1.4793862E+02| 0.0000000E+00| 6)
7 prt(o:23| 6.3223667E+03;-6.1901911E+02,-2.2124340E+03,-5.8894784E+03| 8.3152513E+03| 7)
8 prt(o:21| 5.6069844E+03; 6.1901911E+02, 2.2124340E+03, 5.1147068E+03| 0.0000000E+00| 8)
========================================================================
========================================================================
Event #1
------------------------------------------------------------------------
Unweighted = F
Normalization = 'sigma'
Helicity handling = drop
Keep correlations = F
------------------------------------------------------------------------
Squared matrix el. (ref) = 2.59218E-11
Squared matrix el. (prc) = 3.17087E-12
Event weight (ref) = 1.08513E-10
Event weight (prc) = 1.32738E-11
------------------------------------------------------------------------
Selected MCI group = 1
Selected term = 1
Selected channel = 1
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
3918711470.0, 3219671117.0, 1835215485.0,
910317989.0, 2956387936.0, 953139539.0,
]
Beginning substream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Initial stream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 5.577290E+03
P = 0.000000E+00 0.000000E+00 5.577290E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 6.352061E+03
P = 0.000000E+00 0.000000E+00 -6.352061E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 9.227103E+02
P = 0.000000E+00 0.000000E+00 9.227103E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 1.479386E+02
P = 0.000000E+00 0.000000E+00 -1.479386E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.322367E+03
P = -6.190191E+02 -2.212434E+03 -5.889478E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 5.606984E+03
P = 6.190191E+02 2.212434E+03 5.114707E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
3837183517.0, 863385439.0, 3750118422.0,
1573947479.0, 1398293379.0, 2353965585.0,
]
Beginning substream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Initial stream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.719467E+03
P = 0.000000E+00 0.000000E+00 5.719467E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 6.483048E+03
P = 0.000000E+00 0.000000E+00 -6.483048E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 7.805329E+02
P = 0.000000E+00 0.000000E+00 7.805329E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.695224E+01
P = 0.000000E+00 0.000000E+00 -1.695224E+01
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.365877E+03
P = -7.258503E+02 -2.295642E+03 -5.892304E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 5.566539E+03
P = 5.129495E+02 2.129820E+03 5.117334E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 2.700989E+02
P = 2.129009E+02 1.658219E+02 1.139005E+01
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 6.567700474E-14
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 5.577290E+03
P = 0.000000E+00 0.000000E+00 5.577290E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 6.352061E+03
P = 0.000000E+00 0.000000E+00 -6.352061E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 9.227103E+02
P = 0.000000E+00 0.000000E+00 9.227103E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 1.479386E+02
P = 0.000000E+00 0.000000E+00 -1.479386E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.322367E+03
P = -6.190191E+02 -2.212434E+03 -5.889478E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 5.606984E+03
P = 6.190191E+02 2.212434E+03 5.114707E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(1)
E = 5.719467E+03
P = 0.000000E+00 0.000000E+00 5.719467E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 6.483048E+03
P = 0.000000E+00 0.000000E+00 -6.483048E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 7.805329E+02
P = 0.000000E+00 0.000000E+00 7.805329E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 1.695224E+01
P = 0.000000E+00 0.000000E+00 -1.695224E+01
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.365877E+03
P = -7.258503E+02 -2.295642E+03 -5.892304E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(1)
E = 5.566539E+03
P = 5.129495E+02 2.129820E+03 5.117334E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 2.700989E+02
P = 2.129009E+02 1.658219E+02 1.139005E+01
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.719467E+03
P = 0.000000E+00 0.000000E+00 5.719467E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 6.483048E+03
P = 0.000000E+00 0.000000E+00 -6.483048E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 7.805329E+02
P = 0.000000E+00 0.000000E+00 7.805329E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 1.695224E+01
P = 0.000000E+00 0.000000E+00 -1.695224E+01
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.365877E+03
P = -7.258503E+02 -2.295642E+03 -5.892304E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 5.566539E+03
P = 5.129495E+02 2.129820E+03 5.117334E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 2.700989E+02
P = 2.129009E+02 1.658219E+02 1.139005E+01
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.577290E+03
P = 0.000000E+00 0.000000E+00 5.577290E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 6.352061E+03
P = 0.000000E+00 0.000000E+00 -6.352061E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 9.227103E+02
P = 0.000000E+00 0.000000E+00 9.227103E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.479386E+02
P = 0.000000E+00 0.000000E+00 -1.479386E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 5.858846E+03
P = -5.736256E+02 -2.050193E+03 -5.457602E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 1.094967E+03
P = -6.008776E+02 9.152101E+02 -1.699223E+01
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 4.975538E+03
P = 1.174503E+03 1.134983E+03 4.699823E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.719467E+03
P = 0.000000E+00 0.000000E+00 5.719467E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 6.483048E+03
P = 0.000000E+00 0.000000E+00 -6.483048E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 7.805329E+02
P = 0.000000E+00 0.000000E+00 7.805329E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.695224E+01
P = 0.000000E+00 0.000000E+00 -1.695224E+01
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.365877E+03
P = -7.258503E+02 -2.295642E+03 -5.892304E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 5.566539E+03
P = 5.129495E+02 2.129820E+03 5.117334E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 2.700989E+02
P = 2.129009E+02 1.658219E+02 1.139005E+01
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 1.21786E+04
n_in* => 2
n_out* => 5
n_tot* => 7
$process_id* => "nlo_ppzj_sim_4_p1"
process_num_id* => [unknown integer]
sqme* => 3.17087E-12
sqme_ref* => 2.59218E-11
event_index* => 1
event_weight* => 1.32738E-11
event_weight_ref* => 1.08513E-10
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:1|-5.7194671E+03; 0.0000000E+00, 0.0000000E+00,-5.7194671E+03| 0.0000000E+00| 3)
4 prt(i:2|-6.4830478E+03; 0.0000000E+00, 0.0000000E+00, 6.4830478E+03| 0.0000000E+00| 4)
5 prt(o:-92| 7.8053288E+02; 0.0000000E+00, 0.0000000E+00, 7.8053288E+02| 0.0000000E+00| 5)
6 prt(o:-92| 1.6952242E+01; 0.0000000E+00, 0.0000000E+00,-1.6952242E+01| 0.0000000E+00| 6)
7 prt(o:23| 6.3658773E+03;-7.2585033E+02,-2.2956416E+03,-5.8923043E+03| 8.3152513E+03| 7)
8 prt(o:1| 5.5665386E+03; 5.1294946E+02, 2.1298196E+03, 5.1173336E+03| 0.0000000E+00| 8)
9 prt(o:2| 2.7009893E+02; 2.1290087E+02, 1.6582195E+02, 1.1390052E+01| 0.0000000E+00| 9)
========================================================================
========================================================================
Event #1
------------------------------------------------------------------------
Unweighted = F
Normalization = 'sigma'
Helicity handling = drop
Keep correlations = F
------------------------------------------------------------------------
Squared matrix el. (ref) = 2.59218E-11
Squared matrix el. (prc) = 3.54041E-12
Event weight (ref) = 1.08513E-10
Event weight (prc) = 1.48207E-11
------------------------------------------------------------------------
Selected MCI group = 1
Selected term = 1
Selected channel = 1
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
3918711470.0, 3219671117.0, 1835215485.0,
910317989.0, 2956387936.0, 953139539.0,
]
Beginning substream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Initial stream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 5.577290E+03
P = 0.000000E+00 0.000000E+00 5.577290E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 6.352061E+03
P = 0.000000E+00 0.000000E+00 -6.352061E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 9.227103E+02
P = 0.000000E+00 0.000000E+00 9.227103E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 1.479386E+02
P = 0.000000E+00 0.000000E+00 -1.479386E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.322367E+03
P = -6.190191E+02 -2.212434E+03 -5.889478E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 5.606984E+03
P = 6.190191E+02 2.212434E+03 5.114707E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
3837183517.0, 863385439.0, 3750118422.0,
1573947479.0, 1398293379.0, 2353965585.0,
]
Beginning substream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Initial stream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.719467E+03
P = 0.000000E+00 0.000000E+00 5.719467E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 6.483048E+03
P = 0.000000E+00 0.000000E+00 -6.483048E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 7.805329E+02
P = 0.000000E+00 0.000000E+00 7.805329E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.695224E+01
P = 0.000000E+00 0.000000E+00 -1.695224E+01
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.365877E+03
P = -7.258503E+02 -2.295642E+03 -5.892304E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 5.566539E+03
P = 5.129495E+02 2.129820E+03 5.117334E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 2.700989E+02
P = 2.129009E+02 1.658219E+02 1.139005E+01
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 6.567700474E-14
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 5.577290E+03
P = 0.000000E+00 0.000000E+00 5.577290E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 6.352061E+03
P = 0.000000E+00 0.000000E+00 -6.352061E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 9.227103E+02
P = 0.000000E+00 0.000000E+00 9.227103E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 1.479386E+02
P = 0.000000E+00 0.000000E+00 -1.479386E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.322367E+03
P = -6.190191E+02 -2.212434E+03 -5.889478E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 5.606984E+03
P = 6.190191E+02 2.212434E+03 5.114707E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(1)
E = 5.719467E+03
P = 0.000000E+00 0.000000E+00 5.719467E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 6.483048E+03
P = 0.000000E+00 0.000000E+00 -6.483048E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 7.805329E+02
P = 0.000000E+00 0.000000E+00 7.805329E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 1.695224E+01
P = 0.000000E+00 0.000000E+00 -1.695224E+01
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.365877E+03
P = -7.258503E+02 -2.295642E+03 -5.892304E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(1)
E = 5.566539E+03
P = 5.129495E+02 2.129820E+03 5.117334E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 2.700989E+02
P = 2.129009E+02 1.658219E+02 1.139005E+01
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.719467E+03
P = 0.000000E+00 0.000000E+00 5.719467E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 6.483048E+03
P = 0.000000E+00 0.000000E+00 -6.483048E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 7.805329E+02
P = 0.000000E+00 0.000000E+00 7.805329E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 1.695224E+01
P = 0.000000E+00 0.000000E+00 -1.695224E+01
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.365877E+03
P = -7.258503E+02 -2.295642E+03 -5.892304E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 5.566539E+03
P = 5.129495E+02 2.129820E+03 5.117334E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 2.700989E+02
P = 2.129009E+02 1.658219E+02 1.139005E+01
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.577290E+03
P = 0.000000E+00 0.000000E+00 5.577290E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 6.352061E+03
P = 0.000000E+00 0.000000E+00 -6.352061E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 9.227103E+02
P = 0.000000E+00 0.000000E+00 9.227103E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.479386E+02
P = 0.000000E+00 0.000000E+00 -1.479386E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 5.858846E+03
P = -5.736256E+02 -2.050193E+03 -5.457602E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 1.094967E+03
P = -6.008776E+02 9.152101E+02 -1.699223E+01
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 4.975538E+03
P = 1.174503E+03 1.134983E+03 4.699823E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.719467E+03
P = 0.000000E+00 0.000000E+00 5.719467E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 6.483048E+03
P = 0.000000E+00 0.000000E+00 -6.483048E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 7.805329E+02
P = 0.000000E+00 0.000000E+00 7.805329E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.695224E+01
P = 0.000000E+00 0.000000E+00 -1.695224E+01
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.365877E+03
P = -7.258503E+02 -2.295642E+03 -5.892304E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 5.566539E+03
P = 5.129495E+02 2.129820E+03 5.117334E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 2.700989E+02
P = 2.129009E+02 1.658219E+02 1.139005E+01
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 1.21786E+04
n_in* => 2
n_out* => 5
n_tot* => 7
$process_id* => "nlo_ppzj_sim_4_p1"
process_num_id* => [unknown integer]
sqme* => 3.54041E-12
sqme_ref* => 2.59218E-11
event_index* => 1
event_weight* => 1.48207E-11
event_weight_ref* => 1.08513E-10
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:2|-5.7194671E+03; 0.0000000E+00, 0.0000000E+00,-5.7194671E+03| 0.0000000E+00| 3)
4 prt(i:2|-6.4830478E+03; 0.0000000E+00, 0.0000000E+00, 6.4830478E+03| 0.0000000E+00| 4)
5 prt(o:-92| 7.8053288E+02; 0.0000000E+00, 0.0000000E+00, 7.8053288E+02| 0.0000000E+00| 5)
6 prt(o:-92| 1.6952242E+01; 0.0000000E+00, 0.0000000E+00,-1.6952242E+01| 0.0000000E+00| 6)
7 prt(o:23| 6.3658773E+03;-7.2585033E+02,-2.2956416E+03,-5.8923043E+03| 8.3152513E+03| 7)
8 prt(o:2| 5.5665386E+03; 5.1294946E+02, 2.1298196E+03, 5.1173336E+03| 0.0000000E+00| 8)
9 prt(o:2| 2.7009893E+02; 2.1290087E+02, 1.6582195E+02, 1.1390052E+01| 0.0000000E+00| 9)
========================================================================
========================================================================
Event #1
------------------------------------------------------------------------
Unweighted = F
Normalization = 'sigma'
Helicity handling = drop
Keep correlations = F
------------------------------------------------------------------------
Squared matrix el. (ref) = 2.59218E-11
Squared matrix el. (prc) = 1.36582E-11
Event weight (ref) = 1.08513E-10
Event weight (prc) = 5.71755E-11
------------------------------------------------------------------------
Selected MCI group = 1
Selected term = 1
Selected channel = 1
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
3918711470.0, 3219671117.0, 1835215485.0,
910317989.0, 2956387936.0, 953139539.0,
]
Beginning substream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Initial stream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 5.577290E+03
P = 0.000000E+00 0.000000E+00 5.577290E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 6.352061E+03
P = 0.000000E+00 0.000000E+00 -6.352061E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 9.227103E+02
P = 0.000000E+00 0.000000E+00 9.227103E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 1.479386E+02
P = 0.000000E+00 0.000000E+00 -1.479386E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.322367E+03
P = -6.190191E+02 -2.212434E+03 -5.889478E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 5.606984E+03
P = 6.190191E+02 2.212434E+03 5.114707E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
3837183517.0, 863385439.0, 3750118422.0,
1573947479.0, 1398293379.0, 2353965585.0,
]
Beginning substream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Initial stream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.719467E+03
P = 0.000000E+00 0.000000E+00 5.719467E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 6.483048E+03
P = 0.000000E+00 0.000000E+00 -6.483048E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 7.805329E+02
P = 0.000000E+00 0.000000E+00 7.805329E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.695224E+01
P = 0.000000E+00 0.000000E+00 -1.695224E+01
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.365877E+03
P = -7.258503E+02 -2.295642E+03 -5.892304E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 5.566539E+03
P = 5.129495E+02 2.129820E+03 5.117334E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 2.700989E+02
P = 2.129009E+02 1.658219E+02 1.139005E+01
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 6.567700474E-14
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 5.577290E+03
P = 0.000000E+00 0.000000E+00 5.577290E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 6.352061E+03
P = 0.000000E+00 0.000000E+00 -6.352061E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 9.227103E+02
P = 0.000000E+00 0.000000E+00 9.227103E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 1.479386E+02
P = 0.000000E+00 0.000000E+00 -1.479386E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.322367E+03
P = -6.190191E+02 -2.212434E+03 -5.889478E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 5.606984E+03
P = 6.190191E+02 2.212434E+03 5.114707E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(1)
E = 5.719467E+03
P = 0.000000E+00 0.000000E+00 5.719467E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 6.483048E+03
P = 0.000000E+00 0.000000E+00 -6.483048E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 7.805329E+02
P = 0.000000E+00 0.000000E+00 7.805329E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 1.695224E+01
P = 0.000000E+00 0.000000E+00 -1.695224E+01
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.365877E+03
P = -7.258503E+02 -2.295642E+03 -5.892304E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(1)
E = 5.566539E+03
P = 5.129495E+02 2.129820E+03 5.117334E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 2.700989E+02
P = 2.129009E+02 1.658219E+02 1.139005E+01
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.719467E+03
P = 0.000000E+00 0.000000E+00 5.719467E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 6.483048E+03
P = 0.000000E+00 0.000000E+00 -6.483048E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 7.805329E+02
P = 0.000000E+00 0.000000E+00 7.805329E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 1.695224E+01
P = 0.000000E+00 0.000000E+00 -1.695224E+01
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.365877E+03
P = -7.258503E+02 -2.295642E+03 -5.892304E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 5.566539E+03
P = 5.129495E+02 2.129820E+03 5.117334E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 2.700989E+02
P = 2.129009E+02 1.658219E+02 1.139005E+01
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.577290E+03
P = 0.000000E+00 0.000000E+00 5.577290E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 6.352061E+03
P = 0.000000E+00 0.000000E+00 -6.352061E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 9.227103E+02
P = 0.000000E+00 0.000000E+00 9.227103E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.479386E+02
P = 0.000000E+00 0.000000E+00 -1.479386E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 5.858846E+03
P = -5.736256E+02 -2.050193E+03 -5.457602E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 1.094967E+03
P = -6.008776E+02 9.152101E+02 -1.699223E+01
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 4.975538E+03
P = 1.174503E+03 1.134983E+03 4.699823E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.719467E+03
P = 0.000000E+00 0.000000E+00 5.719467E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 6.483048E+03
P = 0.000000E+00 0.000000E+00 -6.483048E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 7.805329E+02
P = 0.000000E+00 0.000000E+00 7.805329E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.695224E+01
P = 0.000000E+00 0.000000E+00 -1.695224E+01
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.365877E+03
P = -7.258503E+02 -2.295642E+03 -5.892304E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 5.566539E+03
P = 5.129495E+02 2.129820E+03 5.117334E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 2.700989E+02
P = 2.129009E+02 1.658219E+02 1.139005E+01
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 1.19042E+04
n_in* => 2
n_out* => 5
n_tot* => 7
$process_id* => "nlo_ppzj_sim_4_p1"
process_num_id* => [unknown integer]
sqme* => 1.36582E-11
sqme_ref* => 2.59218E-11
event_index* => 1
event_weight* => 5.71755E-11
event_weight_ref* => 1.08513E-10
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:2|-5.5772897E+03; 0.0000000E+00, 0.0000000E+00,-5.5772897E+03| 0.0000000E+00| 3)
4 prt(i:-2|-6.3520614E+03; 0.0000000E+00, 0.0000000E+00, 6.3520614E+03| 0.0000000E+00| 4)
5 prt(o:-92| 9.2271026E+02; 0.0000000E+00, 0.0000000E+00, 9.2271026E+02| 0.0000000E+00| 5)
6 prt(o:92| 1.4793862E+02; 0.0000000E+00, 0.0000000E+00,-1.4793862E+02| 0.0000000E+00| 6)
7 prt(o:23| 5.8588461E+03;-5.7362565E+02,-2.0501934E+03,-5.4576024E+03| 8.3152513E+03| 7)
8 prt(o:-2| 1.0949667E+03;-6.0087760E+02, 9.1521009E+02,-1.6992232E+01| 0.0000000E+00| 8)
9 prt(o:2| 4.9755382E+03; 1.1745032E+03, 1.1349833E+03, 4.6998230E+03| 0.0000000E+00| 9)
========================================================================
========================================================================
Event #1
------------------------------------------------------------------------
Unweighted = F
Normalization = 'sigma'
Helicity handling = drop
Keep correlations = F
------------------------------------------------------------------------
Squared matrix el. (ref) = 2.59218E-11
Squared matrix el. (prc) = 6.56770E-14
Event weight (ref) = 1.08513E-10
Event weight (prc) = 2.74935E-13
------------------------------------------------------------------------
Selected MCI group = 1
Selected term = 1
Selected channel = 1
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
3918711470.0, 3219671117.0, 1835215485.0,
910317989.0, 2956387936.0, 953139539.0,
]
Beginning substream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Initial stream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 5.577290E+03
P = 0.000000E+00 0.000000E+00 5.577290E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 6.352061E+03
P = 0.000000E+00 0.000000E+00 -6.352061E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 9.227103E+02
P = 0.000000E+00 0.000000E+00 9.227103E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 1.479386E+02
P = 0.000000E+00 0.000000E+00 -1.479386E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.322367E+03
P = -6.190191E+02 -2.212434E+03 -5.889478E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 5.606984E+03
P = 6.190191E+02 2.212434E+03 5.114707E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
3837183517.0, 863385439.0, 3750118422.0,
1573947479.0, 1398293379.0, 2353965585.0,
]
Beginning substream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Initial stream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.719467E+03
P = 0.000000E+00 0.000000E+00 5.719467E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 6.483048E+03
P = 0.000000E+00 0.000000E+00 -6.483048E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 7.805329E+02
P = 0.000000E+00 0.000000E+00 7.805329E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.695224E+01
P = 0.000000E+00 0.000000E+00 -1.695224E+01
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.365877E+03
P = -7.258503E+02 -2.295642E+03 -5.892304E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 5.566539E+03
P = 5.129495E+02 2.129820E+03 5.117334E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 2.700989E+02
P = 2.129009E+02 1.658219E+02 1.139005E+01
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 6.567700474E-14
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 5.577290E+03
P = 0.000000E+00 0.000000E+00 5.577290E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 6.352061E+03
P = 0.000000E+00 0.000000E+00 -6.352061E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 9.227103E+02
P = 0.000000E+00 0.000000E+00 9.227103E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 1.479386E+02
P = 0.000000E+00 0.000000E+00 -1.479386E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.322367E+03
P = -6.190191E+02 -2.212434E+03 -5.889478E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 5.606984E+03
P = 6.190191E+02 2.212434E+03 5.114707E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(1)
E = 5.719467E+03
P = 0.000000E+00 0.000000E+00 5.719467E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 6.483048E+03
P = 0.000000E+00 0.000000E+00 -6.483048E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 7.805329E+02
P = 0.000000E+00 0.000000E+00 7.805329E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 1.695224E+01
P = 0.000000E+00 0.000000E+00 -1.695224E+01
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.365877E+03
P = -7.258503E+02 -2.295642E+03 -5.892304E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(1)
E = 5.566539E+03
P = 5.129495E+02 2.129820E+03 5.117334E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 2.700989E+02
P = 2.129009E+02 1.658219E+02 1.139005E+01
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.719467E+03
P = 0.000000E+00 0.000000E+00 5.719467E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 6.483048E+03
P = 0.000000E+00 0.000000E+00 -6.483048E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 7.805329E+02
P = 0.000000E+00 0.000000E+00 7.805329E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 1.695224E+01
P = 0.000000E+00 0.000000E+00 -1.695224E+01
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.365877E+03
P = -7.258503E+02 -2.295642E+03 -5.892304E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 5.566539E+03
P = 5.129495E+02 2.129820E+03 5.117334E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 2.700989E+02
P = 2.129009E+02 1.658219E+02 1.139005E+01
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.577290E+03
P = 0.000000E+00 0.000000E+00 5.577290E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 6.352061E+03
P = 0.000000E+00 0.000000E+00 -6.352061E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 9.227103E+02
P = 0.000000E+00 0.000000E+00 9.227103E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.479386E+02
P = 0.000000E+00 0.000000E+00 -1.479386E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 5.858846E+03
P = -5.736256E+02 -2.050193E+03 -5.457602E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 1.094967E+03
P = -6.008776E+02 9.152101E+02 -1.699223E+01
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 4.975538E+03
P = 1.174503E+03 1.134983E+03 4.699823E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.719467E+03
P = 0.000000E+00 0.000000E+00 5.719467E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 6.483048E+03
P = 0.000000E+00 0.000000E+00 -6.483048E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 7.805329E+02
P = 0.000000E+00 0.000000E+00 7.805329E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.695224E+01
P = 0.000000E+00 0.000000E+00 -1.695224E+01
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.365877E+03
P = -7.258503E+02 -2.295642E+03 -5.892304E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 5.566539E+03
P = 5.129495E+02 2.129820E+03 5.117334E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 2.700989E+02
P = 2.129009E+02 1.658219E+02 1.139005E+01
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 1.21786E+04
n_in* => 2
n_out* => 5
n_tot* => 7
$process_id* => "nlo_ppzj_sim_4_p1"
process_num_id* => [unknown integer]
sqme* => 6.56770E-14
sqme_ref* => 2.59218E-11
event_index* => 1
event_weight* => 2.74935E-13
event_weight_ref* => 1.08513E-10
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:2|-5.7194671E+03; 0.0000000E+00, 0.0000000E+00,-5.7194671E+03| 0.0000000E+00| 3)
4 prt(i:-2|-6.4830478E+03; 0.0000000E+00, 0.0000000E+00, 6.4830478E+03| 0.0000000E+00| 4)
5 prt(o:-92| 7.8053288E+02; 0.0000000E+00, 0.0000000E+00, 7.8053288E+02| 0.0000000E+00| 5)
6 prt(o:92| 1.6952242E+01; 0.0000000E+00, 0.0000000E+00,-1.6952242E+01| 0.0000000E+00| 6)
7 prt(o:23| 6.3658773E+03;-7.2585033E+02,-2.2956416E+03,-5.8923043E+03| 8.3152513E+03| 7)
8 prt(o:21| 5.5665386E+03; 5.1294946E+02, 2.1298196E+03, 5.1173336E+03| 0.0000000E+00| 8)
9 prt(o:21| 2.7009893E+02; 2.1290087E+02, 1.6582195E+02, 1.1390052E+01| 0.0000000E+00| 9)
========================================================================
========================================================================
Event #2
------------------------------------------------------------------------
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 = 1
Selected term = 1
Selected channel = 1
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
249063162.0, 3180624499.0, 2049528270.0,
1287817717.0, 1499479252.0, 1691198921.0,
]
Beginning substream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Initial stream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(21)
E = 1.991392E+03
P = 0.000000E+00 0.000000E+00 1.991392E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 4.706996E+03
P = 0.000000E+00 0.000000E+00 -4.706996E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(93*)
E = 4.508608E+03
P = 0.000000E+00 0.000000E+00 4.508608E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 1.793004E+03
P = 0.000000E+00 0.000000E+00 -1.793004E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.993632E+03
P = -4.363609E+01 -1.208500E+02 1.987396E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 4.704755E+03
P = 4.363609E+01 1.208500E+02 -4.703000E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
3446517234.0, 3532023251.0, 3862878338.0,
20538588.0, 1152278667.0, 344405092.0,
]
Beginning substream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Initial stream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 2.252519E+03
P = 0.000000E+00 0.000000E+00 2.252519E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 4.734315E+03
P = 0.000000E+00 0.000000E+00 -4.734315E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 4.247481E+03
P = 0.000000E+00 0.000000E+00 4.247481E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.765685E+03
P = 0.000000E+00 0.000000E+00 -1.765685E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.991986E+03
P = -7.286604E+01 -4.455541E+01 1.988064E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 4.708787E+03
P = 1.439432E+01 1.971754E+02 -4.704635E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 2.860618E+02
P = 5.847172E+01 -1.526200E+02 2.347755E+02
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 6.567700474E-14
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 1.991392E+03
P = 0.000000E+00 0.000000E+00 1.991392E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 4.706996E+03
P = 0.000000E+00 0.000000E+00 -4.706996E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 4.508608E+03
P = 0.000000E+00 0.000000E+00 4.508608E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 1.793004E+03
P = 0.000000E+00 0.000000E+00 -1.793004E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.993632E+03
P = -4.363609E+01 -1.208500E+02 1.987396E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 4.704755E+03
P = 4.363609E+01 1.208500E+02 -4.703000E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 2.252519E+03
P = 0.000000E+00 0.000000E+00 2.252519E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 4.734315E+03
P = 0.000000E+00 0.000000E+00 -4.734315E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 4.247481E+03
P = 0.000000E+00 0.000000E+00 4.247481E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.765685E+03
P = 0.000000E+00 0.000000E+00 -1.765685E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.991986E+03
P = -7.286604E+01 -4.455541E+01 1.988064E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 4.708787E+03
P = 1.439432E+01 1.971754E+02 -4.704635E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 2.860618E+02
P = 5.847172E+01 -1.526200E+02 2.347755E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 2.252519E+03
P = 0.000000E+00 0.000000E+00 2.252519E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 4.734315E+03
P = 0.000000E+00 0.000000E+00 -4.734315E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 4.247481E+03
P = 0.000000E+00 0.000000E+00 4.247481E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.765685E+03
P = 0.000000E+00 0.000000E+00 -1.765685E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.991986E+03
P = -7.286604E+01 -4.455541E+01 1.988064E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 4.708787E+03
P = 1.439432E+01 1.971754E+02 -4.704635E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 2.860618E+02
P = 5.847172E+01 -1.526200E+02 2.347755E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 1.991392E+03
P = 0.000000E+00 0.000000E+00 1.991392E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 4.706996E+03
P = 0.000000E+00 0.000000E+00 -4.706996E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 4.508608E+03
P = 0.000000E+00 0.000000E+00 4.508608E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.793004E+03
P = 0.000000E+00 0.000000E+00 -1.793004E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.980994E+03
P = -4.335905E+01 -1.200827E+02 1.974771E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 3.931290E+03
P = 3.287823E+01 2.813823E+02 -3.921069E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 7.861041E+02
P = 1.048082E+01 -1.612995E+02 -7.693064E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 2.252519E+03
P = 0.000000E+00 0.000000E+00 2.252519E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 4.734315E+03
P = 0.000000E+00 0.000000E+00 -4.734315E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 4.247481E+03
P = 0.000000E+00 0.000000E+00 4.247481E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.765685E+03
P = 0.000000E+00 0.000000E+00 -1.765685E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.991986E+03
P = -7.286604E+01 -4.455541E+01 1.988064E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 4.708787E+03
P = 1.439432E+01 1.971754E+02 -4.704635E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 2.860618E+02
P = 5.847172E+01 -1.526200E+02 2.347755E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 6.12323E+03
n_in* => 2
n_out* => 4
n_tot* => 6
$process_id* => "nlo_ppzj_sim_4_p1"
process_num_id* => [unknown integer]
sqme* => 0.00000E+00
sqme_ref* => 0.00000E+00
event_index* => 2
event_weight* => 0.00000E+00
event_weight_ref* => 0.00000E+00
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:-2|-1.9913915E+03; 0.0000000E+00, 0.0000000E+00,-1.9913915E+03| 0.0000000E+00| 3)
4 prt(i:2|-4.7069957E+03; 0.0000000E+00, 0.0000000E+00, 4.7069957E+03| 0.0000000E+00| 4)
5 prt(o:92| 4.5086085E+03; 0.0000000E+00, 0.0000000E+00, 4.5086085E+03| 0.0000000E+00| 5)
6 prt(o:-92| 1.7930043E+03; 0.0000000E+00, 0.0000000E+00,-1.7930043E+03| 0.0000000E+00| 6)
7 prt(o:23| 1.9936319E+03;-4.3636090E+01,-1.2085001E+02, 1.9873963E+03| 8.3152513E+03| 7)
8 prt(o:21| 4.7047553E+03; 4.3636090E+01, 1.2085001E+02,-4.7030005E+03| 0.0000000E+00| 8)
========================================================================
========================================================================
Event #2
------------------------------------------------------------------------
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 = 1
Selected term = 1
Selected channel = 1
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
249063162.0, 3180624499.0, 2049528270.0,
1287817717.0, 1499479252.0, 1691198921.0,
]
Beginning substream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Initial stream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(21)
E = 1.991392E+03
P = 0.000000E+00 0.000000E+00 1.991392E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 4.706996E+03
P = 0.000000E+00 0.000000E+00 -4.706996E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(93*)
E = 4.508608E+03
P = 0.000000E+00 0.000000E+00 4.508608E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 1.793004E+03
P = 0.000000E+00 0.000000E+00 -1.793004E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.993632E+03
P = -4.363609E+01 -1.208500E+02 1.987396E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 4.704755E+03
P = 4.363609E+01 1.208500E+02 -4.703000E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
3446517234.0, 3532023251.0, 3862878338.0,
20538588.0, 1152278667.0, 344405092.0,
]
Beginning substream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Initial stream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 2.252519E+03
P = 0.000000E+00 0.000000E+00 2.252519E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 4.734315E+03
P = 0.000000E+00 0.000000E+00 -4.734315E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 4.247481E+03
P = 0.000000E+00 0.000000E+00 4.247481E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.765685E+03
P = 0.000000E+00 0.000000E+00 -1.765685E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.991986E+03
P = -7.286604E+01 -4.455541E+01 1.988064E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 4.708787E+03
P = 1.439432E+01 1.971754E+02 -4.704635E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 2.860618E+02
P = 5.847172E+01 -1.526200E+02 2.347755E+02
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 6.567700474E-14
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 1.991392E+03
P = 0.000000E+00 0.000000E+00 1.991392E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 4.706996E+03
P = 0.000000E+00 0.000000E+00 -4.706996E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 4.508608E+03
P = 0.000000E+00 0.000000E+00 4.508608E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 1.793004E+03
P = 0.000000E+00 0.000000E+00 -1.793004E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.993632E+03
P = -4.363609E+01 -1.208500E+02 1.987396E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 4.704755E+03
P = 4.363609E+01 1.208500E+02 -4.703000E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 2.252519E+03
P = 0.000000E+00 0.000000E+00 2.252519E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 4.734315E+03
P = 0.000000E+00 0.000000E+00 -4.734315E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 4.247481E+03
P = 0.000000E+00 0.000000E+00 4.247481E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.765685E+03
P = 0.000000E+00 0.000000E+00 -1.765685E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.991986E+03
P = -7.286604E+01 -4.455541E+01 1.988064E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 4.708787E+03
P = 1.439432E+01 1.971754E+02 -4.704635E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 2.860618E+02
P = 5.847172E+01 -1.526200E+02 2.347755E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 2.252519E+03
P = 0.000000E+00 0.000000E+00 2.252519E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 4.734315E+03
P = 0.000000E+00 0.000000E+00 -4.734315E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 4.247481E+03
P = 0.000000E+00 0.000000E+00 4.247481E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.765685E+03
P = 0.000000E+00 0.000000E+00 -1.765685E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.991986E+03
P = -7.286604E+01 -4.455541E+01 1.988064E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 4.708787E+03
P = 1.439432E+01 1.971754E+02 -4.704635E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 2.860618E+02
P = 5.847172E+01 -1.526200E+02 2.347755E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 1.991392E+03
P = 0.000000E+00 0.000000E+00 1.991392E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 4.706996E+03
P = 0.000000E+00 0.000000E+00 -4.706996E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 4.508608E+03
P = 0.000000E+00 0.000000E+00 4.508608E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.793004E+03
P = 0.000000E+00 0.000000E+00 -1.793004E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.980994E+03
P = -4.335905E+01 -1.200827E+02 1.974771E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 3.931290E+03
P = 3.287823E+01 2.813823E+02 -3.921069E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 7.861041E+02
P = 1.048082E+01 -1.612995E+02 -7.693064E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 2.252519E+03
P = 0.000000E+00 0.000000E+00 2.252519E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 4.734315E+03
P = 0.000000E+00 0.000000E+00 -4.734315E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 4.247481E+03
P = 0.000000E+00 0.000000E+00 4.247481E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.765685E+03
P = 0.000000E+00 0.000000E+00 -1.765685E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.991986E+03
P = -7.286604E+01 -4.455541E+01 1.988064E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 4.708787E+03
P = 1.439432E+01 1.971754E+02 -4.704635E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 2.860618E+02
P = 5.847172E+01 -1.526200E+02 2.347755E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 6.53120E+03
n_in* => 2
n_out* => 5
n_tot* => 7
$process_id* => "nlo_ppzj_sim_4_p1"
process_num_id* => [unknown integer]
sqme* => 0.00000E+00
sqme_ref* => 0.00000E+00
event_index* => 2
event_weight* => 0.00000E+00
event_weight_ref* => 0.00000E+00
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:-2|-2.2525195E+03; 0.0000000E+00, 0.0000000E+00,-2.2525195E+03| 0.0000000E+00| 3)
4 prt(i:-2|-4.7343152E+03; 0.0000000E+00, 0.0000000E+00, 4.7343152E+03| 0.0000000E+00| 4)
5 prt(o:92| 4.2474805E+03; 0.0000000E+00, 0.0000000E+00, 4.2474805E+03| 0.0000000E+00| 5)
6 prt(o:92| 1.7656848E+03; 0.0000000E+00, 0.0000000E+00,-1.7656848E+03| 0.0000000E+00| 6)
7 prt(o:23| 1.9919857E+03;-7.2866043E+01,-4.4555412E+01, 1.9880637E+03| 8.3152513E+03| 7)
8 prt(o:-2| 4.7087871E+03; 1.4394325E+01, 1.9717543E+02,-4.7046350E+03| 0.0000000E+00| 8)
9 prt(o:-2| 2.8606183E+02; 5.8471718E+01,-1.5262002E+02, 2.3477555E+02| 0.0000000E+00| 9)
========================================================================
========================================================================
Event #2
------------------------------------------------------------------------
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 = 1
Selected term = 1
Selected channel = 1
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
249063162.0, 3180624499.0, 2049528270.0,
1287817717.0, 1499479252.0, 1691198921.0,
]
Beginning substream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Initial stream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(21)
E = 1.991392E+03
P = 0.000000E+00 0.000000E+00 1.991392E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 4.706996E+03
P = 0.000000E+00 0.000000E+00 -4.706996E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(93*)
E = 4.508608E+03
P = 0.000000E+00 0.000000E+00 4.508608E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 1.793004E+03
P = 0.000000E+00 0.000000E+00 -1.793004E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.993632E+03
P = -4.363609E+01 -1.208500E+02 1.987396E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 4.704755E+03
P = 4.363609E+01 1.208500E+02 -4.703000E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
3446517234.0, 3532023251.0, 3862878338.0,
20538588.0, 1152278667.0, 344405092.0,
]
Beginning substream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Initial stream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 2.252519E+03
P = 0.000000E+00 0.000000E+00 2.252519E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 4.734315E+03
P = 0.000000E+00 0.000000E+00 -4.734315E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 4.247481E+03
P = 0.000000E+00 0.000000E+00 4.247481E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.765685E+03
P = 0.000000E+00 0.000000E+00 -1.765685E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.991986E+03
P = -7.286604E+01 -4.455541E+01 1.988064E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 4.708787E+03
P = 1.439432E+01 1.971754E+02 -4.704635E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 2.860618E+02
P = 5.847172E+01 -1.526200E+02 2.347755E+02
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 6.567700474E-14
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 1.991392E+03
P = 0.000000E+00 0.000000E+00 1.991392E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 4.706996E+03
P = 0.000000E+00 0.000000E+00 -4.706996E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 4.508608E+03
P = 0.000000E+00 0.000000E+00 4.508608E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 1.793004E+03
P = 0.000000E+00 0.000000E+00 -1.793004E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.993632E+03
P = -4.363609E+01 -1.208500E+02 1.987396E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 4.704755E+03
P = 4.363609E+01 1.208500E+02 -4.703000E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 2.252519E+03
P = 0.000000E+00 0.000000E+00 2.252519E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 4.734315E+03
P = 0.000000E+00 0.000000E+00 -4.734315E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 4.247481E+03
P = 0.000000E+00 0.000000E+00 4.247481E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.765685E+03
P = 0.000000E+00 0.000000E+00 -1.765685E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.991986E+03
P = -7.286604E+01 -4.455541E+01 1.988064E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 4.708787E+03
P = 1.439432E+01 1.971754E+02 -4.704635E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 2.860618E+02
P = 5.847172E+01 -1.526200E+02 2.347755E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 2.252519E+03
P = 0.000000E+00 0.000000E+00 2.252519E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 4.734315E+03
P = 0.000000E+00 0.000000E+00 -4.734315E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 4.247481E+03
P = 0.000000E+00 0.000000E+00 4.247481E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.765685E+03
P = 0.000000E+00 0.000000E+00 -1.765685E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.991986E+03
P = -7.286604E+01 -4.455541E+01 1.988064E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 4.708787E+03
P = 1.439432E+01 1.971754E+02 -4.704635E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 2.860618E+02
P = 5.847172E+01 -1.526200E+02 2.347755E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 1.991392E+03
P = 0.000000E+00 0.000000E+00 1.991392E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 4.706996E+03
P = 0.000000E+00 0.000000E+00 -4.706996E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 4.508608E+03
P = 0.000000E+00 0.000000E+00 4.508608E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.793004E+03
P = 0.000000E+00 0.000000E+00 -1.793004E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.980994E+03
P = -4.335905E+01 -1.200827E+02 1.974771E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 3.931290E+03
P = 3.287823E+01 2.813823E+02 -3.921069E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 7.861041E+02
P = 1.048082E+01 -1.612995E+02 -7.693064E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 2.252519E+03
P = 0.000000E+00 0.000000E+00 2.252519E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 4.734315E+03
P = 0.000000E+00 0.000000E+00 -4.734315E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 4.247481E+03
P = 0.000000E+00 0.000000E+00 4.247481E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.765685E+03
P = 0.000000E+00 0.000000E+00 -1.765685E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.991986E+03
P = -7.286604E+01 -4.455541E+01 1.988064E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 4.708787E+03
P = 1.439432E+01 1.971754E+02 -4.704635E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 2.860618E+02
P = 5.847172E+01 -1.526200E+02 2.347755E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 6.53120E+03
n_in* => 2
n_out* => 5
n_tot* => 7
$process_id* => "nlo_ppzj_sim_4_p1"
process_num_id* => [unknown integer]
sqme* => 0.00000E+00
sqme_ref* => 0.00000E+00
event_index* => 2
event_weight* => 0.00000E+00
event_weight_ref* => 0.00000E+00
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:-2|-2.2525195E+03; 0.0000000E+00, 0.0000000E+00,-2.2525195E+03| 0.0000000E+00| 3)
4 prt(i:-2|-4.7343152E+03; 0.0000000E+00, 0.0000000E+00, 4.7343152E+03| 0.0000000E+00| 4)
5 prt(o:92| 4.2474805E+03; 0.0000000E+00, 0.0000000E+00, 4.2474805E+03| 0.0000000E+00| 5)
6 prt(o:92| 1.7656848E+03; 0.0000000E+00, 0.0000000E+00,-1.7656848E+03| 0.0000000E+00| 6)
7 prt(o:23| 1.9919857E+03;-7.2866043E+01,-4.4555412E+01, 1.9880637E+03| 8.3152513E+03| 7)
8 prt(o:-2| 4.7087871E+03; 1.4394325E+01, 1.9717543E+02,-4.7046350E+03| 0.0000000E+00| 8)
9 prt(o:-2| 2.8606183E+02; 5.8471718E+01,-1.5262002E+02, 2.3477555E+02| 0.0000000E+00| 9)
========================================================================
========================================================================
Event #2
------------------------------------------------------------------------
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 = 1
Selected term = 1
Selected channel = 1
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
249063162.0, 3180624499.0, 2049528270.0,
1287817717.0, 1499479252.0, 1691198921.0,
]
Beginning substream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Initial stream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(21)
E = 1.991392E+03
P = 0.000000E+00 0.000000E+00 1.991392E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 4.706996E+03
P = 0.000000E+00 0.000000E+00 -4.706996E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(93*)
E = 4.508608E+03
P = 0.000000E+00 0.000000E+00 4.508608E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 1.793004E+03
P = 0.000000E+00 0.000000E+00 -1.793004E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.993632E+03
P = -4.363609E+01 -1.208500E+02 1.987396E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 4.704755E+03
P = 4.363609E+01 1.208500E+02 -4.703000E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
3446517234.0, 3532023251.0, 3862878338.0,
20538588.0, 1152278667.0, 344405092.0,
]
Beginning substream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Initial stream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 2.252519E+03
P = 0.000000E+00 0.000000E+00 2.252519E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 4.734315E+03
P = 0.000000E+00 0.000000E+00 -4.734315E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 4.247481E+03
P = 0.000000E+00 0.000000E+00 4.247481E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.765685E+03
P = 0.000000E+00 0.000000E+00 -1.765685E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.991986E+03
P = -7.286604E+01 -4.455541E+01 1.988064E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 4.708787E+03
P = 1.439432E+01 1.971754E+02 -4.704635E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 2.860618E+02
P = 5.847172E+01 -1.526200E+02 2.347755E+02
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 6.567700474E-14
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 1.991392E+03
P = 0.000000E+00 0.000000E+00 1.991392E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 4.706996E+03
P = 0.000000E+00 0.000000E+00 -4.706996E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 4.508608E+03
P = 0.000000E+00 0.000000E+00 4.508608E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 1.793004E+03
P = 0.000000E+00 0.000000E+00 -1.793004E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.993632E+03
P = -4.363609E+01 -1.208500E+02 1.987396E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 4.704755E+03
P = 4.363609E+01 1.208500E+02 -4.703000E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 2.252519E+03
P = 0.000000E+00 0.000000E+00 2.252519E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 4.734315E+03
P = 0.000000E+00 0.000000E+00 -4.734315E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 4.247481E+03
P = 0.000000E+00 0.000000E+00 4.247481E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.765685E+03
P = 0.000000E+00 0.000000E+00 -1.765685E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.991986E+03
P = -7.286604E+01 -4.455541E+01 1.988064E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 4.708787E+03
P = 1.439432E+01 1.971754E+02 -4.704635E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 2.860618E+02
P = 5.847172E+01 -1.526200E+02 2.347755E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 2.252519E+03
P = 0.000000E+00 0.000000E+00 2.252519E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 4.734315E+03
P = 0.000000E+00 0.000000E+00 -4.734315E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 4.247481E+03
P = 0.000000E+00 0.000000E+00 4.247481E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.765685E+03
P = 0.000000E+00 0.000000E+00 -1.765685E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.991986E+03
P = -7.286604E+01 -4.455541E+01 1.988064E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 4.708787E+03
P = 1.439432E+01 1.971754E+02 -4.704635E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 2.860618E+02
P = 5.847172E+01 -1.526200E+02 2.347755E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 1.991392E+03
P = 0.000000E+00 0.000000E+00 1.991392E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 4.706996E+03
P = 0.000000E+00 0.000000E+00 -4.706996E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 4.508608E+03
P = 0.000000E+00 0.000000E+00 4.508608E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.793004E+03
P = 0.000000E+00 0.000000E+00 -1.793004E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.980994E+03
P = -4.335905E+01 -1.200827E+02 1.974771E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 3.931290E+03
P = 3.287823E+01 2.813823E+02 -3.921069E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 7.861041E+02
P = 1.048082E+01 -1.612995E+02 -7.693064E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 2.252519E+03
P = 0.000000E+00 0.000000E+00 2.252519E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 4.734315E+03
P = 0.000000E+00 0.000000E+00 -4.734315E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 4.247481E+03
P = 0.000000E+00 0.000000E+00 4.247481E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.765685E+03
P = 0.000000E+00 0.000000E+00 -1.765685E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.991986E+03
P = -7.286604E+01 -4.455541E+01 1.988064E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 4.708787E+03
P = 1.439432E+01 1.971754E+02 -4.704635E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 2.860618E+02
P = 5.847172E+01 -1.526200E+02 2.347755E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 6.12323E+03
n_in* => 2
n_out* => 5
n_tot* => 7
$process_id* => "nlo_ppzj_sim_4_p1"
process_num_id* => [unknown integer]
sqme* => 0.00000E+00
sqme_ref* => 0.00000E+00
event_index* => 2
event_weight* => 0.00000E+00
event_weight_ref* => 0.00000E+00
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:-3|-1.9913915E+03; 0.0000000E+00, 0.0000000E+00,-1.9913915E+03| 0.0000000E+00| 3)
4 prt(i:-3|-4.7069957E+03; 0.0000000E+00, 0.0000000E+00, 4.7069957E+03| 0.0000000E+00| 4)
5 prt(o:92| 4.5086085E+03; 0.0000000E+00, 0.0000000E+00, 4.5086085E+03| 0.0000000E+00| 5)
6 prt(o:92| 1.7930043E+03; 0.0000000E+00, 0.0000000E+00,-1.7930043E+03| 0.0000000E+00| 6)
7 prt(o:23| 1.9809936E+03;-4.3359051E+01,-1.2008275E+02, 1.9747710E+03| 8.3152513E+03| 7)
8 prt(o:-3| 3.9312895E+03; 3.2878231E+01, 2.8138228E+02,-3.9210688E+03| 0.0000000E+00| 8)
9 prt(o:-3| 7.8610410E+02; 1.0480820E+01,-1.6129954E+02,-7.6930635E+02| 0.0000000E+00| 9)
========================================================================
========================================================================
Event #2
------------------------------------------------------------------------
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 = 1
Selected term = 1
Selected channel = 1
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
249063162.0, 3180624499.0, 2049528270.0,
1287817717.0, 1499479252.0, 1691198921.0,
]
Beginning substream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Initial stream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(21)
E = 1.991392E+03
P = 0.000000E+00 0.000000E+00 1.991392E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 4.706996E+03
P = 0.000000E+00 0.000000E+00 -4.706996E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(93*)
E = 4.508608E+03
P = 0.000000E+00 0.000000E+00 4.508608E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 1.793004E+03
P = 0.000000E+00 0.000000E+00 -1.793004E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.993632E+03
P = -4.363609E+01 -1.208500E+02 1.987396E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 4.704755E+03
P = 4.363609E+01 1.208500E+02 -4.703000E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
3446517234.0, 3532023251.0, 3862878338.0,
20538588.0, 1152278667.0, 344405092.0,
]
Beginning substream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Initial stream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 2.252519E+03
P = 0.000000E+00 0.000000E+00 2.252519E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 4.734315E+03
P = 0.000000E+00 0.000000E+00 -4.734315E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 4.247481E+03
P = 0.000000E+00 0.000000E+00 4.247481E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.765685E+03
P = 0.000000E+00 0.000000E+00 -1.765685E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.991986E+03
P = -7.286604E+01 -4.455541E+01 1.988064E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 4.708787E+03
P = 1.439432E+01 1.971754E+02 -4.704635E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 2.860618E+02
P = 5.847172E+01 -1.526200E+02 2.347755E+02
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 6.567700474E-14
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 1.991392E+03
P = 0.000000E+00 0.000000E+00 1.991392E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(2)
E = 4.706996E+03
P = 0.000000E+00 0.000000E+00 -4.706996E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(92*)
E = 4.508608E+03
P = 0.000000E+00 0.000000E+00 4.508608E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 1.793004E+03
P = 0.000000E+00 0.000000E+00 -1.793004E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.993632E+03
P = -4.363609E+01 -1.208500E+02 1.987396E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 4.704755E+03
P = 4.363609E+01 1.208500E+02 -4.703000E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 2.252519E+03
P = 0.000000E+00 0.000000E+00 2.252519E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 4.734315E+03
P = 0.000000E+00 0.000000E+00 -4.734315E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 4.247481E+03
P = 0.000000E+00 0.000000E+00 4.247481E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.765685E+03
P = 0.000000E+00 0.000000E+00 -1.765685E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.991986E+03
P = -7.286604E+01 -4.455541E+01 1.988064E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 4.708787E+03
P = 1.439432E+01 1.971754E+02 -4.704635E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 2.860618E+02
P = 5.847172E+01 -1.526200E+02 2.347755E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 2.252519E+03
P = 0.000000E+00 0.000000E+00 2.252519E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 4.734315E+03
P = 0.000000E+00 0.000000E+00 -4.734315E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 4.247481E+03
P = 0.000000E+00 0.000000E+00 4.247481E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.765685E+03
P = 0.000000E+00 0.000000E+00 -1.765685E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.991986E+03
P = -7.286604E+01 -4.455541E+01 1.988064E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 4.708787E+03
P = 1.439432E+01 1.971754E+02 -4.704635E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 2.860618E+02
P = 5.847172E+01 -1.526200E+02 2.347755E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 1.991392E+03
P = 0.000000E+00 0.000000E+00 1.991392E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 4.706996E+03
P = 0.000000E+00 0.000000E+00 -4.706996E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 4.508608E+03
P = 0.000000E+00 0.000000E+00 4.508608E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.793004E+03
P = 0.000000E+00 0.000000E+00 -1.793004E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.980994E+03
P = -4.335905E+01 -1.200827E+02 1.974771E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 3.931290E+03
P = 3.287823E+01 2.813823E+02 -3.921069E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 7.861041E+02
P = 1.048082E+01 -1.612995E+02 -7.693064E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 2.252519E+03
P = 0.000000E+00 0.000000E+00 2.252519E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 4.734315E+03
P = 0.000000E+00 0.000000E+00 -4.734315E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 4.247481E+03
P = 0.000000E+00 0.000000E+00 4.247481E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.765685E+03
P = 0.000000E+00 0.000000E+00 -1.765685E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.991986E+03
P = -7.286604E+01 -4.455541E+01 1.988064E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 4.708787E+03
P = 1.439432E+01 1.971754E+02 -4.704635E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 2.860618E+02
P = 5.847172E+01 -1.526200E+02 2.347755E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 6.53120E+03
n_in* => 2
n_out* => 5
n_tot* => 7
$process_id* => "nlo_ppzj_sim_4_p1"
process_num_id* => [unknown integer]
sqme* => 0.00000E+00
sqme_ref* => 0.00000E+00
event_index* => 2
event_weight* => 0.00000E+00
event_weight_ref* => 0.00000E+00
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:-3|-2.2525195E+03; 0.0000000E+00, 0.0000000E+00,-2.2525195E+03| 0.0000000E+00| 3)
4 prt(i:-3|-4.7343152E+03; 0.0000000E+00, 0.0000000E+00, 4.7343152E+03| 0.0000000E+00| 4)
5 prt(o:92| 4.2474805E+03; 0.0000000E+00, 0.0000000E+00, 4.2474805E+03| 0.0000000E+00| 5)
6 prt(o:92| 1.7656848E+03; 0.0000000E+00, 0.0000000E+00,-1.7656848E+03| 0.0000000E+00| 6)
7 prt(o:23| 1.9919857E+03;-7.2866043E+01,-4.4555412E+01, 1.9880637E+03| 8.3152513E+03| 7)
8 prt(o:-3| 4.7087871E+03; 1.4394325E+01, 1.9717543E+02,-4.7046350E+03| 0.0000000E+00| 8)
9 prt(o:-3| 2.8606183E+02; 5.8471718E+01,-1.5262002E+02, 2.3477555E+02| 0.0000000E+00| 9)
========================================================================
========================================================================
Event #3
------------------------------------------------------------------------
Unweighted = F
Normalization = 'sigma'
Helicity handling = drop
Keep correlations = F
------------------------------------------------------------------------
Squared matrix el. (ref) = 1.43112E-04
Squared matrix el. (prc) = 8.68197E-05
Event weight (ref) = 1.17395E-02
Event weight (prc) = 7.12182E-03
------------------------------------------------------------------------
Selected MCI group = 1
Selected term = 1
Selected channel = 1
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
784184328.0, 816305042.0, 3316216404.0,
3118678308.0, 4016092761.0, 661603336.0,
]
Beginning substream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Initial stream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 4.966226E+03
P = 0.000000E+00 0.000000E+00 4.966226E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(-2)
E = 2.261501E+03
P = 0.000000E+00 0.000000E+00 -2.261501E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(-92*)
E = 1.533774E+03
P = 0.000000E+00 0.000000E+00 1.533774E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 4.238499E+03
P = 0.000000E+00 0.000000E+00 -4.238499E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.454281E+03
P = 4.764012E+02 1.653222E+03 -1.747879E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 4.773445E+03
P = -4.764012E+02 -1.653222E+03 4.452604E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
2355884569.0, 1770005309.0, 824852983.0,
1046209911.0, 859808400.0, 303029715.0,
]
Beginning substream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Initial stream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.803764E+03
P = 0.000000E+00 0.000000E+00 5.803764E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 2.440623E+03
P = 0.000000E+00 0.000000E+00 -2.440623E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 6.962357E+02
P = 0.000000E+00 0.000000E+00 6.962357E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 4.059377E+03
P = 0.000000E+00 0.000000E+00 -4.059377E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.583445E+03
P = 8.333371E+02 1.755841E+03 -1.699543E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 4.687231E+03
P = -1.300427E+02 -1.553644E+03 4.420341E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 9.737105E+02
P = -7.032944E+02 -2.021969E+02 6.423438E+02
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 6.624891457E-07
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(1)
E = 4.966226E+03
P = 0.000000E+00 0.000000E+00 4.966226E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(-1)
E = 2.261501E+03
P = 0.000000E+00 0.000000E+00 -2.261501E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(-92*)
E = 1.533774E+03
P = 0.000000E+00 0.000000E+00 1.533774E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 4.238499E+03
P = 0.000000E+00 0.000000E+00 -4.238499E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.454281E+03
P = 4.764012E+02 1.653222E+03 -1.747879E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 4.773445E+03
P = -4.764012E+02 -1.653222E+03 4.452604E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.803764E+03
P = 0.000000E+00 0.000000E+00 5.803764E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 2.440623E+03
P = 0.000000E+00 0.000000E+00 -2.440623E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 6.962357E+02
P = 0.000000E+00 0.000000E+00 6.962357E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 4.059377E+03
P = 0.000000E+00 0.000000E+00 -4.059377E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.583445E+03
P = 8.333371E+02 1.755841E+03 -1.699543E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 4.687231E+03
P = -1.300427E+02 -1.553644E+03 4.420341E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 9.737105E+02
P = -7.032944E+02 -2.021969E+02 6.423438E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.803764E+03
P = 0.000000E+00 0.000000E+00 5.803764E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 2.440623E+03
P = 0.000000E+00 0.000000E+00 -2.440623E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 6.962357E+02
P = 0.000000E+00 0.000000E+00 6.962357E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 4.059377E+03
P = 0.000000E+00 0.000000E+00 -4.059377E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.583445E+03
P = 8.333371E+02 1.755841E+03 -1.699543E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 4.687231E+03
P = -1.300427E+02 -1.553644E+03 4.420341E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 9.737105E+02
P = -7.032944E+02 -2.021969E+02 6.423438E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(21)
E = 4.966226E+03
P = 0.000000E+00 0.000000E+00 4.966226E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 2.261501E+03
P = 0.000000E+00 0.000000E+00 -2.261501E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(93*)
E = 1.533774E+03
P = 0.000000E+00 0.000000E+00 1.533774E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 4.238499E+03
P = 0.000000E+00 0.000000E+00 -4.238499E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.217580E+03
P = 4.304023E+02 1.493595E+03 -1.579011E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 2.172357E+03
P = -1.049780E+03 -8.387954E+01 1.900016E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 2.837789E+03
P = 6.193776E+02 -1.409716E+03 2.383720E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.803764E+03
P = 0.000000E+00 0.000000E+00 5.803764E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 2.440623E+03
P = 0.000000E+00 0.000000E+00 -2.440623E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 6.962357E+02
P = 0.000000E+00 0.000000E+00 6.962357E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 4.059377E+03
P = 0.000000E+00 0.000000E+00 -4.059377E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.583445E+03
P = 8.333371E+02 1.755841E+03 -1.699543E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 4.687231E+03
P = -1.300427E+02 -1.553644E+03 4.420341E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 9.737105E+02
P = -7.032944E+02 -2.021969E+02 6.423438E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 6.70257E+03
n_in* => 2
n_out* => 4
n_tot* => 6
$process_id* => "nlo_ppzj_sim_4_p1"
process_num_id* => [unknown integer]
sqme* => 8.68197E-05
sqme_ref* => 1.43112E-04
event_index* => 3
event_weight* => 7.12182E-03
event_weight_ref* => 1.17395E-02
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:1|-4.9662258E+03; 0.0000000E+00, 0.0000000E+00,-4.9662258E+03| 0.0000000E+00| 3)
4 prt(i:-1|-2.2615006E+03; 0.0000000E+00, 0.0000000E+00, 2.2615006E+03| 0.0000000E+00| 4)
5 prt(o:-92| 1.5337742E+03; 0.0000000E+00, 0.0000000E+00, 1.5337742E+03| 0.0000000E+00| 5)
6 prt(o:92| 4.2384994E+03; 0.0000000E+00, 0.0000000E+00,-4.2384994E+03| 0.0000000E+00| 6)
7 prt(o:23| 2.4542811E+03; 4.7640118E+02, 1.6532218E+03,-1.7478786E+03| 8.3152513E+03| 7)
8 prt(o:21| 4.7734454E+03;-4.7640118E+02,-1.6532218E+03, 4.4526038E+03| 0.0000000E+00| 8)
========================================================================
========================================================================
Event #3
------------------------------------------------------------------------
Unweighted = F
Normalization = 'sigma'
Helicity handling = drop
Keep correlations = F
------------------------------------------------------------------------
Squared matrix el. (ref) = 1.43112E-04
Squared matrix el. (prc) = 7.49754E-06
Event weight (ref) = 1.17395E-02
Event weight (prc) = 6.15023E-04
------------------------------------------------------------------------
Selected MCI group = 1
Selected term = 1
Selected channel = 1
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
784184328.0, 816305042.0, 3316216404.0,
3118678308.0, 4016092761.0, 661603336.0,
]
Beginning substream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Initial stream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 4.966226E+03
P = 0.000000E+00 0.000000E+00 4.966226E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(-2)
E = 2.261501E+03
P = 0.000000E+00 0.000000E+00 -2.261501E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(-92*)
E = 1.533774E+03
P = 0.000000E+00 0.000000E+00 1.533774E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 4.238499E+03
P = 0.000000E+00 0.000000E+00 -4.238499E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.454281E+03
P = 4.764012E+02 1.653222E+03 -1.747879E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 4.773445E+03
P = -4.764012E+02 -1.653222E+03 4.452604E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
2355884569.0, 1770005309.0, 824852983.0,
1046209911.0, 859808400.0, 303029715.0,
]
Beginning substream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Initial stream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.803764E+03
P = 0.000000E+00 0.000000E+00 5.803764E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 2.440623E+03
P = 0.000000E+00 0.000000E+00 -2.440623E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 6.962357E+02
P = 0.000000E+00 0.000000E+00 6.962357E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 4.059377E+03
P = 0.000000E+00 0.000000E+00 -4.059377E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.583445E+03
P = 8.333371E+02 1.755841E+03 -1.699543E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 4.687231E+03
P = -1.300427E+02 -1.553644E+03 4.420341E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 9.737105E+02
P = -7.032944E+02 -2.021969E+02 6.423438E+02
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 6.624891457E-07
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(1)
E = 4.966226E+03
P = 0.000000E+00 0.000000E+00 4.966226E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(-1)
E = 2.261501E+03
P = 0.000000E+00 0.000000E+00 -2.261501E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(-92*)
E = 1.533774E+03
P = 0.000000E+00 0.000000E+00 1.533774E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 4.238499E+03
P = 0.000000E+00 0.000000E+00 -4.238499E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.454281E+03
P = 4.764012E+02 1.653222E+03 -1.747879E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 4.773445E+03
P = -4.764012E+02 -1.653222E+03 4.452604E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.803764E+03
P = 0.000000E+00 0.000000E+00 5.803764E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 2.440623E+03
P = 0.000000E+00 0.000000E+00 -2.440623E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 6.962357E+02
P = 0.000000E+00 0.000000E+00 6.962357E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 4.059377E+03
P = 0.000000E+00 0.000000E+00 -4.059377E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.583445E+03
P = 8.333371E+02 1.755841E+03 -1.699543E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 4.687231E+03
P = -1.300427E+02 -1.553644E+03 4.420341E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 9.737105E+02
P = -7.032944E+02 -2.021969E+02 6.423438E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.803764E+03
P = 0.000000E+00 0.000000E+00 5.803764E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 2.440623E+03
P = 0.000000E+00 0.000000E+00 -2.440623E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 6.962357E+02
P = 0.000000E+00 0.000000E+00 6.962357E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 4.059377E+03
P = 0.000000E+00 0.000000E+00 -4.059377E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.583445E+03
P = 8.333371E+02 1.755841E+03 -1.699543E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 4.687231E+03
P = -1.300427E+02 -1.553644E+03 4.420341E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 9.737105E+02
P = -7.032944E+02 -2.021969E+02 6.423438E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(21)
E = 4.966226E+03
P = 0.000000E+00 0.000000E+00 4.966226E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 2.261501E+03
P = 0.000000E+00 0.000000E+00 -2.261501E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(93*)
E = 1.533774E+03
P = 0.000000E+00 0.000000E+00 1.533774E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 4.238499E+03
P = 0.000000E+00 0.000000E+00 -4.238499E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.217580E+03
P = 4.304023E+02 1.493595E+03 -1.579011E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 2.172357E+03
P = -1.049780E+03 -8.387954E+01 1.900016E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 2.837789E+03
P = 6.193776E+02 -1.409716E+03 2.383720E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.803764E+03
P = 0.000000E+00 0.000000E+00 5.803764E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 2.440623E+03
P = 0.000000E+00 0.000000E+00 -2.440623E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 6.962357E+02
P = 0.000000E+00 0.000000E+00 6.962357E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 4.059377E+03
P = 0.000000E+00 0.000000E+00 -4.059377E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.583445E+03
P = 8.333371E+02 1.755841E+03 -1.699543E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 4.687231E+03
P = -1.300427E+02 -1.553644E+03 4.420341E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 9.737105E+02
P = -7.032944E+02 -2.021969E+02 6.423438E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 7.52723E+03
n_in* => 2
n_out* => 5
n_tot* => 7
$process_id* => "nlo_ppzj_sim_4_p1"
process_num_id* => [unknown integer]
sqme* => 7.49754E-06
sqme_ref* => 1.43112E-04
event_index* => 3
event_weight* => 6.15023E-04
event_weight_ref* => 1.17395E-02
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:2|-5.8037643E+03; 0.0000000E+00, 0.0000000E+00,-5.8037643E+03| 0.0000000E+00| 3)
4 prt(i:2|-2.4406228E+03; 0.0000000E+00, 0.0000000E+00, 2.4406228E+03| 0.0000000E+00| 4)
5 prt(o:-92| 6.9623570E+02; 0.0000000E+00, 0.0000000E+00, 6.9623570E+02| 0.0000000E+00| 5)
6 prt(o:-92| 4.0593772E+03; 0.0000000E+00, 0.0000000E+00,-4.0593772E+03| 0.0000000E+00| 6)
7 prt(o:23| 2.5834455E+03; 8.3333711E+02, 1.7558408E+03,-1.6995433E+03| 8.3152513E+03| 7)
8 prt(o:2| 4.6872311E+03;-1.3004272E+02,-1.5536439E+03, 4.4203411E+03| 0.0000000E+00| 8)
9 prt(o:2| 9.7371049E+02;-7.0329439E+02,-2.0219686E+02, 6.4234379E+02| 0.0000000E+00| 9)
========================================================================
========================================================================
Event #3
------------------------------------------------------------------------
Unweighted = F
Normalization = 'sigma'
Helicity handling = drop
Keep correlations = F
------------------------------------------------------------------------
Squared matrix el. (ref) = 1.43112E-04
Squared matrix el. (prc) = 8.17438E-06
Event weight (ref) = 1.17395E-02
Event weight (prc) = 6.70544E-04
------------------------------------------------------------------------
Selected MCI group = 1
Selected term = 1
Selected channel = 1
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
784184328.0, 816305042.0, 3316216404.0,
3118678308.0, 4016092761.0, 661603336.0,
]
Beginning substream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Initial stream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 4.966226E+03
P = 0.000000E+00 0.000000E+00 4.966226E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(-2)
E = 2.261501E+03
P = 0.000000E+00 0.000000E+00 -2.261501E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(-92*)
E = 1.533774E+03
P = 0.000000E+00 0.000000E+00 1.533774E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 4.238499E+03
P = 0.000000E+00 0.000000E+00 -4.238499E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.454281E+03
P = 4.764012E+02 1.653222E+03 -1.747879E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 4.773445E+03
P = -4.764012E+02 -1.653222E+03 4.452604E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
2355884569.0, 1770005309.0, 824852983.0,
1046209911.0, 859808400.0, 303029715.0,
]
Beginning substream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Initial stream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.803764E+03
P = 0.000000E+00 0.000000E+00 5.803764E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 2.440623E+03
P = 0.000000E+00 0.000000E+00 -2.440623E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 6.962357E+02
P = 0.000000E+00 0.000000E+00 6.962357E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 4.059377E+03
P = 0.000000E+00 0.000000E+00 -4.059377E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.583445E+03
P = 8.333371E+02 1.755841E+03 -1.699543E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 4.687231E+03
P = -1.300427E+02 -1.553644E+03 4.420341E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 9.737105E+02
P = -7.032944E+02 -2.021969E+02 6.423438E+02
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 6.624891457E-07
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(1)
E = 4.966226E+03
P = 0.000000E+00 0.000000E+00 4.966226E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(-1)
E = 2.261501E+03
P = 0.000000E+00 0.000000E+00 -2.261501E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(-92*)
E = 1.533774E+03
P = 0.000000E+00 0.000000E+00 1.533774E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 4.238499E+03
P = 0.000000E+00 0.000000E+00 -4.238499E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.454281E+03
P = 4.764012E+02 1.653222E+03 -1.747879E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 4.773445E+03
P = -4.764012E+02 -1.653222E+03 4.452604E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.803764E+03
P = 0.000000E+00 0.000000E+00 5.803764E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 2.440623E+03
P = 0.000000E+00 0.000000E+00 -2.440623E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 6.962357E+02
P = 0.000000E+00 0.000000E+00 6.962357E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 4.059377E+03
P = 0.000000E+00 0.000000E+00 -4.059377E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.583445E+03
P = 8.333371E+02 1.755841E+03 -1.699543E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 4.687231E+03
P = -1.300427E+02 -1.553644E+03 4.420341E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 9.737105E+02
P = -7.032944E+02 -2.021969E+02 6.423438E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.803764E+03
P = 0.000000E+00 0.000000E+00 5.803764E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 2.440623E+03
P = 0.000000E+00 0.000000E+00 -2.440623E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 6.962357E+02
P = 0.000000E+00 0.000000E+00 6.962357E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 4.059377E+03
P = 0.000000E+00 0.000000E+00 -4.059377E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.583445E+03
P = 8.333371E+02 1.755841E+03 -1.699543E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 4.687231E+03
P = -1.300427E+02 -1.553644E+03 4.420341E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 9.737105E+02
P = -7.032944E+02 -2.021969E+02 6.423438E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(21)
E = 4.966226E+03
P = 0.000000E+00 0.000000E+00 4.966226E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 2.261501E+03
P = 0.000000E+00 0.000000E+00 -2.261501E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(93*)
E = 1.533774E+03
P = 0.000000E+00 0.000000E+00 1.533774E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 4.238499E+03
P = 0.000000E+00 0.000000E+00 -4.238499E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.217580E+03
P = 4.304023E+02 1.493595E+03 -1.579011E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 2.172357E+03
P = -1.049780E+03 -8.387954E+01 1.900016E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 2.837789E+03
P = 6.193776E+02 -1.409716E+03 2.383720E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.803764E+03
P = 0.000000E+00 0.000000E+00 5.803764E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 2.440623E+03
P = 0.000000E+00 0.000000E+00 -2.440623E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 6.962357E+02
P = 0.000000E+00 0.000000E+00 6.962357E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 4.059377E+03
P = 0.000000E+00 0.000000E+00 -4.059377E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.583445E+03
P = 8.333371E+02 1.755841E+03 -1.699543E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 4.687231E+03
P = -1.300427E+02 -1.553644E+03 4.420341E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 9.737105E+02
P = -7.032944E+02 -2.021969E+02 6.423438E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 7.52723E+03
n_in* => 2
n_out* => 5
n_tot* => 7
$process_id* => "nlo_ppzj_sim_4_p1"
process_num_id* => [unknown integer]
sqme* => 8.17438E-06
sqme_ref* => 1.43112E-04
event_index* => 3
event_weight* => 6.70544E-04
event_weight_ref* => 1.17395E-02
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:2|-5.8037643E+03; 0.0000000E+00, 0.0000000E+00,-5.8037643E+03| 0.0000000E+00| 3)
4 prt(i:2|-2.4406228E+03; 0.0000000E+00, 0.0000000E+00, 2.4406228E+03| 0.0000000E+00| 4)
5 prt(o:-92| 6.9623570E+02; 0.0000000E+00, 0.0000000E+00, 6.9623570E+02| 0.0000000E+00| 5)
6 prt(o:-92| 4.0593772E+03; 0.0000000E+00, 0.0000000E+00,-4.0593772E+03| 0.0000000E+00| 6)
7 prt(o:23| 2.5834455E+03; 8.3333711E+02, 1.7558408E+03,-1.6995433E+03| 8.3152513E+03| 7)
8 prt(o:2| 4.6872311E+03;-1.3004272E+02,-1.5536439E+03, 4.4203411E+03| 0.0000000E+00| 8)
9 prt(o:2| 9.7371049E+02;-7.0329439E+02,-2.0219686E+02, 6.4234379E+02| 0.0000000E+00| 9)
========================================================================
========================================================================
Event #3
------------------------------------------------------------------------
Unweighted = F
Normalization = 'sigma'
Helicity handling = drop
Keep correlations = F
------------------------------------------------------------------------
Squared matrix el. (ref) = 1.43112E-04
Squared matrix el. (prc) = 3.99584E-05
Event weight (ref) = 1.17395E-02
Event weight (prc) = 3.27779E-03
------------------------------------------------------------------------
Selected MCI group = 1
Selected term = 1
Selected channel = 1
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
784184328.0, 816305042.0, 3316216404.0,
3118678308.0, 4016092761.0, 661603336.0,
]
Beginning substream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Initial stream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 4.966226E+03
P = 0.000000E+00 0.000000E+00 4.966226E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(-2)
E = 2.261501E+03
P = 0.000000E+00 0.000000E+00 -2.261501E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(-92*)
E = 1.533774E+03
P = 0.000000E+00 0.000000E+00 1.533774E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 4.238499E+03
P = 0.000000E+00 0.000000E+00 -4.238499E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.454281E+03
P = 4.764012E+02 1.653222E+03 -1.747879E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 4.773445E+03
P = -4.764012E+02 -1.653222E+03 4.452604E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
2355884569.0, 1770005309.0, 824852983.0,
1046209911.0, 859808400.0, 303029715.0,
]
Beginning substream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Initial stream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.803764E+03
P = 0.000000E+00 0.000000E+00 5.803764E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 2.440623E+03
P = 0.000000E+00 0.000000E+00 -2.440623E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 6.962357E+02
P = 0.000000E+00 0.000000E+00 6.962357E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 4.059377E+03
P = 0.000000E+00 0.000000E+00 -4.059377E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.583445E+03
P = 8.333371E+02 1.755841E+03 -1.699543E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 4.687231E+03
P = -1.300427E+02 -1.553644E+03 4.420341E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 9.737105E+02
P = -7.032944E+02 -2.021969E+02 6.423438E+02
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 6.624891457E-07
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(1)
E = 4.966226E+03
P = 0.000000E+00 0.000000E+00 4.966226E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(-1)
E = 2.261501E+03
P = 0.000000E+00 0.000000E+00 -2.261501E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(-92*)
E = 1.533774E+03
P = 0.000000E+00 0.000000E+00 1.533774E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 4.238499E+03
P = 0.000000E+00 0.000000E+00 -4.238499E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.454281E+03
P = 4.764012E+02 1.653222E+03 -1.747879E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 4.773445E+03
P = -4.764012E+02 -1.653222E+03 4.452604E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.803764E+03
P = 0.000000E+00 0.000000E+00 5.803764E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 2.440623E+03
P = 0.000000E+00 0.000000E+00 -2.440623E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 6.962357E+02
P = 0.000000E+00 0.000000E+00 6.962357E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 4.059377E+03
P = 0.000000E+00 0.000000E+00 -4.059377E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.583445E+03
P = 8.333371E+02 1.755841E+03 -1.699543E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 4.687231E+03
P = -1.300427E+02 -1.553644E+03 4.420341E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 9.737105E+02
P = -7.032944E+02 -2.021969E+02 6.423438E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.803764E+03
P = 0.000000E+00 0.000000E+00 5.803764E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 2.440623E+03
P = 0.000000E+00 0.000000E+00 -2.440623E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 6.962357E+02
P = 0.000000E+00 0.000000E+00 6.962357E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 4.059377E+03
P = 0.000000E+00 0.000000E+00 -4.059377E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.583445E+03
P = 8.333371E+02 1.755841E+03 -1.699543E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 4.687231E+03
P = -1.300427E+02 -1.553644E+03 4.420341E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 9.737105E+02
P = -7.032944E+02 -2.021969E+02 6.423438E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(21)
E = 4.966226E+03
P = 0.000000E+00 0.000000E+00 4.966226E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 2.261501E+03
P = 0.000000E+00 0.000000E+00 -2.261501E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(93*)
E = 1.533774E+03
P = 0.000000E+00 0.000000E+00 1.533774E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 4.238499E+03
P = 0.000000E+00 0.000000E+00 -4.238499E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.217580E+03
P = 4.304023E+02 1.493595E+03 -1.579011E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 2.172357E+03
P = -1.049780E+03 -8.387954E+01 1.900016E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 2.837789E+03
P = 6.193776E+02 -1.409716E+03 2.383720E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.803764E+03
P = 0.000000E+00 0.000000E+00 5.803764E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 2.440623E+03
P = 0.000000E+00 0.000000E+00 -2.440623E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 6.962357E+02
P = 0.000000E+00 0.000000E+00 6.962357E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 4.059377E+03
P = 0.000000E+00 0.000000E+00 -4.059377E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.583445E+03
P = 8.333371E+02 1.755841E+03 -1.699543E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 4.687231E+03
P = -1.300427E+02 -1.553644E+03 4.420341E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 9.737105E+02
P = -7.032944E+02 -2.021969E+02 6.423438E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 6.70257E+03
n_in* => 2
n_out* => 5
n_tot* => 7
$process_id* => "nlo_ppzj_sim_4_p1"
process_num_id* => [unknown integer]
sqme* => 3.99584E-05
sqme_ref* => 1.43112E-04
event_index* => 3
event_weight* => 3.27779E-03
event_weight_ref* => 1.17395E-02
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:21|-4.9662258E+03; 0.0000000E+00, 0.0000000E+00,-4.9662258E+03| 0.0000000E+00| 3)
4 prt(i:2|-2.2615006E+03; 0.0000000E+00, 0.0000000E+00, 2.2615006E+03| 0.0000000E+00| 4)
5 prt(o:93| 1.5337742E+03; 0.0000000E+00, 0.0000000E+00, 1.5337742E+03| 0.0000000E+00| 5)
6 prt(o:-92| 4.2384994E+03; 0.0000000E+00, 0.0000000E+00,-4.2384994E+03| 0.0000000E+00| 6)
7 prt(o:23| 2.2175804E+03; 4.3040234E+02, 1.4935953E+03,-1.5790107E+03| 8.3152513E+03| 7)
8 prt(o:2| 2.1723566E+03;-1.0497799E+03,-8.3879539E+01, 1.9000156E+03| 0.0000000E+00| 8)
9 prt(o:21| 2.8377894E+03; 6.1937756E+02,-1.4097157E+03, 2.3837202E+03| 0.0000000E+00| 9)
========================================================================
========================================================================
Event #3
------------------------------------------------------------------------
Unweighted = F
Normalization = 'sigma'
Helicity handling = drop
Keep correlations = F
------------------------------------------------------------------------
Squared matrix el. (ref) = 1.43112E-04
Squared matrix el. (prc) = 6.62489E-07
Event weight (ref) = 1.17395E-02
Event weight (prc) = 5.43440E-05
------------------------------------------------------------------------
Selected MCI group = 1
Selected term = 1
Selected channel = 1
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
784184328.0, 816305042.0, 3316216404.0,
3118678308.0, 4016092761.0, 661603336.0,
]
Beginning substream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Initial stream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 4.966226E+03
P = 0.000000E+00 0.000000E+00 4.966226E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(-2)
E = 2.261501E+03
P = 0.000000E+00 0.000000E+00 -2.261501E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(-92*)
E = 1.533774E+03
P = 0.000000E+00 0.000000E+00 1.533774E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 4.238499E+03
P = 0.000000E+00 0.000000E+00 -4.238499E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.454281E+03
P = 4.764012E+02 1.653222E+03 -1.747879E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 4.773445E+03
P = -4.764012E+02 -1.653222E+03 4.452604E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
2355884569.0, 1770005309.0, 824852983.0,
1046209911.0, 859808400.0, 303029715.0,
]
Beginning substream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Initial stream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.803764E+03
P = 0.000000E+00 0.000000E+00 5.803764E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 2.440623E+03
P = 0.000000E+00 0.000000E+00 -2.440623E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 6.962357E+02
P = 0.000000E+00 0.000000E+00 6.962357E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 4.059377E+03
P = 0.000000E+00 0.000000E+00 -4.059377E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.583445E+03
P = 8.333371E+02 1.755841E+03 -1.699543E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 4.687231E+03
P = -1.300427E+02 -1.553644E+03 4.420341E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 9.737105E+02
P = -7.032944E+02 -2.021969E+02 6.423438E+02
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 6.624891457E-07
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(1)
E = 4.966226E+03
P = 0.000000E+00 0.000000E+00 4.966226E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(-1)
E = 2.261501E+03
P = 0.000000E+00 0.000000E+00 -2.261501E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(-92*)
E = 1.533774E+03
P = 0.000000E+00 0.000000E+00 1.533774E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 4.238499E+03
P = 0.000000E+00 0.000000E+00 -4.238499E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.454281E+03
P = 4.764012E+02 1.653222E+03 -1.747879E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 4.773445E+03
P = -4.764012E+02 -1.653222E+03 4.452604E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.803764E+03
P = 0.000000E+00 0.000000E+00 5.803764E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 2.440623E+03
P = 0.000000E+00 0.000000E+00 -2.440623E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 6.962357E+02
P = 0.000000E+00 0.000000E+00 6.962357E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 4.059377E+03
P = 0.000000E+00 0.000000E+00 -4.059377E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.583445E+03
P = 8.333371E+02 1.755841E+03 -1.699543E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 4.687231E+03
P = -1.300427E+02 -1.553644E+03 4.420341E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 9.737105E+02
P = -7.032944E+02 -2.021969E+02 6.423438E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.803764E+03
P = 0.000000E+00 0.000000E+00 5.803764E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 2.440623E+03
P = 0.000000E+00 0.000000E+00 -2.440623E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 6.962357E+02
P = 0.000000E+00 0.000000E+00 6.962357E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 4.059377E+03
P = 0.000000E+00 0.000000E+00 -4.059377E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.583445E+03
P = 8.333371E+02 1.755841E+03 -1.699543E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 4.687231E+03
P = -1.300427E+02 -1.553644E+03 4.420341E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 9.737105E+02
P = -7.032944E+02 -2.021969E+02 6.423438E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(21)
E = 4.966226E+03
P = 0.000000E+00 0.000000E+00 4.966226E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 2.261501E+03
P = 0.000000E+00 0.000000E+00 -2.261501E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(93*)
E = 1.533774E+03
P = 0.000000E+00 0.000000E+00 1.533774E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 4.238499E+03
P = 0.000000E+00 0.000000E+00 -4.238499E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.217580E+03
P = 4.304023E+02 1.493595E+03 -1.579011E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 2.172357E+03
P = -1.049780E+03 -8.387954E+01 1.900016E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 2.837789E+03
P = 6.193776E+02 -1.409716E+03 2.383720E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.803764E+03
P = 0.000000E+00 0.000000E+00 5.803764E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 2.440623E+03
P = 0.000000E+00 0.000000E+00 -2.440623E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 6.962357E+02
P = 0.000000E+00 0.000000E+00 6.962357E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 4.059377E+03
P = 0.000000E+00 0.000000E+00 -4.059377E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.583445E+03
P = 8.333371E+02 1.755841E+03 -1.699543E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 4.687231E+03
P = -1.300427E+02 -1.553644E+03 4.420341E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 9.737105E+02
P = -7.032944E+02 -2.021969E+02 6.423438E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 7.52723E+03
n_in* => 2
n_out* => 5
n_tot* => 7
$process_id* => "nlo_ppzj_sim_4_p1"
process_num_id* => [unknown integer]
sqme* => 6.62489E-07
sqme_ref* => 1.43112E-04
event_index* => 3
event_weight* => 5.43440E-05
event_weight_ref* => 1.17395E-02
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:2|-5.8037643E+03; 0.0000000E+00, 0.0000000E+00,-5.8037643E+03| 0.0000000E+00| 3)
4 prt(i:-2|-2.4406228E+03; 0.0000000E+00, 0.0000000E+00, 2.4406228E+03| 0.0000000E+00| 4)
5 prt(o:-92| 6.9623570E+02; 0.0000000E+00, 0.0000000E+00, 6.9623570E+02| 0.0000000E+00| 5)
6 prt(o:92| 4.0593772E+03; 0.0000000E+00, 0.0000000E+00,-4.0593772E+03| 0.0000000E+00| 6)
7 prt(o:23| 2.5834455E+03; 8.3333711E+02, 1.7558408E+03,-1.6995433E+03| 8.3152513E+03| 7)
8 prt(o:21| 4.6872311E+03;-1.3004272E+02,-1.5536439E+03, 4.4203411E+03| 0.0000000E+00| 8)
9 prt(o:21| 9.7371049E+02;-7.0329439E+02,-2.0219686E+02, 6.4234379E+02| 0.0000000E+00| 9)
========================================================================
========================================================================
Event #4
------------------------------------------------------------------------
Unweighted = F
Normalization = 'sigma'
Helicity handling = drop
Keep correlations = F
------------------------------------------------------------------------
Squared matrix el. (ref) = 1.73217E+00
Squared matrix el. (prc) = 0.00000E+00
Event weight (ref) = 1.11576E+01
Event weight (prc) = 0.00000E+00
------------------------------------------------------------------------
Selected MCI group = 1
Selected term = 1
Selected channel = 1
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
1455178991.0, 3824546791.0, 2370438453.0,
2582743604.0, 2955291653.0, 639724234.0,
]
Beginning substream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Initial stream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(1)
E = 2.172781E+03
P = 0.000000E+00 0.000000E+00 2.172781E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(-1)
E = 3.379386E+03
P = 0.000000E+00 0.000000E+00 -3.379386E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(-92*)
E = 4.327219E+03
P = 0.000000E+00 0.000000E+00 4.327219E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 3.120614E+03
P = 0.000000E+00 0.000000E+00 -3.120614E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 3.377048E+03
P = 2.004596E+02 -1.774682E+02 -3.365184E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 2.175119E+03
P = -2.004596E+02 1.774682E+02 2.158579E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
572568861.0, 96836838.0, 537456895.0,
924764937.0, 4278716561.0, 1575029148.0,
]
Beginning substream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Initial stream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(21)
E = 2.182891E+03
P = 0.000000E+00 0.000000E+00 2.182891E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 5.992598E+03
P = 0.000000E+00 0.000000E+00 -5.992598E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(93*)
E = 4.317109E+03
P = 0.000000E+00 0.000000E+00 4.317109E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 5.074019E+02
P = 0.000000E+00 0.000000E+00 -5.074019E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 3.368406E+03
P = 1.540592E+02 -4.783042E+01 -3.363305E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 2.190952E+03
P = -2.470384E+02 3.076046E+02 2.155138E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 2.616131E+03
P = 9.297923E+01 -2.597742E+02 -2.601540E+03
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 4.022091751E-04
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 2.172781E+03
P = 0.000000E+00 0.000000E+00 2.172781E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(21)
E = 3.379386E+03
P = 0.000000E+00 0.000000E+00 -3.379386E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(-92*)
E = 4.327219E+03
P = 0.000000E+00 0.000000E+00 4.327219E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(93*)
E = 3.120614E+03
P = 0.000000E+00 0.000000E+00 -3.120614E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 3.377048E+03
P = 2.004596E+02 -1.774682E+02 -3.365184E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 2.175119E+03
P = -2.004596E+02 1.774682E+02 2.158579E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 2.182891E+03
P = 0.000000E+00 0.000000E+00 2.182891E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 5.992598E+03
P = 0.000000E+00 0.000000E+00 -5.992598E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 4.317109E+03
P = 0.000000E+00 0.000000E+00 4.317109E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 5.074019E+02
P = 0.000000E+00 0.000000E+00 -5.074019E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 3.368406E+03
P = 1.540592E+02 -4.783042E+01 -3.363305E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 2.190952E+03
P = -2.470384E+02 3.076046E+02 2.155138E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 2.616131E+03
P = 9.297923E+01 -2.597742E+02 -2.601540E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(21)
E = 2.182891E+03
P = 0.000000E+00 0.000000E+00 2.182891E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 5.992598E+03
P = 0.000000E+00 0.000000E+00 -5.992598E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(93*)
E = 4.317109E+03
P = 0.000000E+00 0.000000E+00 4.317109E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 5.074019E+02
P = 0.000000E+00 0.000000E+00 -5.074019E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 3.368406E+03
P = 1.540592E+02 -4.783042E+01 -3.363305E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 2.190952E+03
P = -2.470384E+02 3.076046E+02 2.155138E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 2.616131E+03
P = 9.297923E+01 -2.597742E+02 -2.601540E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(21)
E = 2.172781E+03
P = 0.000000E+00 0.000000E+00 2.172781E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 3.379386E+03
P = 0.000000E+00 0.000000E+00 -3.379386E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(93*)
E = 4.327219E+03
P = 0.000000E+00 0.000000E+00 4.327219E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 3.120614E+03
P = 0.000000E+00 0.000000E+00 -3.120614E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 5.541933E+02
P = 3.233926E+01 -2.863016E+01 -5.449306E+02
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 2.409827E+03
P = 1.138478E+03 -2.115057E+03 1.940701E+02
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 2.588148E+03
P = -1.170817E+03 2.143688E+03 -8.557437E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(21)
E = 2.182891E+03
P = 0.000000E+00 0.000000E+00 2.182891E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 5.992598E+03
P = 0.000000E+00 0.000000E+00 -5.992598E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(93*)
E = 4.317109E+03
P = 0.000000E+00 0.000000E+00 4.317109E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 5.074019E+02
P = 0.000000E+00 0.000000E+00 -5.074019E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 3.368406E+03
P = 1.540592E+02 -4.783042E+01 -3.363305E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 2.190952E+03
P = -2.470384E+02 3.076046E+02 2.155138E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 2.616131E+03
P = 9.297923E+01 -2.597742E+02 -2.601540E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 5.41947E+03
n_in* => 2
n_out* => 4
n_tot* => 6
$process_id* => "nlo_ppzj_sim_4_p1"
process_num_id* => [unknown integer]
sqme* => 0.00000E+00
sqme_ref* => 1.73217E+00
event_index* => 4
event_weight* => 0.00000E+00
event_weight_ref* => 1.11576E+01
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:2|-2.1727815E+03; 0.0000000E+00, 0.0000000E+00,-2.1727815E+03| 0.0000000E+00| 3)
4 prt(i:21|-3.3793858E+03; 0.0000000E+00, 0.0000000E+00, 3.3793858E+03| 0.0000000E+00| 4)
5 prt(o:-92| 4.3272185E+03; 0.0000000E+00, 0.0000000E+00, 4.3272185E+03| 0.0000000E+00| 5)
6 prt(o:93| 3.1206142E+03; 0.0000000E+00, 0.0000000E+00,-3.1206142E+03| 0.0000000E+00| 6)
7 prt(o:23| 3.3770482E+03; 2.0045956E+02,-1.7746816E+02,-3.3651835E+03| 8.3152513E+03| 7)
8 prt(o:2| 2.1751191E+03;-2.0045956E+02, 1.7746816E+02, 2.1585792E+03| 0.0000000E+00| 8)
========================================================================
========================================================================
Event #4
------------------------------------------------------------------------
Unweighted = F
Normalization = 'sigma'
Helicity handling = drop
Keep correlations = F
------------------------------------------------------------------------
Squared matrix el. (ref) = 1.73217E+00
Squared matrix el. (prc) = 1.10967E+00
Event weight (ref) = 1.11576E+01
Event weight (prc) = 7.14780E+00
------------------------------------------------------------------------
Selected MCI group = 1
Selected term = 1
Selected channel = 1
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
1455178991.0, 3824546791.0, 2370438453.0,
2582743604.0, 2955291653.0, 639724234.0,
]
Beginning substream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Initial stream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(1)
E = 2.172781E+03
P = 0.000000E+00 0.000000E+00 2.172781E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(-1)
E = 3.379386E+03
P = 0.000000E+00 0.000000E+00 -3.379386E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(-92*)
E = 4.327219E+03
P = 0.000000E+00 0.000000E+00 4.327219E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 3.120614E+03
P = 0.000000E+00 0.000000E+00 -3.120614E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 3.377048E+03
P = 2.004596E+02 -1.774682E+02 -3.365184E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 2.175119E+03
P = -2.004596E+02 1.774682E+02 2.158579E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
572568861.0, 96836838.0, 537456895.0,
924764937.0, 4278716561.0, 1575029148.0,
]
Beginning substream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Initial stream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(21)
E = 2.182891E+03
P = 0.000000E+00 0.000000E+00 2.182891E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 5.992598E+03
P = 0.000000E+00 0.000000E+00 -5.992598E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(93*)
E = 4.317109E+03
P = 0.000000E+00 0.000000E+00 4.317109E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 5.074019E+02
P = 0.000000E+00 0.000000E+00 -5.074019E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 3.368406E+03
P = 1.540592E+02 -4.783042E+01 -3.363305E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 2.190952E+03
P = -2.470384E+02 3.076046E+02 2.155138E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 2.616131E+03
P = 9.297923E+01 -2.597742E+02 -2.601540E+03
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 4.022091751E-04
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 2.172781E+03
P = 0.000000E+00 0.000000E+00 2.172781E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(21)
E = 3.379386E+03
P = 0.000000E+00 0.000000E+00 -3.379386E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(-92*)
E = 4.327219E+03
P = 0.000000E+00 0.000000E+00 4.327219E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(93*)
E = 3.120614E+03
P = 0.000000E+00 0.000000E+00 -3.120614E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 3.377048E+03
P = 2.004596E+02 -1.774682E+02 -3.365184E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 2.175119E+03
P = -2.004596E+02 1.774682E+02 2.158579E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 2.182891E+03
P = 0.000000E+00 0.000000E+00 2.182891E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 5.992598E+03
P = 0.000000E+00 0.000000E+00 -5.992598E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 4.317109E+03
P = 0.000000E+00 0.000000E+00 4.317109E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 5.074019E+02
P = 0.000000E+00 0.000000E+00 -5.074019E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 3.368406E+03
P = 1.540592E+02 -4.783042E+01 -3.363305E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 2.190952E+03
P = -2.470384E+02 3.076046E+02 2.155138E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 2.616131E+03
P = 9.297923E+01 -2.597742E+02 -2.601540E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(21)
E = 2.182891E+03
P = 0.000000E+00 0.000000E+00 2.182891E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 5.992598E+03
P = 0.000000E+00 0.000000E+00 -5.992598E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(93*)
E = 4.317109E+03
P = 0.000000E+00 0.000000E+00 4.317109E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 5.074019E+02
P = 0.000000E+00 0.000000E+00 -5.074019E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 3.368406E+03
P = 1.540592E+02 -4.783042E+01 -3.363305E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 2.190952E+03
P = -2.470384E+02 3.076046E+02 2.155138E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 2.616131E+03
P = 9.297923E+01 -2.597742E+02 -2.601540E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(21)
E = 2.172781E+03
P = 0.000000E+00 0.000000E+00 2.172781E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 3.379386E+03
P = 0.000000E+00 0.000000E+00 -3.379386E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(93*)
E = 4.327219E+03
P = 0.000000E+00 0.000000E+00 4.327219E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 3.120614E+03
P = 0.000000E+00 0.000000E+00 -3.120614E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 5.541933E+02
P = 3.233926E+01 -2.863016E+01 -5.449306E+02
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 2.409827E+03
P = 1.138478E+03 -2.115057E+03 1.940701E+02
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 2.588148E+03
P = -1.170817E+03 2.143688E+03 -8.557437E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(21)
E = 2.182891E+03
P = 0.000000E+00 0.000000E+00 2.182891E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 5.992598E+03
P = 0.000000E+00 0.000000E+00 -5.992598E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(93*)
E = 4.317109E+03
P = 0.000000E+00 0.000000E+00 4.317109E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 5.074019E+02
P = 0.000000E+00 0.000000E+00 -5.074019E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 3.368406E+03
P = 1.540592E+02 -4.783042E+01 -3.363305E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 2.190952E+03
P = -2.470384E+02 3.076046E+02 2.155138E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 2.616131E+03
P = 9.297923E+01 -2.597742E+02 -2.601540E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 7.23358E+03
n_in* => 2
n_out* => 5
n_tot* => 7
$process_id* => "nlo_ppzj_sim_4_p1"
process_num_id* => [unknown integer]
sqme* => 1.10967E+00
sqme_ref* => 1.73217E+00
event_index* => 4
event_weight* => 7.14780E+00
event_weight_ref* => 1.11576E+01
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:2|-2.1828907E+03; 0.0000000E+00, 0.0000000E+00,-2.1828907E+03| 0.0000000E+00| 3)
4 prt(i:2|-5.9925981E+03; 0.0000000E+00, 0.0000000E+00, 5.9925981E+03| 0.0000000E+00| 4)
5 prt(o:-92| 4.3171093E+03; 0.0000000E+00, 0.0000000E+00, 4.3171093E+03| 0.0000000E+00| 5)
6 prt(o:-92| 5.0740186E+02; 0.0000000E+00, 0.0000000E+00,-5.0740186E+02| 0.0000000E+00| 6)
7 prt(o:23| 3.3684063E+03; 1.5405919E+02,-4.7830418E+01,-3.3633054E+03| 8.3152513E+03| 7)
8 prt(o:2| 2.1909519E+03;-2.4703842E+02, 3.0760460E+02, 2.1551384E+03| 0.0000000E+00| 8)
9 prt(o:2| 2.6161307E+03; 9.2979227E+01,-2.5977418E+02,-2.6015404E+03| 0.0000000E+00| 9)
========================================================================
========================================================================
Event #4
------------------------------------------------------------------------
Unweighted = F
Normalization = 'sigma'
Helicity handling = drop
Keep correlations = F
------------------------------------------------------------------------
Squared matrix el. (ref) = 1.73217E+00
Squared matrix el. (prc) = 1.06695E-02
Event weight (ref) = 1.11576E+01
Event weight (prc) = 6.87261E-02
------------------------------------------------------------------------
Selected MCI group = 1
Selected term = 1
Selected channel = 1
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
1455178991.0, 3824546791.0, 2370438453.0,
2582743604.0, 2955291653.0, 639724234.0,
]
Beginning substream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Initial stream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(1)
E = 2.172781E+03
P = 0.000000E+00 0.000000E+00 2.172781E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(-1)
E = 3.379386E+03
P = 0.000000E+00 0.000000E+00 -3.379386E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(-92*)
E = 4.327219E+03
P = 0.000000E+00 0.000000E+00 4.327219E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 3.120614E+03
P = 0.000000E+00 0.000000E+00 -3.120614E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 3.377048E+03
P = 2.004596E+02 -1.774682E+02 -3.365184E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 2.175119E+03
P = -2.004596E+02 1.774682E+02 2.158579E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
572568861.0, 96836838.0, 537456895.0,
924764937.0, 4278716561.0, 1575029148.0,
]
Beginning substream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Initial stream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(21)
E = 2.182891E+03
P = 0.000000E+00 0.000000E+00 2.182891E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 5.992598E+03
P = 0.000000E+00 0.000000E+00 -5.992598E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(93*)
E = 4.317109E+03
P = 0.000000E+00 0.000000E+00 4.317109E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 5.074019E+02
P = 0.000000E+00 0.000000E+00 -5.074019E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 3.368406E+03
P = 1.540592E+02 -4.783042E+01 -3.363305E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 2.190952E+03
P = -2.470384E+02 3.076046E+02 2.155138E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 2.616131E+03
P = 9.297923E+01 -2.597742E+02 -2.601540E+03
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 4.022091751E-04
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 2.172781E+03
P = 0.000000E+00 0.000000E+00 2.172781E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(21)
E = 3.379386E+03
P = 0.000000E+00 0.000000E+00 -3.379386E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(-92*)
E = 4.327219E+03
P = 0.000000E+00 0.000000E+00 4.327219E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(93*)
E = 3.120614E+03
P = 0.000000E+00 0.000000E+00 -3.120614E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 3.377048E+03
P = 2.004596E+02 -1.774682E+02 -3.365184E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 2.175119E+03
P = -2.004596E+02 1.774682E+02 2.158579E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 2.182891E+03
P = 0.000000E+00 0.000000E+00 2.182891E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 5.992598E+03
P = 0.000000E+00 0.000000E+00 -5.992598E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 4.317109E+03
P = 0.000000E+00 0.000000E+00 4.317109E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 5.074019E+02
P = 0.000000E+00 0.000000E+00 -5.074019E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 3.368406E+03
P = 1.540592E+02 -4.783042E+01 -3.363305E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 2.190952E+03
P = -2.470384E+02 3.076046E+02 2.155138E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 2.616131E+03
P = 9.297923E+01 -2.597742E+02 -2.601540E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(21)
E = 2.182891E+03
P = 0.000000E+00 0.000000E+00 2.182891E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 5.992598E+03
P = 0.000000E+00 0.000000E+00 -5.992598E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(93*)
E = 4.317109E+03
P = 0.000000E+00 0.000000E+00 4.317109E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 5.074019E+02
P = 0.000000E+00 0.000000E+00 -5.074019E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 3.368406E+03
P = 1.540592E+02 -4.783042E+01 -3.363305E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 2.190952E+03
P = -2.470384E+02 3.076046E+02 2.155138E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 2.616131E+03
P = 9.297923E+01 -2.597742E+02 -2.601540E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(21)
E = 2.172781E+03
P = 0.000000E+00 0.000000E+00 2.172781E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 3.379386E+03
P = 0.000000E+00 0.000000E+00 -3.379386E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(93*)
E = 4.327219E+03
P = 0.000000E+00 0.000000E+00 4.327219E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 3.120614E+03
P = 0.000000E+00 0.000000E+00 -3.120614E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 5.541933E+02
P = 3.233926E+01 -2.863016E+01 -5.449306E+02
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 2.409827E+03
P = 1.138478E+03 -2.115057E+03 1.940701E+02
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 2.588148E+03
P = -1.170817E+03 2.143688E+03 -8.557437E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(21)
E = 2.182891E+03
P = 0.000000E+00 0.000000E+00 2.182891E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 5.992598E+03
P = 0.000000E+00 0.000000E+00 -5.992598E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(93*)
E = 4.317109E+03
P = 0.000000E+00 0.000000E+00 4.317109E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 5.074019E+02
P = 0.000000E+00 0.000000E+00 -5.074019E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 3.368406E+03
P = 1.540592E+02 -4.783042E+01 -3.363305E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 2.190952E+03
P = -2.470384E+02 3.076046E+02 2.155138E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 2.616131E+03
P = 9.297923E+01 -2.597742E+02 -2.601540E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 7.23358E+03
n_in* => 2
n_out* => 5
n_tot* => 7
$process_id* => "nlo_ppzj_sim_4_p1"
process_num_id* => [unknown integer]
sqme* => 1.06695E-02
sqme_ref* => 1.73217E+00
event_index* => 4
event_weight* => 6.87261E-02
event_weight_ref* => 1.11576E+01
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:21|-2.1828907E+03; 0.0000000E+00, 0.0000000E+00,-2.1828907E+03| 0.0000000E+00| 3)
4 prt(i:2|-5.9925981E+03; 0.0000000E+00, 0.0000000E+00, 5.9925981E+03| 0.0000000E+00| 4)
5 prt(o:93| 4.3171093E+03; 0.0000000E+00, 0.0000000E+00, 4.3171093E+03| 0.0000000E+00| 5)
6 prt(o:-92| 5.0740186E+02; 0.0000000E+00, 0.0000000E+00,-5.0740186E+02| 0.0000000E+00| 6)
7 prt(o:23| 3.3684063E+03; 1.5405919E+02,-4.7830418E+01,-3.3633054E+03| 8.3152513E+03| 7)
8 prt(o:21| 2.1909519E+03;-2.4703842E+02, 3.0760460E+02, 2.1551384E+03| 0.0000000E+00| 8)
9 prt(o:2| 2.6161307E+03; 9.2979227E+01,-2.5977418E+02,-2.6015404E+03| 0.0000000E+00| 9)
========================================================================
========================================================================
Event #4
------------------------------------------------------------------------
Unweighted = F
Normalization = 'sigma'
Helicity handling = drop
Keep correlations = F
------------------------------------------------------------------------
Squared matrix el. (ref) = 1.73217E+00
Squared matrix el. (prc) = 6.11428E-01
Event weight (ref) = 1.11576E+01
Event weight (prc) = 3.93844E+00
------------------------------------------------------------------------
Selected MCI group = 1
Selected term = 1
Selected channel = 1
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
1455178991.0, 3824546791.0, 2370438453.0,
2582743604.0, 2955291653.0, 639724234.0,
]
Beginning substream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Initial stream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(1)
E = 2.172781E+03
P = 0.000000E+00 0.000000E+00 2.172781E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(-1)
E = 3.379386E+03
P = 0.000000E+00 0.000000E+00 -3.379386E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(-92*)
E = 4.327219E+03
P = 0.000000E+00 0.000000E+00 4.327219E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 3.120614E+03
P = 0.000000E+00 0.000000E+00 -3.120614E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 3.377048E+03
P = 2.004596E+02 -1.774682E+02 -3.365184E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 2.175119E+03
P = -2.004596E+02 1.774682E+02 2.158579E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
572568861.0, 96836838.0, 537456895.0,
924764937.0, 4278716561.0, 1575029148.0,
]
Beginning substream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Initial stream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(21)
E = 2.182891E+03
P = 0.000000E+00 0.000000E+00 2.182891E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 5.992598E+03
P = 0.000000E+00 0.000000E+00 -5.992598E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(93*)
E = 4.317109E+03
P = 0.000000E+00 0.000000E+00 4.317109E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 5.074019E+02
P = 0.000000E+00 0.000000E+00 -5.074019E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 3.368406E+03
P = 1.540592E+02 -4.783042E+01 -3.363305E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 2.190952E+03
P = -2.470384E+02 3.076046E+02 2.155138E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 2.616131E+03
P = 9.297923E+01 -2.597742E+02 -2.601540E+03
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 4.022091751E-04
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 2.172781E+03
P = 0.000000E+00 0.000000E+00 2.172781E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(21)
E = 3.379386E+03
P = 0.000000E+00 0.000000E+00 -3.379386E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(-92*)
E = 4.327219E+03
P = 0.000000E+00 0.000000E+00 4.327219E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(93*)
E = 3.120614E+03
P = 0.000000E+00 0.000000E+00 -3.120614E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 3.377048E+03
P = 2.004596E+02 -1.774682E+02 -3.365184E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 2.175119E+03
P = -2.004596E+02 1.774682E+02 2.158579E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 2.182891E+03
P = 0.000000E+00 0.000000E+00 2.182891E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 5.992598E+03
P = 0.000000E+00 0.000000E+00 -5.992598E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 4.317109E+03
P = 0.000000E+00 0.000000E+00 4.317109E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 5.074019E+02
P = 0.000000E+00 0.000000E+00 -5.074019E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 3.368406E+03
P = 1.540592E+02 -4.783042E+01 -3.363305E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 2.190952E+03
P = -2.470384E+02 3.076046E+02 2.155138E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 2.616131E+03
P = 9.297923E+01 -2.597742E+02 -2.601540E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(21)
E = 2.182891E+03
P = 0.000000E+00 0.000000E+00 2.182891E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 5.992598E+03
P = 0.000000E+00 0.000000E+00 -5.992598E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(93*)
E = 4.317109E+03
P = 0.000000E+00 0.000000E+00 4.317109E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 5.074019E+02
P = 0.000000E+00 0.000000E+00 -5.074019E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 3.368406E+03
P = 1.540592E+02 -4.783042E+01 -3.363305E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 2.190952E+03
P = -2.470384E+02 3.076046E+02 2.155138E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 2.616131E+03
P = 9.297923E+01 -2.597742E+02 -2.601540E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(21)
E = 2.172781E+03
P = 0.000000E+00 0.000000E+00 2.172781E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 3.379386E+03
P = 0.000000E+00 0.000000E+00 -3.379386E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(93*)
E = 4.327219E+03
P = 0.000000E+00 0.000000E+00 4.327219E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 3.120614E+03
P = 0.000000E+00 0.000000E+00 -3.120614E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 5.541933E+02
P = 3.233926E+01 -2.863016E+01 -5.449306E+02
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 2.409827E+03
P = 1.138478E+03 -2.115057E+03 1.940701E+02
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 2.588148E+03
P = -1.170817E+03 2.143688E+03 -8.557437E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(21)
E = 2.182891E+03
P = 0.000000E+00 0.000000E+00 2.182891E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 5.992598E+03
P = 0.000000E+00 0.000000E+00 -5.992598E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(93*)
E = 4.317109E+03
P = 0.000000E+00 0.000000E+00 4.317109E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 5.074019E+02
P = 0.000000E+00 0.000000E+00 -5.074019E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 3.368406E+03
P = 1.540592E+02 -4.783042E+01 -3.363305E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 2.190952E+03
P = -2.470384E+02 3.076046E+02 2.155138E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 2.616131E+03
P = 9.297923E+01 -2.597742E+02 -2.601540E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 5.41947E+03
n_in* => 2
n_out* => 5
n_tot* => 7
$process_id* => "nlo_ppzj_sim_4_p1"
process_num_id* => [unknown integer]
sqme* => 6.11428E-01
sqme_ref* => 1.73217E+00
event_index* => 4
event_weight* => 3.93844E+00
event_weight_ref* => 1.11576E+01
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:21|-2.1727815E+03; 0.0000000E+00, 0.0000000E+00,-2.1727815E+03| 0.0000000E+00| 3)
4 prt(i:2|-3.3793858E+03; 0.0000000E+00, 0.0000000E+00, 3.3793858E+03| 0.0000000E+00| 4)
5 prt(o:93| 4.3272185E+03; 0.0000000E+00, 0.0000000E+00, 4.3272185E+03| 0.0000000E+00| 5)
6 prt(o:-92| 3.1206142E+03; 0.0000000E+00, 0.0000000E+00,-3.1206142E+03| 0.0000000E+00| 6)
7 prt(o:23| 5.5419325E+02; 3.2339256E+01,-2.8630156E+01,-5.4493064E+02| 8.3152513E+03| 7)
8 prt(o:2| 2.4098265E+03; 1.1384782E+03,-2.1150575E+03, 1.9407007E+02| 0.0000000E+00| 8)
9 prt(o:21| 2.5881475E+03;-1.1708175E+03, 2.1436876E+03,-8.5574373E+02| 0.0000000E+00| 9)
========================================================================
========================================================================
Event #4
------------------------------------------------------------------------
Unweighted = F
Normalization = 'sigma'
Helicity handling = drop
Keep correlations = F
------------------------------------------------------------------------
Squared matrix el. (ref) = 1.73217E+00
Squared matrix el. (prc) = 4.02209E-04
Event weight (ref) = 1.11576E+01
Event weight (prc) = 2.59078E-03
------------------------------------------------------------------------
Selected MCI group = 1
Selected term = 1
Selected channel = 1
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
1455178991.0, 3824546791.0, 2370438453.0,
2582743604.0, 2955291653.0, 639724234.0,
]
Beginning substream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Initial stream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(1)
E = 2.172781E+03
P = 0.000000E+00 0.000000E+00 2.172781E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(-1)
E = 3.379386E+03
P = 0.000000E+00 0.000000E+00 -3.379386E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(-92*)
E = 4.327219E+03
P = 0.000000E+00 0.000000E+00 4.327219E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 3.120614E+03
P = 0.000000E+00 0.000000E+00 -3.120614E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 3.377048E+03
P = 2.004596E+02 -1.774682E+02 -3.365184E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 2.175119E+03
P = -2.004596E+02 1.774682E+02 2.158579E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
572568861.0, 96836838.0, 537456895.0,
924764937.0, 4278716561.0, 1575029148.0,
]
Beginning substream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Initial stream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(21)
E = 2.182891E+03
P = 0.000000E+00 0.000000E+00 2.182891E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 5.992598E+03
P = 0.000000E+00 0.000000E+00 -5.992598E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(93*)
E = 4.317109E+03
P = 0.000000E+00 0.000000E+00 4.317109E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 5.074019E+02
P = 0.000000E+00 0.000000E+00 -5.074019E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 3.368406E+03
P = 1.540592E+02 -4.783042E+01 -3.363305E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 2.190952E+03
P = -2.470384E+02 3.076046E+02 2.155138E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 2.616131E+03
P = 9.297923E+01 -2.597742E+02 -2.601540E+03
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 4.022091751E-04
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 2.172781E+03
P = 0.000000E+00 0.000000E+00 2.172781E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(21)
E = 3.379386E+03
P = 0.000000E+00 0.000000E+00 -3.379386E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(-92*)
E = 4.327219E+03
P = 0.000000E+00 0.000000E+00 4.327219E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(93*)
E = 3.120614E+03
P = 0.000000E+00 0.000000E+00 -3.120614E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 3.377048E+03
P = 2.004596E+02 -1.774682E+02 -3.365184E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 2.175119E+03
P = -2.004596E+02 1.774682E+02 2.158579E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 2.182891E+03
P = 0.000000E+00 0.000000E+00 2.182891E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 5.992598E+03
P = 0.000000E+00 0.000000E+00 -5.992598E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 4.317109E+03
P = 0.000000E+00 0.000000E+00 4.317109E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 5.074019E+02
P = 0.000000E+00 0.000000E+00 -5.074019E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 3.368406E+03
P = 1.540592E+02 -4.783042E+01 -3.363305E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 2.190952E+03
P = -2.470384E+02 3.076046E+02 2.155138E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 2.616131E+03
P = 9.297923E+01 -2.597742E+02 -2.601540E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(21)
E = 2.182891E+03
P = 0.000000E+00 0.000000E+00 2.182891E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 5.992598E+03
P = 0.000000E+00 0.000000E+00 -5.992598E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(93*)
E = 4.317109E+03
P = 0.000000E+00 0.000000E+00 4.317109E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 5.074019E+02
P = 0.000000E+00 0.000000E+00 -5.074019E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 3.368406E+03
P = 1.540592E+02 -4.783042E+01 -3.363305E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 2.190952E+03
P = -2.470384E+02 3.076046E+02 2.155138E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 2.616131E+03
P = 9.297923E+01 -2.597742E+02 -2.601540E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(21)
E = 2.172781E+03
P = 0.000000E+00 0.000000E+00 2.172781E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 3.379386E+03
P = 0.000000E+00 0.000000E+00 -3.379386E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(93*)
E = 4.327219E+03
P = 0.000000E+00 0.000000E+00 4.327219E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 3.120614E+03
P = 0.000000E+00 0.000000E+00 -3.120614E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 5.541933E+02
P = 3.233926E+01 -2.863016E+01 -5.449306E+02
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 2.409827E+03
P = 1.138478E+03 -2.115057E+03 1.940701E+02
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 2.588148E+03
P = -1.170817E+03 2.143688E+03 -8.557437E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(21)
E = 2.182891E+03
P = 0.000000E+00 0.000000E+00 2.182891E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 5.992598E+03
P = 0.000000E+00 0.000000E+00 -5.992598E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(93*)
E = 4.317109E+03
P = 0.000000E+00 0.000000E+00 4.317109E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 5.074019E+02
P = 0.000000E+00 0.000000E+00 -5.074019E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 3.368406E+03
P = 1.540592E+02 -4.783042E+01 -3.363305E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 2.190952E+03
P = -2.470384E+02 3.076046E+02 2.155138E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 2.616131E+03
P = 9.297923E+01 -2.597742E+02 -2.601540E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 7.23358E+03
n_in* => 2
n_out* => 5
n_tot* => 7
$process_id* => "nlo_ppzj_sim_4_p1"
process_num_id* => [unknown integer]
sqme* => 4.02209E-04
sqme_ref* => 1.73217E+00
event_index* => 4
event_weight* => 2.59078E-03
event_weight_ref* => 1.11576E+01
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:21|-2.1828907E+03; 0.0000000E+00, 0.0000000E+00,-2.1828907E+03| 0.0000000E+00| 3)
4 prt(i:2|-5.9925981E+03; 0.0000000E+00, 0.0000000E+00, 5.9925981E+03| 0.0000000E+00| 4)
5 prt(o:93| 4.3171093E+03; 0.0000000E+00, 0.0000000E+00, 4.3171093E+03| 0.0000000E+00| 5)
6 prt(o:-92| 5.0740186E+02; 0.0000000E+00, 0.0000000E+00,-5.0740186E+02| 0.0000000E+00| 6)
7 prt(o:23| 3.3684063E+03; 1.5405919E+02,-4.7830418E+01,-3.3633054E+03| 8.3152513E+03| 7)
8 prt(o:2| 2.1909519E+03;-2.4703842E+02, 3.0760460E+02, 2.1551384E+03| 0.0000000E+00| 8)
9 prt(o:21| 2.6161307E+03; 9.2979227E+01,-2.5977418E+02,-2.6015404E+03| 0.0000000E+00| 9)
========================================================================
========================================================================
Event #5
------------------------------------------------------------------------
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 = 1
Selected term = 1
Selected channel = 1
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
795611600.0, 2057298764.0, 35580411.0,
1531113698.0, 4099606364.0, 1165796235.0,
]
Beginning substream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Initial stream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 3.458129E+03
P = 0.000000E+00 0.000000E+00 3.458129E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(-2)
E = 3.683775E+01
P = 0.000000E+00 0.000000E+00 -3.683775E+01
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(-92*)
E = 3.041871E+03
P = 0.000000E+00 0.000000E+00 3.041871E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 6.463162E+03
P = 0.000000E+00 0.000000E+00 -6.463162E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.222627E+02
P = 4.559218E+01 -4.617894E+01 4.921159E+01
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 3.372704E+03
P = -4.559218E+01 4.617894E+01 3.372079E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
645088676.0, 977955169.0, 3913511931.0,
295659821.0, 2790160762.0, 3426294658.0,
]
Beginning substream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Initial stream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 4.172720E+03
P = 0.000000E+00 0.000000E+00 4.172720E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 3.785064E+01
P = 0.000000E+00 0.000000E+00 -3.785064E+01
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 2.327280E+03
P = 0.000000E+00 0.000000E+00 2.327280E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 6.462149E+03
P = 0.000000E+00 0.000000E+00 -6.462149E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.356696E+02
P = 3.575237E+01 -7.019261E+01 6.233585E+01
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 3.368185E+03
P = -5.506773E+01 2.305426E+01 3.367656E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 7.067153E+02
P = 1.931535E+01 4.713835E+01 7.048769E+02
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 4.022091751E-04
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 3.458129E+03
P = 0.000000E+00 0.000000E+00 3.458129E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(-2)
E = 3.683775E+01
P = 0.000000E+00 0.000000E+00 -3.683775E+01
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(-92*)
E = 3.041871E+03
P = 0.000000E+00 0.000000E+00 3.041871E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 6.463162E+03
P = 0.000000E+00 0.000000E+00 -6.463162E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.222627E+02
P = 4.559218E+01 -4.617894E+01 4.921159E+01
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 3.372704E+03
P = -4.559218E+01 4.617894E+01 3.372079E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 4.172720E+03
P = 0.000000E+00 0.000000E+00 4.172720E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 3.785064E+01
P = 0.000000E+00 0.000000E+00 -3.785064E+01
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 2.327280E+03
P = 0.000000E+00 0.000000E+00 2.327280E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 6.462149E+03
P = 0.000000E+00 0.000000E+00 -6.462149E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.356696E+02
P = 3.575237E+01 -7.019261E+01 6.233585E+01
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 3.368185E+03
P = -5.506773E+01 2.305426E+01 3.367656E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 7.067153E+02
P = 1.931535E+01 4.713835E+01 7.048769E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 4.172720E+03
P = 0.000000E+00 0.000000E+00 4.172720E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 3.785064E+01
P = 0.000000E+00 0.000000E+00 -3.785064E+01
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 2.327280E+03
P = 0.000000E+00 0.000000E+00 2.327280E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 6.462149E+03
P = 0.000000E+00 0.000000E+00 -6.462149E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.356696E+02
P = 3.575237E+01 -7.019261E+01 6.233585E+01
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 3.368185E+03
P = -5.506773E+01 2.305426E+01 3.367656E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 7.067153E+02
P = 1.931535E+01 4.713835E+01 7.048769E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 3.458129E+03
P = 0.000000E+00 0.000000E+00 3.458129E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 3.683775E+01
P = 0.000000E+00 0.000000E+00 -3.683775E+01
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 3.041871E+03
P = 0.000000E+00 0.000000E+00 3.041871E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 6.463162E+03
P = 0.000000E+00 0.000000E+00 -6.463162E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.220015E+02
P = 4.416246E+01 -4.473082E+01 5.116585E+01
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 2.128524E+03
P = -8.250693E+01 5.174365E+01 2.126295E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 1.244441E+03
P = 3.834447E+01 -7.012833E+00 1.243830E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 4.172720E+03
P = 0.000000E+00 0.000000E+00 4.172720E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 3.785064E+01
P = 0.000000E+00 0.000000E+00 -3.785064E+01
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 2.327280E+03
P = 0.000000E+00 0.000000E+00 2.327280E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 6.462149E+03
P = 0.000000E+00 0.000000E+00 -6.462149E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.356696E+02
P = 3.575237E+01 -7.019261E+01 6.233585E+01
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 3.368185E+03
P = -5.506773E+01 2.305426E+01 3.367656E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 7.067153E+02
P = 1.931535E+01 4.713835E+01 7.048769E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 7.13834E+02
n_in* => 2
n_out* => 4
n_tot* => 6
$process_id* => "nlo_ppzj_sim_4_p1"
process_num_id* => [unknown integer]
sqme* => 0.00000E+00
sqme_ref* => 0.00000E+00
event_index* => 5
event_weight* => 0.00000E+00
event_weight_ref* => 0.00000E+00
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:2|-3.4581288E+03; 0.0000000E+00, 0.0000000E+00,-3.4581288E+03| 0.0000000E+00| 3)
4 prt(i:-2|-3.6837746E+01; 0.0000000E+00, 0.0000000E+00, 3.6837746E+01| 0.0000000E+00| 4)
5 prt(o:-92| 3.0418712E+03; 0.0000000E+00, 0.0000000E+00, 3.0418712E+03| 0.0000000E+00| 5)
6 prt(o:92| 6.4631623E+03; 0.0000000E+00, 0.0000000E+00,-6.4631623E+03| 0.0000000E+00| 6)
7 prt(o:23| 1.2226272E+02; 4.5592183E+01,-4.6178943E+01, 4.9211585E+01| 8.3152513E+03| 7)
8 prt(o:21| 3.3727038E+03;-4.5592183E+01, 4.6178943E+01, 3.3720795E+03| 0.0000000E+00| 8)
========================================================================
========================================================================
Event #5
------------------------------------------------------------------------
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 = 1
Selected term = 1
Selected channel = 1
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
795611600.0, 2057298764.0, 35580411.0,
1531113698.0, 4099606364.0, 1165796235.0,
]
Beginning substream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Initial stream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 3.458129E+03
P = 0.000000E+00 0.000000E+00 3.458129E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(-2)
E = 3.683775E+01
P = 0.000000E+00 0.000000E+00 -3.683775E+01
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(-92*)
E = 3.041871E+03
P = 0.000000E+00 0.000000E+00 3.041871E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 6.463162E+03
P = 0.000000E+00 0.000000E+00 -6.463162E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.222627E+02
P = 4.559218E+01 -4.617894E+01 4.921159E+01
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 3.372704E+03
P = -4.559218E+01 4.617894E+01 3.372079E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
645088676.0, 977955169.0, 3913511931.0,
295659821.0, 2790160762.0, 3426294658.0,
]
Beginning substream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Initial stream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 4.172720E+03
P = 0.000000E+00 0.000000E+00 4.172720E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 3.785064E+01
P = 0.000000E+00 0.000000E+00 -3.785064E+01
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 2.327280E+03
P = 0.000000E+00 0.000000E+00 2.327280E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 6.462149E+03
P = 0.000000E+00 0.000000E+00 -6.462149E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.356696E+02
P = 3.575237E+01 -7.019261E+01 6.233585E+01
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 3.368185E+03
P = -5.506773E+01 2.305426E+01 3.367656E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 7.067153E+02
P = 1.931535E+01 4.713835E+01 7.048769E+02
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 4.022091751E-04
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 3.458129E+03
P = 0.000000E+00 0.000000E+00 3.458129E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(-2)
E = 3.683775E+01
P = 0.000000E+00 0.000000E+00 -3.683775E+01
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(-92*)
E = 3.041871E+03
P = 0.000000E+00 0.000000E+00 3.041871E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 6.463162E+03
P = 0.000000E+00 0.000000E+00 -6.463162E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.222627E+02
P = 4.559218E+01 -4.617894E+01 4.921159E+01
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 3.372704E+03
P = -4.559218E+01 4.617894E+01 3.372079E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 4.172720E+03
P = 0.000000E+00 0.000000E+00 4.172720E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 3.785064E+01
P = 0.000000E+00 0.000000E+00 -3.785064E+01
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 2.327280E+03
P = 0.000000E+00 0.000000E+00 2.327280E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 6.462149E+03
P = 0.000000E+00 0.000000E+00 -6.462149E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.356696E+02
P = 3.575237E+01 -7.019261E+01 6.233585E+01
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 3.368185E+03
P = -5.506773E+01 2.305426E+01 3.367656E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 7.067153E+02
P = 1.931535E+01 4.713835E+01 7.048769E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 4.172720E+03
P = 0.000000E+00 0.000000E+00 4.172720E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 3.785064E+01
P = 0.000000E+00 0.000000E+00 -3.785064E+01
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 2.327280E+03
P = 0.000000E+00 0.000000E+00 2.327280E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 6.462149E+03
P = 0.000000E+00 0.000000E+00 -6.462149E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.356696E+02
P = 3.575237E+01 -7.019261E+01 6.233585E+01
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 3.368185E+03
P = -5.506773E+01 2.305426E+01 3.367656E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 7.067153E+02
P = 1.931535E+01 4.713835E+01 7.048769E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 3.458129E+03
P = 0.000000E+00 0.000000E+00 3.458129E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 3.683775E+01
P = 0.000000E+00 0.000000E+00 -3.683775E+01
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 3.041871E+03
P = 0.000000E+00 0.000000E+00 3.041871E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 6.463162E+03
P = 0.000000E+00 0.000000E+00 -6.463162E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.220015E+02
P = 4.416246E+01 -4.473082E+01 5.116585E+01
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 2.128524E+03
P = -8.250693E+01 5.174365E+01 2.126295E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 1.244441E+03
P = 3.834447E+01 -7.012833E+00 1.243830E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 4.172720E+03
P = 0.000000E+00 0.000000E+00 4.172720E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 3.785064E+01
P = 0.000000E+00 0.000000E+00 -3.785064E+01
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 2.327280E+03
P = 0.000000E+00 0.000000E+00 2.327280E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 6.462149E+03
P = 0.000000E+00 0.000000E+00 -6.462149E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.356696E+02
P = 3.575237E+01 -7.019261E+01 6.233585E+01
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 3.368185E+03
P = -5.506773E+01 2.305426E+01 3.367656E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 7.067153E+02
P = 1.931535E+01 4.713835E+01 7.048769E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 7.94834E+02
n_in* => 2
n_out* => 5
n_tot* => 7
$process_id* => "nlo_ppzj_sim_4_p1"
process_num_id* => [unknown integer]
sqme* => 0.00000E+00
sqme_ref* => 0.00000E+00
event_index* => 5
event_weight* => 0.00000E+00
event_weight_ref* => 0.00000E+00
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:-2|-4.1727196E+03; 0.0000000E+00, 0.0000000E+00,-4.1727196E+03| 0.0000000E+00| 3)
4 prt(i:-2|-3.7850644E+01; 0.0000000E+00, 0.0000000E+00, 3.7850644E+01| 0.0000000E+00| 4)
5 prt(o:92| 2.3272804E+03; 0.0000000E+00, 0.0000000E+00, 2.3272804E+03| 0.0000000E+00| 5)
6 prt(o:92| 6.4621494E+03; 0.0000000E+00, 0.0000000E+00,-6.4621494E+03| 0.0000000E+00| 6)
7 prt(o:23| 1.3566962E+02; 3.5752372E+01,-7.0192608E+01, 6.2335854E+01| 8.3152513E+03| 7)
8 prt(o:-2| 3.3681853E+03;-5.5067725E+01, 2.3054260E+01, 3.3676562E+03| 0.0000000E+00| 8)
9 prt(o:-2| 7.0671532E+02; 1.9315353E+01, 4.7138348E+01, 7.0487689E+02| 0.0000000E+00| 9)
========================================================================
========================================================================
Event #5
------------------------------------------------------------------------
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 = 1
Selected term = 1
Selected channel = 1
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
795611600.0, 2057298764.0, 35580411.0,
1531113698.0, 4099606364.0, 1165796235.0,
]
Beginning substream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Initial stream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 3.458129E+03
P = 0.000000E+00 0.000000E+00 3.458129E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(-2)
E = 3.683775E+01
P = 0.000000E+00 0.000000E+00 -3.683775E+01
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(-92*)
E = 3.041871E+03
P = 0.000000E+00 0.000000E+00 3.041871E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 6.463162E+03
P = 0.000000E+00 0.000000E+00 -6.463162E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.222627E+02
P = 4.559218E+01 -4.617894E+01 4.921159E+01
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 3.372704E+03
P = -4.559218E+01 4.617894E+01 3.372079E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
645088676.0, 977955169.0, 3913511931.0,
295659821.0, 2790160762.0, 3426294658.0,
]
Beginning substream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Initial stream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 4.172720E+03
P = 0.000000E+00 0.000000E+00 4.172720E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 3.785064E+01
P = 0.000000E+00 0.000000E+00 -3.785064E+01
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 2.327280E+03
P = 0.000000E+00 0.000000E+00 2.327280E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 6.462149E+03
P = 0.000000E+00 0.000000E+00 -6.462149E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.356696E+02
P = 3.575237E+01 -7.019261E+01 6.233585E+01
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 3.368185E+03
P = -5.506773E+01 2.305426E+01 3.367656E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 7.067153E+02
P = 1.931535E+01 4.713835E+01 7.048769E+02
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 4.022091751E-04
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 3.458129E+03
P = 0.000000E+00 0.000000E+00 3.458129E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(-2)
E = 3.683775E+01
P = 0.000000E+00 0.000000E+00 -3.683775E+01
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(-92*)
E = 3.041871E+03
P = 0.000000E+00 0.000000E+00 3.041871E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 6.463162E+03
P = 0.000000E+00 0.000000E+00 -6.463162E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.222627E+02
P = 4.559218E+01 -4.617894E+01 4.921159E+01
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 3.372704E+03
P = -4.559218E+01 4.617894E+01 3.372079E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 4.172720E+03
P = 0.000000E+00 0.000000E+00 4.172720E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 3.785064E+01
P = 0.000000E+00 0.000000E+00 -3.785064E+01
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 2.327280E+03
P = 0.000000E+00 0.000000E+00 2.327280E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 6.462149E+03
P = 0.000000E+00 0.000000E+00 -6.462149E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.356696E+02
P = 3.575237E+01 -7.019261E+01 6.233585E+01
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 3.368185E+03
P = -5.506773E+01 2.305426E+01 3.367656E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 7.067153E+02
P = 1.931535E+01 4.713835E+01 7.048769E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 4.172720E+03
P = 0.000000E+00 0.000000E+00 4.172720E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 3.785064E+01
P = 0.000000E+00 0.000000E+00 -3.785064E+01
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 2.327280E+03
P = 0.000000E+00 0.000000E+00 2.327280E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 6.462149E+03
P = 0.000000E+00 0.000000E+00 -6.462149E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.356696E+02
P = 3.575237E+01 -7.019261E+01 6.233585E+01
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 3.368185E+03
P = -5.506773E+01 2.305426E+01 3.367656E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 7.067153E+02
P = 1.931535E+01 4.713835E+01 7.048769E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 3.458129E+03
P = 0.000000E+00 0.000000E+00 3.458129E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 3.683775E+01
P = 0.000000E+00 0.000000E+00 -3.683775E+01
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 3.041871E+03
P = 0.000000E+00 0.000000E+00 3.041871E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 6.463162E+03
P = 0.000000E+00 0.000000E+00 -6.463162E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.220015E+02
P = 4.416246E+01 -4.473082E+01 5.116585E+01
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 2.128524E+03
P = -8.250693E+01 5.174365E+01 2.126295E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 1.244441E+03
P = 3.834447E+01 -7.012833E+00 1.243830E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 4.172720E+03
P = 0.000000E+00 0.000000E+00 4.172720E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 3.785064E+01
P = 0.000000E+00 0.000000E+00 -3.785064E+01
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 2.327280E+03
P = 0.000000E+00 0.000000E+00 2.327280E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 6.462149E+03
P = 0.000000E+00 0.000000E+00 -6.462149E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.356696E+02
P = 3.575237E+01 -7.019261E+01 6.233585E+01
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 3.368185E+03
P = -5.506773E+01 2.305426E+01 3.367656E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 7.067153E+02
P = 1.931535E+01 4.713835E+01 7.048769E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 7.94834E+02
n_in* => 2
n_out* => 5
n_tot* => 7
$process_id* => "nlo_ppzj_sim_4_p1"
process_num_id* => [unknown integer]
sqme* => 0.00000E+00
sqme_ref* => 0.00000E+00
event_index* => 5
event_weight* => 0.00000E+00
event_weight_ref* => 0.00000E+00
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:-2|-4.1727196E+03; 0.0000000E+00, 0.0000000E+00,-4.1727196E+03| 0.0000000E+00| 3)
4 prt(i:-2|-3.7850644E+01; 0.0000000E+00, 0.0000000E+00, 3.7850644E+01| 0.0000000E+00| 4)
5 prt(o:92| 2.3272804E+03; 0.0000000E+00, 0.0000000E+00, 2.3272804E+03| 0.0000000E+00| 5)
6 prt(o:92| 6.4621494E+03; 0.0000000E+00, 0.0000000E+00,-6.4621494E+03| 0.0000000E+00| 6)
7 prt(o:23| 1.3566962E+02; 3.5752372E+01,-7.0192608E+01, 6.2335854E+01| 8.3152513E+03| 7)
8 prt(o:-2| 3.3681853E+03;-5.5067725E+01, 2.3054260E+01, 3.3676562E+03| 0.0000000E+00| 8)
9 prt(o:-2| 7.0671532E+02; 1.9315353E+01, 4.7138348E+01, 7.0487689E+02| 0.0000000E+00| 9)
========================================================================
========================================================================
Event #5
------------------------------------------------------------------------
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 = 1
Selected term = 1
Selected channel = 1
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
795611600.0, 2057298764.0, 35580411.0,
1531113698.0, 4099606364.0, 1165796235.0,
]
Beginning substream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Initial stream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 3.458129E+03
P = 0.000000E+00 0.000000E+00 3.458129E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(-2)
E = 3.683775E+01
P = 0.000000E+00 0.000000E+00 -3.683775E+01
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(-92*)
E = 3.041871E+03
P = 0.000000E+00 0.000000E+00 3.041871E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 6.463162E+03
P = 0.000000E+00 0.000000E+00 -6.463162E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.222627E+02
P = 4.559218E+01 -4.617894E+01 4.921159E+01
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 3.372704E+03
P = -4.559218E+01 4.617894E+01 3.372079E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
645088676.0, 977955169.0, 3913511931.0,
295659821.0, 2790160762.0, 3426294658.0,
]
Beginning substream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Initial stream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 4.172720E+03
P = 0.000000E+00 0.000000E+00 4.172720E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 3.785064E+01
P = 0.000000E+00 0.000000E+00 -3.785064E+01
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 2.327280E+03
P = 0.000000E+00 0.000000E+00 2.327280E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 6.462149E+03
P = 0.000000E+00 0.000000E+00 -6.462149E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.356696E+02
P = 3.575237E+01 -7.019261E+01 6.233585E+01
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 3.368185E+03
P = -5.506773E+01 2.305426E+01 3.367656E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 7.067153E+02
P = 1.931535E+01 4.713835E+01 7.048769E+02
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 4.022091751E-04
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 3.458129E+03
P = 0.000000E+00 0.000000E+00 3.458129E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(-2)
E = 3.683775E+01
P = 0.000000E+00 0.000000E+00 -3.683775E+01
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(-92*)
E = 3.041871E+03
P = 0.000000E+00 0.000000E+00 3.041871E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 6.463162E+03
P = 0.000000E+00 0.000000E+00 -6.463162E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.222627E+02
P = 4.559218E+01 -4.617894E+01 4.921159E+01
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 3.372704E+03
P = -4.559218E+01 4.617894E+01 3.372079E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 4.172720E+03
P = 0.000000E+00 0.000000E+00 4.172720E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 3.785064E+01
P = 0.000000E+00 0.000000E+00 -3.785064E+01
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 2.327280E+03
P = 0.000000E+00 0.000000E+00 2.327280E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 6.462149E+03
P = 0.000000E+00 0.000000E+00 -6.462149E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.356696E+02
P = 3.575237E+01 -7.019261E+01 6.233585E+01
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 3.368185E+03
P = -5.506773E+01 2.305426E+01 3.367656E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 7.067153E+02
P = 1.931535E+01 4.713835E+01 7.048769E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 4.172720E+03
P = 0.000000E+00 0.000000E+00 4.172720E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 3.785064E+01
P = 0.000000E+00 0.000000E+00 -3.785064E+01
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 2.327280E+03
P = 0.000000E+00 0.000000E+00 2.327280E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 6.462149E+03
P = 0.000000E+00 0.000000E+00 -6.462149E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.356696E+02
P = 3.575237E+01 -7.019261E+01 6.233585E+01
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 3.368185E+03
P = -5.506773E+01 2.305426E+01 3.367656E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 7.067153E+02
P = 1.931535E+01 4.713835E+01 7.048769E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 3.458129E+03
P = 0.000000E+00 0.000000E+00 3.458129E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 3.683775E+01
P = 0.000000E+00 0.000000E+00 -3.683775E+01
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 3.041871E+03
P = 0.000000E+00 0.000000E+00 3.041871E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 6.463162E+03
P = 0.000000E+00 0.000000E+00 -6.463162E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.220015E+02
P = 4.416246E+01 -4.473082E+01 5.116585E+01
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 2.128524E+03
P = -8.250693E+01 5.174365E+01 2.126295E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 1.244441E+03
P = 3.834447E+01 -7.012833E+00 1.243830E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 4.172720E+03
P = 0.000000E+00 0.000000E+00 4.172720E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 3.785064E+01
P = 0.000000E+00 0.000000E+00 -3.785064E+01
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 2.327280E+03
P = 0.000000E+00 0.000000E+00 2.327280E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 6.462149E+03
P = 0.000000E+00 0.000000E+00 -6.462149E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.356696E+02
P = 3.575237E+01 -7.019261E+01 6.233585E+01
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 3.368185E+03
P = -5.506773E+01 2.305426E+01 3.367656E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 7.067153E+02
P = 1.931535E+01 4.713835E+01 7.048769E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 7.13834E+02
n_in* => 2
n_out* => 5
n_tot* => 7
$process_id* => "nlo_ppzj_sim_4_p1"
process_num_id* => [unknown integer]
sqme* => 0.00000E+00
sqme_ref* => 0.00000E+00
event_index* => 5
event_weight* => 0.00000E+00
event_weight_ref* => 0.00000E+00
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:-3|-3.4581288E+03; 0.0000000E+00, 0.0000000E+00,-3.4581288E+03| 0.0000000E+00| 3)
4 prt(i:-3|-3.6837746E+01; 0.0000000E+00, 0.0000000E+00, 3.6837746E+01| 0.0000000E+00| 4)
5 prt(o:92| 3.0418712E+03; 0.0000000E+00, 0.0000000E+00, 3.0418712E+03| 0.0000000E+00| 5)
6 prt(o:92| 6.4631623E+03; 0.0000000E+00, 0.0000000E+00,-6.4631623E+03| 0.0000000E+00| 6)
7 prt(o:23| 1.2200149E+02; 4.4162460E+01,-4.4730820E+01, 5.1165846E+01| 8.3152513E+03| 7)
8 prt(o:-3| 2.1285242E+03;-8.2506927E+01, 5.1743653E+01, 2.1262950E+03| 0.0000000E+00| 8)
9 prt(o:-3| 1.2444408E+03; 3.8344467E+01,-7.0128334E+00, 1.2438302E+03| 0.0000000E+00| 9)
========================================================================
========================================================================
Event #5
------------------------------------------------------------------------
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 = 1
Selected term = 1
Selected channel = 1
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
795611600.0, 2057298764.0, 35580411.0,
1531113698.0, 4099606364.0, 1165796235.0,
]
Beginning substream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Initial stream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 3.458129E+03
P = 0.000000E+00 0.000000E+00 3.458129E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(-2)
E = 3.683775E+01
P = 0.000000E+00 0.000000E+00 -3.683775E+01
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(-92*)
E = 3.041871E+03
P = 0.000000E+00 0.000000E+00 3.041871E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 6.463162E+03
P = 0.000000E+00 0.000000E+00 -6.463162E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.222627E+02
P = 4.559218E+01 -4.617894E+01 4.921159E+01
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 3.372704E+03
P = -4.559218E+01 4.617894E+01 3.372079E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
645088676.0, 977955169.0, 3913511931.0,
295659821.0, 2790160762.0, 3426294658.0,
]
Beginning substream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Initial stream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 4.172720E+03
P = 0.000000E+00 0.000000E+00 4.172720E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 3.785064E+01
P = 0.000000E+00 0.000000E+00 -3.785064E+01
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 2.327280E+03
P = 0.000000E+00 0.000000E+00 2.327280E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 6.462149E+03
P = 0.000000E+00 0.000000E+00 -6.462149E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.356696E+02
P = 3.575237E+01 -7.019261E+01 6.233585E+01
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 3.368185E+03
P = -5.506773E+01 2.305426E+01 3.367656E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 7.067153E+02
P = 1.931535E+01 4.713835E+01 7.048769E+02
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 4.022091751E-04
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 3.458129E+03
P = 0.000000E+00 0.000000E+00 3.458129E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(-2)
E = 3.683775E+01
P = 0.000000E+00 0.000000E+00 -3.683775E+01
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(-92*)
E = 3.041871E+03
P = 0.000000E+00 0.000000E+00 3.041871E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 6.463162E+03
P = 0.000000E+00 0.000000E+00 -6.463162E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.222627E+02
P = 4.559218E+01 -4.617894E+01 4.921159E+01
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 3.372704E+03
P = -4.559218E+01 4.617894E+01 3.372079E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 4.172720E+03
P = 0.000000E+00 0.000000E+00 4.172720E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 3.785064E+01
P = 0.000000E+00 0.000000E+00 -3.785064E+01
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 2.327280E+03
P = 0.000000E+00 0.000000E+00 2.327280E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 6.462149E+03
P = 0.000000E+00 0.000000E+00 -6.462149E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.356696E+02
P = 3.575237E+01 -7.019261E+01 6.233585E+01
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 3.368185E+03
P = -5.506773E+01 2.305426E+01 3.367656E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 7.067153E+02
P = 1.931535E+01 4.713835E+01 7.048769E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 4.172720E+03
P = 0.000000E+00 0.000000E+00 4.172720E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 3.785064E+01
P = 0.000000E+00 0.000000E+00 -3.785064E+01
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 2.327280E+03
P = 0.000000E+00 0.000000E+00 2.327280E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 6.462149E+03
P = 0.000000E+00 0.000000E+00 -6.462149E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.356696E+02
P = 3.575237E+01 -7.019261E+01 6.233585E+01
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 3.368185E+03
P = -5.506773E+01 2.305426E+01 3.367656E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 7.067153E+02
P = 1.931535E+01 4.713835E+01 7.048769E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 3.458129E+03
P = 0.000000E+00 0.000000E+00 3.458129E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 3.683775E+01
P = 0.000000E+00 0.000000E+00 -3.683775E+01
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 3.041871E+03
P = 0.000000E+00 0.000000E+00 3.041871E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 6.463162E+03
P = 0.000000E+00 0.000000E+00 -6.463162E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.220015E+02
P = 4.416246E+01 -4.473082E+01 5.116585E+01
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 2.128524E+03
P = -8.250693E+01 5.174365E+01 2.126295E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 1.244441E+03
P = 3.834447E+01 -7.012833E+00 1.243830E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 4.172720E+03
P = 0.000000E+00 0.000000E+00 4.172720E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 3.785064E+01
P = 0.000000E+00 0.000000E+00 -3.785064E+01
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 2.327280E+03
P = 0.000000E+00 0.000000E+00 2.327280E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 6.462149E+03
P = 0.000000E+00 0.000000E+00 -6.462149E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.356696E+02
P = 3.575237E+01 -7.019261E+01 6.233585E+01
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 3.368185E+03
P = -5.506773E+01 2.305426E+01 3.367656E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 7.067153E+02
P = 1.931535E+01 4.713835E+01 7.048769E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 7.94834E+02
n_in* => 2
n_out* => 5
n_tot* => 7
$process_id* => "nlo_ppzj_sim_4_p1"
process_num_id* => [unknown integer]
sqme* => 0.00000E+00
sqme_ref* => 0.00000E+00
event_index* => 5
event_weight* => 0.00000E+00
event_weight_ref* => 0.00000E+00
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:-3|-4.1727196E+03; 0.0000000E+00, 0.0000000E+00,-4.1727196E+03| 0.0000000E+00| 3)
4 prt(i:-3|-3.7850644E+01; 0.0000000E+00, 0.0000000E+00, 3.7850644E+01| 0.0000000E+00| 4)
5 prt(o:92| 2.3272804E+03; 0.0000000E+00, 0.0000000E+00, 2.3272804E+03| 0.0000000E+00| 5)
6 prt(o:92| 6.4621494E+03; 0.0000000E+00, 0.0000000E+00,-6.4621494E+03| 0.0000000E+00| 6)
7 prt(o:23| 1.3566962E+02; 3.5752372E+01,-7.0192608E+01, 6.2335854E+01| 8.3152513E+03| 7)
8 prt(o:-3| 3.3681853E+03;-5.5067725E+01, 2.3054260E+01, 3.3676562E+03| 0.0000000E+00| 8)
9 prt(o:-3| 7.0671532E+02; 1.9315353E+01, 4.7138348E+01, 7.0487689E+02| 0.0000000E+00| 9)
========================================================================
========================================================================
Event #6
------------------------------------------------------------------------
Unweighted = F
Normalization = 'sigma'
Helicity handling = drop
Keep correlations = F
------------------------------------------------------------------------
Squared matrix el. (ref) = 1.43113E-10
Squared matrix el. (prc) = 0.00000E+00
Event weight (ref) = 2.38022E-14
Event weight (prc) = 0.00000E+00
------------------------------------------------------------------------
Selected MCI group = 1
Selected term = 1
Selected channel = 1
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
1041009132.0, 1770701035.0, 3110195224.0,
2121609670.0, 3100617907.0, 262348729.0,
]
Beginning substream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Initial stream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 6.230296E+03
P = 0.000000E+00 0.000000E+00 6.230296E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(-2)
E = 6.319471E+03
P = 0.000000E+00 0.000000E+00 -6.319471E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(-92*)
E = 2.697044E+02
P = 0.000000E+00 0.000000E+00 2.697044E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.805292E+02
P = 0.000000E+00 0.000000E+00 -1.805292E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.319800E+03
P = 7.440376E+00 1.978997E+01 -6.319106E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 6.229967E+03
P = -7.440376E+00 -1.978997E+01 6.229931E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
3122908852.0, 364222012.0, 148320727.0,
2680045150.0, 1965799219.0, 1235728750.0,
]
Beginning substream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Initial stream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 6.231381E+03
P = 0.000000E+00 0.000000E+00 6.231381E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 6.375793E+03
P = 0.000000E+00 0.000000E+00 -6.375793E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 2.686195E+02
P = 0.000000E+00 0.000000E+00 2.686195E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.242075E+02
P = 0.000000E+00 0.000000E+00 -1.242075E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.319819E+03
P = 1.505449E+01 2.148114E+01 -6.319106E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 6.229957E+03
P = 1.729135E-01 -1.809899E+01 6.229931E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 5.739694E+01
P = -1.522740E+01 -3.382153E+00 -5.523672E+01
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 3.893937728E-09
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 6.230296E+03
P = 0.000000E+00 0.000000E+00 6.230296E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(-2)
E = 6.319471E+03
P = 0.000000E+00 0.000000E+00 -6.319471E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(-92*)
E = 2.697044E+02
P = 0.000000E+00 0.000000E+00 2.697044E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.805292E+02
P = 0.000000E+00 0.000000E+00 -1.805292E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.319800E+03
P = 7.440376E+00 1.978997E+01 -6.319106E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 6.229967E+03
P = -7.440376E+00 -1.978997E+01 6.229931E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 6.231381E+03
P = 0.000000E+00 0.000000E+00 6.231381E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 6.375793E+03
P = 0.000000E+00 0.000000E+00 -6.375793E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 2.686195E+02
P = 0.000000E+00 0.000000E+00 2.686195E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.242075E+02
P = 0.000000E+00 0.000000E+00 -1.242075E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.319819E+03
P = 1.505449E+01 2.148114E+01 -6.319106E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 6.229957E+03
P = 1.729135E-01 -1.809899E+01 6.229931E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 5.739694E+01
P = -1.522740E+01 -3.382153E+00 -5.523672E+01
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 6.231381E+03
P = 0.000000E+00 0.000000E+00 6.231381E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 6.375793E+03
P = 0.000000E+00 0.000000E+00 -6.375793E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 2.686195E+02
P = 0.000000E+00 0.000000E+00 2.686195E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.242075E+02
P = 0.000000E+00 0.000000E+00 -1.242075E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.319819E+03
P = 1.505449E+01 2.148114E+01 -6.319106E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 6.229957E+03
P = 1.729135E-01 -1.809899E+01 6.229931E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 5.739694E+01
P = -1.522740E+01 -3.382153E+00 -5.523672E+01
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 6.230296E+03
P = 0.000000E+00 0.000000E+00 6.230296E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 6.319471E+03
P = 0.000000E+00 0.000000E+00 -6.319471E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 2.697044E+02
P = 0.000000E+00 0.000000E+00 2.697044E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 1.805292E+02
P = 0.000000E+00 0.000000E+00 -1.805292E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 4.365949E+03
P = 5.139494E+00 1.367007E+01 -4.364972E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 6.174730E+03
P = -6.663142E+02 4.105865E+02 6.124928E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 2.009087E+03
P = 6.611747E+02 -4.242565E+02 -1.849131E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 6.231381E+03
P = 0.000000E+00 0.000000E+00 6.231381E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 6.375793E+03
P = 0.000000E+00 0.000000E+00 -6.375793E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 2.686195E+02
P = 0.000000E+00 0.000000E+00 2.686195E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.242075E+02
P = 0.000000E+00 0.000000E+00 -1.242075E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.319819E+03
P = 1.505449E+01 2.148114E+01 -6.319106E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 6.229957E+03
P = 1.729135E-01 -1.809899E+01 6.229931E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 5.739694E+01
P = -1.522740E+01 -3.382153E+00 -5.523672E+01
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 1.25494E+04
n_in* => 2
n_out* => 4
n_tot* => 6
$process_id* => "nlo_ppzj_sim_4_p1"
process_num_id* => [unknown integer]
sqme* => 0.00000E+00
sqme_ref* => 1.43113E-10
event_index* => 6
event_weight* => 0.00000E+00
event_weight_ref* => 2.38022E-14
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:2|-6.2302956E+03; 0.0000000E+00, 0.0000000E+00,-6.2302956E+03| 0.0000000E+00| 3)
4 prt(i:-2|-6.3194708E+03; 0.0000000E+00, 0.0000000E+00, 6.3194708E+03| 0.0000000E+00| 4)
5 prt(o:-92| 2.6970440E+02; 0.0000000E+00, 0.0000000E+00, 2.6970440E+02| 0.0000000E+00| 5)
6 prt(o:92| 1.8052918E+02; 0.0000000E+00, 0.0000000E+00,-1.8052918E+02| 0.0000000E+00| 6)
7 prt(o:23| 6.3197995E+03; 7.4403757E+00, 1.9789973E+01,-6.3191062E+03| 8.3152513E+03| 7)
8 prt(o:21| 6.2299669E+03;-7.4403757E+00,-1.9789973E+01, 6.2299310E+03| 0.0000000E+00| 8)
========================================================================
========================================================================
Event #6
------------------------------------------------------------------------
Unweighted = F
Normalization = 'sigma'
Helicity handling = drop
Keep correlations = F
------------------------------------------------------------------------
Squared matrix el. (ref) = 1.43113E-10
Squared matrix el. (prc) = 1.08937E-03
Event weight (ref) = 2.38022E-14
Event weight (prc) = 0.00000E+00
------------------------------------------------------------------------
Selected MCI group = 1
Selected term = 1
Selected channel = 1
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
1041009132.0, 1770701035.0, 3110195224.0,
2121609670.0, 3100617907.0, 262348729.0,
]
Beginning substream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Initial stream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 6.230296E+03
P = 0.000000E+00 0.000000E+00 6.230296E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(-2)
E = 6.319471E+03
P = 0.000000E+00 0.000000E+00 -6.319471E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(-92*)
E = 2.697044E+02
P = 0.000000E+00 0.000000E+00 2.697044E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.805292E+02
P = 0.000000E+00 0.000000E+00 -1.805292E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.319800E+03
P = 7.440376E+00 1.978997E+01 -6.319106E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 6.229967E+03
P = -7.440376E+00 -1.978997E+01 6.229931E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
3122908852.0, 364222012.0, 148320727.0,
2680045150.0, 1965799219.0, 1235728750.0,
]
Beginning substream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Initial stream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 6.231381E+03
P = 0.000000E+00 0.000000E+00 6.231381E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 6.375793E+03
P = 0.000000E+00 0.000000E+00 -6.375793E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 2.686195E+02
P = 0.000000E+00 0.000000E+00 2.686195E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.242075E+02
P = 0.000000E+00 0.000000E+00 -1.242075E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.319819E+03
P = 1.505449E+01 2.148114E+01 -6.319106E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 6.229957E+03
P = 1.729135E-01 -1.809899E+01 6.229931E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 5.739694E+01
P = -1.522740E+01 -3.382153E+00 -5.523672E+01
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 3.893937728E-09
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 6.230296E+03
P = 0.000000E+00 0.000000E+00 6.230296E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(-2)
E = 6.319471E+03
P = 0.000000E+00 0.000000E+00 -6.319471E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(-92*)
E = 2.697044E+02
P = 0.000000E+00 0.000000E+00 2.697044E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.805292E+02
P = 0.000000E+00 0.000000E+00 -1.805292E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.319800E+03
P = 7.440376E+00 1.978997E+01 -6.319106E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 6.229967E+03
P = -7.440376E+00 -1.978997E+01 6.229931E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 6.231381E+03
P = 0.000000E+00 0.000000E+00 6.231381E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 6.375793E+03
P = 0.000000E+00 0.000000E+00 -6.375793E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 2.686195E+02
P = 0.000000E+00 0.000000E+00 2.686195E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.242075E+02
P = 0.000000E+00 0.000000E+00 -1.242075E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.319819E+03
P = 1.505449E+01 2.148114E+01 -6.319106E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 6.229957E+03
P = 1.729135E-01 -1.809899E+01 6.229931E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 5.739694E+01
P = -1.522740E+01 -3.382153E+00 -5.523672E+01
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 6.231381E+03
P = 0.000000E+00 0.000000E+00 6.231381E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 6.375793E+03
P = 0.000000E+00 0.000000E+00 -6.375793E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 2.686195E+02
P = 0.000000E+00 0.000000E+00 2.686195E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.242075E+02
P = 0.000000E+00 0.000000E+00 -1.242075E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.319819E+03
P = 1.505449E+01 2.148114E+01 -6.319106E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 6.229957E+03
P = 1.729135E-01 -1.809899E+01 6.229931E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 5.739694E+01
P = -1.522740E+01 -3.382153E+00 -5.523672E+01
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 6.230296E+03
P = 0.000000E+00 0.000000E+00 6.230296E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 6.319471E+03
P = 0.000000E+00 0.000000E+00 -6.319471E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 2.697044E+02
P = 0.000000E+00 0.000000E+00 2.697044E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 1.805292E+02
P = 0.000000E+00 0.000000E+00 -1.805292E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 4.365949E+03
P = 5.139494E+00 1.367007E+01 -4.364972E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 6.174730E+03
P = -6.663142E+02 4.105865E+02 6.124928E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 2.009087E+03
P = 6.611747E+02 -4.242565E+02 -1.849131E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 6.231381E+03
P = 0.000000E+00 0.000000E+00 6.231381E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 6.375793E+03
P = 0.000000E+00 0.000000E+00 -6.375793E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 2.686195E+02
P = 0.000000E+00 0.000000E+00 2.686195E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.242075E+02
P = 0.000000E+00 0.000000E+00 -1.242075E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.319819E+03
P = 1.505449E+01 2.148114E+01 -6.319106E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 6.229957E+03
P = 1.729135E-01 -1.809899E+01 6.229931E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 5.739694E+01
P = -1.522740E+01 -3.382153E+00 -5.523672E+01
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 1.26063E+04
n_in* => 2
n_out* => 5
n_tot* => 7
$process_id* => "nlo_ppzj_sim_4_p1"
process_num_id* => [unknown integer]
sqme* => 1.08937E-03
sqme_ref* => 1.43113E-10
event_index* => 6
event_weight* => 0.00000E+00
event_weight_ref* => 2.38022E-14
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:-2|-6.2313805E+03; 0.0000000E+00, 0.0000000E+00,-6.2313805E+03| 0.0000000E+00| 3)
4 prt(i:-2|-6.3757925E+03; 0.0000000E+00, 0.0000000E+00, 6.3757925E+03| 0.0000000E+00| 4)
5 prt(o:92| 2.6861948E+02; 0.0000000E+00, 0.0000000E+00, 2.6861948E+02| 0.0000000E+00| 5)
6 prt(o:92| 1.2420747E+02; 0.0000000E+00, 0.0000000E+00,-1.2420747E+02| 0.0000000E+00| 6)
7 prt(o:23| 6.3198187E+03; 1.5054486E+01, 2.1481140E+01,-6.3191064E+03| 8.3152513E+03| 7)
8 prt(o:-2| 6.2299574E+03; 1.7291345E-01,-1.8098988E+01, 6.2299311E+03| 0.0000000E+00| 8)
9 prt(o:-2| 5.7396936E+01;-1.5227400E+01,-3.3821527E+00,-5.5236724E+01| 0.0000000E+00| 9)
========================================================================
========================================================================
Event #6
------------------------------------------------------------------------
Unweighted = F
Normalization = 'sigma'
Helicity handling = drop
Keep correlations = F
------------------------------------------------------------------------
Squared matrix el. (ref) = 1.43113E-10
Squared matrix el. (prc) = 2.09998E-05
Event weight (ref) = 2.38022E-14
Event weight (prc) = 0.00000E+00
------------------------------------------------------------------------
Selected MCI group = 1
Selected term = 1
Selected channel = 1
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
1041009132.0, 1770701035.0, 3110195224.0,
2121609670.0, 3100617907.0, 262348729.0,
]
Beginning substream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Initial stream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 6.230296E+03
P = 0.000000E+00 0.000000E+00 6.230296E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(-2)
E = 6.319471E+03
P = 0.000000E+00 0.000000E+00 -6.319471E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(-92*)
E = 2.697044E+02
P = 0.000000E+00 0.000000E+00 2.697044E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.805292E+02
P = 0.000000E+00 0.000000E+00 -1.805292E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.319800E+03
P = 7.440376E+00 1.978997E+01 -6.319106E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 6.229967E+03
P = -7.440376E+00 -1.978997E+01 6.229931E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
3122908852.0, 364222012.0, 148320727.0,
2680045150.0, 1965799219.0, 1235728750.0,
]
Beginning substream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Initial stream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 6.231381E+03
P = 0.000000E+00 0.000000E+00 6.231381E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 6.375793E+03
P = 0.000000E+00 0.000000E+00 -6.375793E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 2.686195E+02
P = 0.000000E+00 0.000000E+00 2.686195E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.242075E+02
P = 0.000000E+00 0.000000E+00 -1.242075E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.319819E+03
P = 1.505449E+01 2.148114E+01 -6.319106E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 6.229957E+03
P = 1.729135E-01 -1.809899E+01 6.229931E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 5.739694E+01
P = -1.522740E+01 -3.382153E+00 -5.523672E+01
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 3.893937728E-09
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 6.230296E+03
P = 0.000000E+00 0.000000E+00 6.230296E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(-2)
E = 6.319471E+03
P = 0.000000E+00 0.000000E+00 -6.319471E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(-92*)
E = 2.697044E+02
P = 0.000000E+00 0.000000E+00 2.697044E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.805292E+02
P = 0.000000E+00 0.000000E+00 -1.805292E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.319800E+03
P = 7.440376E+00 1.978997E+01 -6.319106E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 6.229967E+03
P = -7.440376E+00 -1.978997E+01 6.229931E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 6.231381E+03
P = 0.000000E+00 0.000000E+00 6.231381E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 6.375793E+03
P = 0.000000E+00 0.000000E+00 -6.375793E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 2.686195E+02
P = 0.000000E+00 0.000000E+00 2.686195E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.242075E+02
P = 0.000000E+00 0.000000E+00 -1.242075E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.319819E+03
P = 1.505449E+01 2.148114E+01 -6.319106E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 6.229957E+03
P = 1.729135E-01 -1.809899E+01 6.229931E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 5.739694E+01
P = -1.522740E+01 -3.382153E+00 -5.523672E+01
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 6.231381E+03
P = 0.000000E+00 0.000000E+00 6.231381E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 6.375793E+03
P = 0.000000E+00 0.000000E+00 -6.375793E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 2.686195E+02
P = 0.000000E+00 0.000000E+00 2.686195E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.242075E+02
P = 0.000000E+00 0.000000E+00 -1.242075E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.319819E+03
P = 1.505449E+01 2.148114E+01 -6.319106E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 6.229957E+03
P = 1.729135E-01 -1.809899E+01 6.229931E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 5.739694E+01
P = -1.522740E+01 -3.382153E+00 -5.523672E+01
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 6.230296E+03
P = 0.000000E+00 0.000000E+00 6.230296E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 6.319471E+03
P = 0.000000E+00 0.000000E+00 -6.319471E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 2.697044E+02
P = 0.000000E+00 0.000000E+00 2.697044E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 1.805292E+02
P = 0.000000E+00 0.000000E+00 -1.805292E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 4.365949E+03
P = 5.139494E+00 1.367007E+01 -4.364972E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 6.174730E+03
P = -6.663142E+02 4.105865E+02 6.124928E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 2.009087E+03
P = 6.611747E+02 -4.242565E+02 -1.849131E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 6.231381E+03
P = 0.000000E+00 0.000000E+00 6.231381E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 6.375793E+03
P = 0.000000E+00 0.000000E+00 -6.375793E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 2.686195E+02
P = 0.000000E+00 0.000000E+00 2.686195E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.242075E+02
P = 0.000000E+00 0.000000E+00 -1.242075E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.319819E+03
P = 1.505449E+01 2.148114E+01 -6.319106E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 6.229957E+03
P = 1.729135E-01 -1.809899E+01 6.229931E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 5.739694E+01
P = -1.522740E+01 -3.382153E+00 -5.523672E+01
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 1.26063E+04
n_in* => 2
n_out* => 5
n_tot* => 7
$process_id* => "nlo_ppzj_sim_4_p1"
process_num_id* => [unknown integer]
sqme* => 2.09998E-05
sqme_ref* => 1.43113E-10
event_index* => 6
event_weight* => 0.00000E+00
event_weight_ref* => 2.38022E-14
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:-2|-6.2313805E+03; 0.0000000E+00, 0.0000000E+00,-6.2313805E+03| 0.0000000E+00| 3)
4 prt(i:-2|-6.3757925E+03; 0.0000000E+00, 0.0000000E+00, 6.3757925E+03| 0.0000000E+00| 4)
5 prt(o:92| 2.6861948E+02; 0.0000000E+00, 0.0000000E+00, 2.6861948E+02| 0.0000000E+00| 5)
6 prt(o:92| 1.2420747E+02; 0.0000000E+00, 0.0000000E+00,-1.2420747E+02| 0.0000000E+00| 6)
7 prt(o:23| 6.3198187E+03; 1.5054486E+01, 2.1481140E+01,-6.3191064E+03| 8.3152513E+03| 7)
8 prt(o:-2| 6.2299574E+03; 1.7291345E-01,-1.8098988E+01, 6.2299311E+03| 0.0000000E+00| 8)
9 prt(o:-2| 5.7396936E+01;-1.5227400E+01,-3.3821527E+00,-5.5236724E+01| 0.0000000E+00| 9)
========================================================================
========================================================================
Event #6
------------------------------------------------------------------------
Unweighted = F
Normalization = 'sigma'
Helicity handling = drop
Keep correlations = F
------------------------------------------------------------------------
Squared matrix el. (ref) = 1.43113E-10
Squared matrix el. (prc) = 1.43113E-10
Event weight (ref) = 2.38022E-14
Event weight (prc) = 2.38022E-14
------------------------------------------------------------------------
Selected MCI group = 1
Selected term = 1
Selected channel = 1
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
1041009132.0, 1770701035.0, 3110195224.0,
2121609670.0, 3100617907.0, 262348729.0,
]
Beginning substream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Initial stream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 6.230296E+03
P = 0.000000E+00 0.000000E+00 6.230296E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(-2)
E = 6.319471E+03
P = 0.000000E+00 0.000000E+00 -6.319471E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(-92*)
E = 2.697044E+02
P = 0.000000E+00 0.000000E+00 2.697044E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.805292E+02
P = 0.000000E+00 0.000000E+00 -1.805292E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.319800E+03
P = 7.440376E+00 1.978997E+01 -6.319106E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 6.229967E+03
P = -7.440376E+00 -1.978997E+01 6.229931E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
3122908852.0, 364222012.0, 148320727.0,
2680045150.0, 1965799219.0, 1235728750.0,
]
Beginning substream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Initial stream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 6.231381E+03
P = 0.000000E+00 0.000000E+00 6.231381E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 6.375793E+03
P = 0.000000E+00 0.000000E+00 -6.375793E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 2.686195E+02
P = 0.000000E+00 0.000000E+00 2.686195E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.242075E+02
P = 0.000000E+00 0.000000E+00 -1.242075E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.319819E+03
P = 1.505449E+01 2.148114E+01 -6.319106E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 6.229957E+03
P = 1.729135E-01 -1.809899E+01 6.229931E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 5.739694E+01
P = -1.522740E+01 -3.382153E+00 -5.523672E+01
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 3.893937728E-09
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 6.230296E+03
P = 0.000000E+00 0.000000E+00 6.230296E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(-2)
E = 6.319471E+03
P = 0.000000E+00 0.000000E+00 -6.319471E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(-92*)
E = 2.697044E+02
P = 0.000000E+00 0.000000E+00 2.697044E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.805292E+02
P = 0.000000E+00 0.000000E+00 -1.805292E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.319800E+03
P = 7.440376E+00 1.978997E+01 -6.319106E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 6.229967E+03
P = -7.440376E+00 -1.978997E+01 6.229931E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 6.231381E+03
P = 0.000000E+00 0.000000E+00 6.231381E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 6.375793E+03
P = 0.000000E+00 0.000000E+00 -6.375793E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 2.686195E+02
P = 0.000000E+00 0.000000E+00 2.686195E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.242075E+02
P = 0.000000E+00 0.000000E+00 -1.242075E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.319819E+03
P = 1.505449E+01 2.148114E+01 -6.319106E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 6.229957E+03
P = 1.729135E-01 -1.809899E+01 6.229931E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 5.739694E+01
P = -1.522740E+01 -3.382153E+00 -5.523672E+01
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 6.231381E+03
P = 0.000000E+00 0.000000E+00 6.231381E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 6.375793E+03
P = 0.000000E+00 0.000000E+00 -6.375793E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 2.686195E+02
P = 0.000000E+00 0.000000E+00 2.686195E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.242075E+02
P = 0.000000E+00 0.000000E+00 -1.242075E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.319819E+03
P = 1.505449E+01 2.148114E+01 -6.319106E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 6.229957E+03
P = 1.729135E-01 -1.809899E+01 6.229931E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 5.739694E+01
P = -1.522740E+01 -3.382153E+00 -5.523672E+01
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 6.230296E+03
P = 0.000000E+00 0.000000E+00 6.230296E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 6.319471E+03
P = 0.000000E+00 0.000000E+00 -6.319471E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 2.697044E+02
P = 0.000000E+00 0.000000E+00 2.697044E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 1.805292E+02
P = 0.000000E+00 0.000000E+00 -1.805292E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 4.365949E+03
P = 5.139494E+00 1.367007E+01 -4.364972E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 6.174730E+03
P = -6.663142E+02 4.105865E+02 6.124928E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 2.009087E+03
P = 6.611747E+02 -4.242565E+02 -1.849131E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 6.231381E+03
P = 0.000000E+00 0.000000E+00 6.231381E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 6.375793E+03
P = 0.000000E+00 0.000000E+00 -6.375793E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 2.686195E+02
P = 0.000000E+00 0.000000E+00 2.686195E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.242075E+02
P = 0.000000E+00 0.000000E+00 -1.242075E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.319819E+03
P = 1.505449E+01 2.148114E+01 -6.319106E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 6.229957E+03
P = 1.729135E-01 -1.809899E+01 6.229931E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 5.739694E+01
P = -1.522740E+01 -3.382153E+00 -5.523672E+01
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 1.25494E+04
n_in* => 2
n_out* => 5
n_tot* => 7
$process_id* => "nlo_ppzj_sim_4_p1"
process_num_id* => [unknown integer]
sqme* => 1.43113E-10
sqme_ref* => 1.43113E-10
event_index* => 6
event_weight* => 2.38022E-14
event_weight_ref* => 2.38022E-14
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:-2|-6.2302956E+03; 0.0000000E+00, 0.0000000E+00,-6.2302956E+03| 0.0000000E+00| 3)
4 prt(i:2|-6.3194708E+03; 0.0000000E+00, 0.0000000E+00, 6.3194708E+03| 0.0000000E+00| 4)
5 prt(o:92| 2.6970440E+02; 0.0000000E+00, 0.0000000E+00, 2.6970440E+02| 0.0000000E+00| 5)
6 prt(o:-92| 1.8052918E+02; 0.0000000E+00, 0.0000000E+00,-1.8052918E+02| 0.0000000E+00| 6)
7 prt(o:23| 4.3659490E+03; 5.1394937E+00, 1.3670068E+01,-4.3649722E+03| 8.3152513E+03| 7)
8 prt(o:-2| 6.1747305E+03;-6.6631419E+02, 4.1058648E+02, 6.1249278E+03| 0.0000000E+00| 8)
9 prt(o:2| 2.0090869E+03; 6.6117469E+02,-4.2425655E+02,-1.8491308E+03| 0.0000000E+00| 9)
========================================================================
========================================================================
Event #6
------------------------------------------------------------------------
Unweighted = F
Normalization = 'sigma'
Helicity handling = drop
Keep correlations = F
------------------------------------------------------------------------
Squared matrix el. (ref) = 1.43113E-10
Squared matrix el. (prc) = 3.89394E-09
Event weight (ref) = 2.38022E-14
Event weight (prc) = 0.00000E+00
------------------------------------------------------------------------
Selected MCI group = 1
Selected term = 1
Selected channel = 1
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
1041009132.0, 1770701035.0, 3110195224.0,
2121609670.0, 3100617907.0, 262348729.0,
]
Beginning substream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Initial stream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 6.230296E+03
P = 0.000000E+00 0.000000E+00 6.230296E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(-2)
E = 6.319471E+03
P = 0.000000E+00 0.000000E+00 -6.319471E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(-92*)
E = 2.697044E+02
P = 0.000000E+00 0.000000E+00 2.697044E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.805292E+02
P = 0.000000E+00 0.000000E+00 -1.805292E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.319800E+03
P = 7.440376E+00 1.978997E+01 -6.319106E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 6.229967E+03
P = -7.440376E+00 -1.978997E+01 6.229931E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
3122908852.0, 364222012.0, 148320727.0,
2680045150.0, 1965799219.0, 1235728750.0,
]
Beginning substream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Initial stream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 6.231381E+03
P = 0.000000E+00 0.000000E+00 6.231381E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 6.375793E+03
P = 0.000000E+00 0.000000E+00 -6.375793E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 2.686195E+02
P = 0.000000E+00 0.000000E+00 2.686195E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.242075E+02
P = 0.000000E+00 0.000000E+00 -1.242075E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.319819E+03
P = 1.505449E+01 2.148114E+01 -6.319106E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 6.229957E+03
P = 1.729135E-01 -1.809899E+01 6.229931E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 5.739694E+01
P = -1.522740E+01 -3.382153E+00 -5.523672E+01
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 3.893937728E-09
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 6.230296E+03
P = 0.000000E+00 0.000000E+00 6.230296E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(-2)
E = 6.319471E+03
P = 0.000000E+00 0.000000E+00 -6.319471E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(-92*)
E = 2.697044E+02
P = 0.000000E+00 0.000000E+00 2.697044E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.805292E+02
P = 0.000000E+00 0.000000E+00 -1.805292E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.319800E+03
P = 7.440376E+00 1.978997E+01 -6.319106E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 6.229967E+03
P = -7.440376E+00 -1.978997E+01 6.229931E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 6.231381E+03
P = 0.000000E+00 0.000000E+00 6.231381E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 6.375793E+03
P = 0.000000E+00 0.000000E+00 -6.375793E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 2.686195E+02
P = 0.000000E+00 0.000000E+00 2.686195E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.242075E+02
P = 0.000000E+00 0.000000E+00 -1.242075E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.319819E+03
P = 1.505449E+01 2.148114E+01 -6.319106E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 6.229957E+03
P = 1.729135E-01 -1.809899E+01 6.229931E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 5.739694E+01
P = -1.522740E+01 -3.382153E+00 -5.523672E+01
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 6.231381E+03
P = 0.000000E+00 0.000000E+00 6.231381E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 6.375793E+03
P = 0.000000E+00 0.000000E+00 -6.375793E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 2.686195E+02
P = 0.000000E+00 0.000000E+00 2.686195E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.242075E+02
P = 0.000000E+00 0.000000E+00 -1.242075E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.319819E+03
P = 1.505449E+01 2.148114E+01 -6.319106E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 6.229957E+03
P = 1.729135E-01 -1.809899E+01 6.229931E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 5.739694E+01
P = -1.522740E+01 -3.382153E+00 -5.523672E+01
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 6.230296E+03
P = 0.000000E+00 0.000000E+00 6.230296E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 6.319471E+03
P = 0.000000E+00 0.000000E+00 -6.319471E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 2.697044E+02
P = 0.000000E+00 0.000000E+00 2.697044E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 1.805292E+02
P = 0.000000E+00 0.000000E+00 -1.805292E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 4.365949E+03
P = 5.139494E+00 1.367007E+01 -4.364972E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 6.174730E+03
P = -6.663142E+02 4.105865E+02 6.124928E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 2.009087E+03
P = 6.611747E+02 -4.242565E+02 -1.849131E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 6.231381E+03
P = 0.000000E+00 0.000000E+00 6.231381E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 6.375793E+03
P = 0.000000E+00 0.000000E+00 -6.375793E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 2.686195E+02
P = 0.000000E+00 0.000000E+00 2.686195E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 1.242075E+02
P = 0.000000E+00 0.000000E+00 -1.242075E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 6.319819E+03
P = 1.505449E+01 2.148114E+01 -6.319106E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 6.229957E+03
P = 1.729135E-01 -1.809899E+01 6.229931E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 5.739694E+01
P = -1.522740E+01 -3.382153E+00 -5.523672E+01
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 1.26063E+04
n_in* => 2
n_out* => 5
n_tot* => 7
$process_id* => "nlo_ppzj_sim_4_p1"
process_num_id* => [unknown integer]
sqme* => 3.89394E-09
sqme_ref* => 1.43113E-10
event_index* => 6
event_weight* => 0.00000E+00
event_weight_ref* => 2.38022E-14
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:-3|-6.2313805E+03; 0.0000000E+00, 0.0000000E+00,-6.2313805E+03| 0.0000000E+00| 3)
4 prt(i:-3|-6.3757925E+03; 0.0000000E+00, 0.0000000E+00, 6.3757925E+03| 0.0000000E+00| 4)
5 prt(o:92| 2.6861948E+02; 0.0000000E+00, 0.0000000E+00, 2.6861948E+02| 0.0000000E+00| 5)
6 prt(o:92| 1.2420747E+02; 0.0000000E+00, 0.0000000E+00,-1.2420747E+02| 0.0000000E+00| 6)
7 prt(o:23| 6.3198187E+03; 1.5054486E+01, 2.1481140E+01,-6.3191064E+03| 8.3152513E+03| 7)
8 prt(o:-3| 6.2299574E+03; 1.7291345E-01,-1.8098988E+01, 6.2299311E+03| 0.0000000E+00| 8)
9 prt(o:-3| 5.7396936E+01;-1.5227400E+01,-3.3821527E+00,-5.5236724E+01| 0.0000000E+00| 9)
========================================================================
========================================================================
Event #7
------------------------------------------------------------------------
Unweighted = F
Normalization = 'sigma'
Helicity handling = drop
Keep correlations = F
------------------------------------------------------------------------
Squared matrix el. (ref) = 1.59038E+00
Squared matrix el. (prc) = 0.00000E+00
Event weight (ref) = 6.11028E-03
Event weight (prc) = 0.00000E+00
------------------------------------------------------------------------
Selected MCI group = 1
Selected term = 1
Selected channel = 1
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
2255705969.0, 3362628724.0, 2952502488.0,
3217231987.0, 2487643470.0, 2150867474.0,
]
Beginning substream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Initial stream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(1)
E = 5.160490E+03
P = 0.000000E+00 0.000000E+00 5.160490E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(21)
E = 1.595951E+03
P = 0.000000E+00 0.000000E+00 -1.595951E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(-92*)
E = 1.339510E+03
P = 0.000000E+00 0.000000E+00 1.339510E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(93*)
E = 4.904049E+03
P = 0.000000E+00 0.000000E+00 -4.904049E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.597254E+03
P = 1.673304E+00 6.625245E-01 -1.594648E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(1)
E = 5.159187E+03
P = -1.673304E+00 -6.625245E-01 5.159187E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
3067832660.0, 4275592703.0, 1632202331.0,
3461487745.0, 2283704839.0, 3609569101.0,
]
Beginning substream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Initial stream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 6.387070E+03
P = 0.000000E+00 0.000000E+00 6.387070E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(21)
E = 2.145160E+03
P = 0.000000E+00 0.000000E+00 -2.145160E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 1.129304E+02
P = 0.000000E+00 0.000000E+00 1.129304E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(93*)
E = 4.354840E+03
P = 0.000000E+00 0.000000E+00 -4.354840E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.704843E+03
P = 6.679665E+02 2.947910E+02 -1.537886E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 5.265648E+03
P = 6.641794E+02 2.932715E+02 5.215353E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 1.561738E+03
P = -1.332146E+03 -5.880626E+02 5.644431E+02
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 4.990885634E-09
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.160490E+03
P = 0.000000E+00 0.000000E+00 5.160490E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(-2)
E = 1.595951E+03
P = 0.000000E+00 0.000000E+00 -1.595951E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(-92*)
E = 1.339510E+03
P = 0.000000E+00 0.000000E+00 1.339510E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 4.904049E+03
P = 0.000000E+00 0.000000E+00 -4.904049E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.597254E+03
P = 1.673304E+00 6.625245E-01 -1.594648E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 5.159187E+03
P = -1.673304E+00 -6.625245E-01 5.159187E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 6.387070E+03
P = 0.000000E+00 0.000000E+00 6.387070E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 2.145160E+03
P = 0.000000E+00 0.000000E+00 -2.145160E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 1.129304E+02
P = 0.000000E+00 0.000000E+00 1.129304E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 4.354840E+03
P = 0.000000E+00 0.000000E+00 -4.354840E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.704843E+03
P = 6.679665E+02 2.947910E+02 -1.537886E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 5.265648E+03
P = 6.641794E+02 2.932715E+02 5.215353E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 1.561738E+03
P = -1.332146E+03 -5.880626E+02 5.644431E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 6.387070E+03
P = 0.000000E+00 0.000000E+00 6.387070E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 2.145160E+03
P = 0.000000E+00 0.000000E+00 -2.145160E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 1.129304E+02
P = 0.000000E+00 0.000000E+00 1.129304E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 4.354840E+03
P = 0.000000E+00 0.000000E+00 -4.354840E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.704843E+03
P = 6.679665E+02 2.947910E+02 -1.537886E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 5.265648E+03
P = 6.641794E+02 2.932715E+02 5.215353E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 1.561738E+03
P = -1.332146E+03 -5.880626E+02 5.644431E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(21)
E = 5.160490E+03
P = 0.000000E+00 0.000000E+00 5.160490E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 1.595951E+03
P = 0.000000E+00 0.000000E+00 -1.595951E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(93*)
E = 1.339510E+03
P = 0.000000E+00 0.000000E+00 1.339510E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 4.904049E+03
P = 0.000000E+00 0.000000E+00 -4.904049E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.485301E+03
P = 1.555760E+00 6.159843E-01 -1.482498E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 4.251072E+02
P = 1.420108E+01 3.664827E+02 2.149533E+02
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 4.846033E+03
P = -1.575684E+01 -3.670987E+02 4.832083E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 6.387070E+03
P = 0.000000E+00 0.000000E+00 6.387070E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(21)
E = 2.145160E+03
P = 0.000000E+00 0.000000E+00 -2.145160E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 1.129304E+02
P = 0.000000E+00 0.000000E+00 1.129304E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(93*)
E = 4.354840E+03
P = 0.000000E+00 0.000000E+00 -4.354840E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.704843E+03
P = 6.679665E+02 2.947910E+02 -1.537886E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 5.265648E+03
P = 6.641794E+02 2.932715E+02 5.215353E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 1.561738E+03
P = -1.332146E+03 -5.880626E+02 5.644431E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 5.73965E+03
n_in* => 2
n_out* => 4
n_tot* => 6
$process_id* => "nlo_ppzj_sim_4_p1"
process_num_id* => [unknown integer]
sqme* => 0.00000E+00
sqme_ref* => 1.59038E+00
event_index* => 7
event_weight* => 0.00000E+00
event_weight_ref* => 6.11028E-03
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:2|-5.1604898E+03; 0.0000000E+00, 0.0000000E+00,-5.1604898E+03| 0.0000000E+00| 3)
4 prt(i:-2|-1.5959512E+03; 0.0000000E+00, 0.0000000E+00, 1.5959512E+03| 0.0000000E+00| 4)
5 prt(o:-92| 1.3395102E+03; 0.0000000E+00, 0.0000000E+00, 1.3395102E+03| 0.0000000E+00| 5)
6 prt(o:92| 4.9040488E+03; 0.0000000E+00, 0.0000000E+00,-4.9040488E+03| 0.0000000E+00| 6)
7 prt(o:23| 1.5972541E+03; 1.6733042E+00, 6.6252453E-01,-1.5946479E+03| 8.3152513E+03| 7)
8 prt(o:21| 5.1591869E+03;-1.6733042E+00,-6.6252453E-01, 5.1591866E+03| 0.0000000E+00| 8)
========================================================================
========================================================================
Event #7
------------------------------------------------------------------------
Unweighted = F
Normalization = 'sigma'
Helicity handling = drop
Keep correlations = F
------------------------------------------------------------------------
Squared matrix el. (ref) = 1.59038E+00
Squared matrix el. (prc) = 1.08739E-06
Event weight (ref) = 6.11028E-03
Event weight (prc) = 4.17777E-09
------------------------------------------------------------------------
Selected MCI group = 1
Selected term = 1
Selected channel = 1
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
2255705969.0, 3362628724.0, 2952502488.0,
3217231987.0, 2487643470.0, 2150867474.0,
]
Beginning substream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Initial stream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(1)
E = 5.160490E+03
P = 0.000000E+00 0.000000E+00 5.160490E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(21)
E = 1.595951E+03
P = 0.000000E+00 0.000000E+00 -1.595951E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(-92*)
E = 1.339510E+03
P = 0.000000E+00 0.000000E+00 1.339510E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(93*)
E = 4.904049E+03
P = 0.000000E+00 0.000000E+00 -4.904049E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.597254E+03
P = 1.673304E+00 6.625245E-01 -1.594648E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(1)
E = 5.159187E+03
P = -1.673304E+00 -6.625245E-01 5.159187E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
3067832660.0, 4275592703.0, 1632202331.0,
3461487745.0, 2283704839.0, 3609569101.0,
]
Beginning substream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Initial stream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 6.387070E+03
P = 0.000000E+00 0.000000E+00 6.387070E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(21)
E = 2.145160E+03
P = 0.000000E+00 0.000000E+00 -2.145160E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 1.129304E+02
P = 0.000000E+00 0.000000E+00 1.129304E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(93*)
E = 4.354840E+03
P = 0.000000E+00 0.000000E+00 -4.354840E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.704843E+03
P = 6.679665E+02 2.947910E+02 -1.537886E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 5.265648E+03
P = 6.641794E+02 2.932715E+02 5.215353E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 1.561738E+03
P = -1.332146E+03 -5.880626E+02 5.644431E+02
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 4.990885634E-09
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.160490E+03
P = 0.000000E+00 0.000000E+00 5.160490E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(-2)
E = 1.595951E+03
P = 0.000000E+00 0.000000E+00 -1.595951E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(-92*)
E = 1.339510E+03
P = 0.000000E+00 0.000000E+00 1.339510E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 4.904049E+03
P = 0.000000E+00 0.000000E+00 -4.904049E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.597254E+03
P = 1.673304E+00 6.625245E-01 -1.594648E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 5.159187E+03
P = -1.673304E+00 -6.625245E-01 5.159187E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 6.387070E+03
P = 0.000000E+00 0.000000E+00 6.387070E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 2.145160E+03
P = 0.000000E+00 0.000000E+00 -2.145160E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 1.129304E+02
P = 0.000000E+00 0.000000E+00 1.129304E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 4.354840E+03
P = 0.000000E+00 0.000000E+00 -4.354840E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.704843E+03
P = 6.679665E+02 2.947910E+02 -1.537886E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 5.265648E+03
P = 6.641794E+02 2.932715E+02 5.215353E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 1.561738E+03
P = -1.332146E+03 -5.880626E+02 5.644431E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 6.387070E+03
P = 0.000000E+00 0.000000E+00 6.387070E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 2.145160E+03
P = 0.000000E+00 0.000000E+00 -2.145160E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 1.129304E+02
P = 0.000000E+00 0.000000E+00 1.129304E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 4.354840E+03
P = 0.000000E+00 0.000000E+00 -4.354840E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.704843E+03
P = 6.679665E+02 2.947910E+02 -1.537886E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 5.265648E+03
P = 6.641794E+02 2.932715E+02 5.215353E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 1.561738E+03
P = -1.332146E+03 -5.880626E+02 5.644431E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(21)
E = 5.160490E+03
P = 0.000000E+00 0.000000E+00 5.160490E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 1.595951E+03
P = 0.000000E+00 0.000000E+00 -1.595951E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(93*)
E = 1.339510E+03
P = 0.000000E+00 0.000000E+00 1.339510E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 4.904049E+03
P = 0.000000E+00 0.000000E+00 -4.904049E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.485301E+03
P = 1.555760E+00 6.159843E-01 -1.482498E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 4.251072E+02
P = 1.420108E+01 3.664827E+02 2.149533E+02
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 4.846033E+03
P = -1.575684E+01 -3.670987E+02 4.832083E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 6.387070E+03
P = 0.000000E+00 0.000000E+00 6.387070E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(21)
E = 2.145160E+03
P = 0.000000E+00 0.000000E+00 -2.145160E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 1.129304E+02
P = 0.000000E+00 0.000000E+00 1.129304E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(93*)
E = 4.354840E+03
P = 0.000000E+00 0.000000E+00 -4.354840E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.704843E+03
P = 6.679665E+02 2.947910E+02 -1.537886E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 5.265648E+03
P = 6.641794E+02 2.932715E+02 5.215353E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 1.561738E+03
P = -1.332146E+03 -5.880626E+02 5.644431E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 7.40305E+03
n_in* => 2
n_out* => 5
n_tot* => 7
$process_id* => "nlo_ppzj_sim_4_p1"
process_num_id* => [unknown integer]
sqme* => 1.08739E-06
sqme_ref* => 1.59038E+00
event_index* => 7
event_weight* => 4.17777E-09
event_weight_ref* => 6.11028E-03
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:2|-6.3870696E+03; 0.0000000E+00, 0.0000000E+00,-6.3870696E+03| 0.0000000E+00| 3)
4 prt(i:2|-2.1451599E+03; 0.0000000E+00, 0.0000000E+00, 2.1451599E+03| 0.0000000E+00| 4)
5 prt(o:-92| 1.1293035E+02; 0.0000000E+00, 0.0000000E+00, 1.1293035E+02| 0.0000000E+00| 5)
6 prt(o:-92| 4.3548401E+03; 0.0000000E+00, 0.0000000E+00,-4.3548401E+03| 0.0000000E+00| 6)
7 prt(o:23| 1.7048433E+03; 6.6796651E+02, 2.9479103E+02,-1.5378864E+03| 8.3152513E+03| 7)
8 prt(o:2| 5.2656480E+03; 6.6417942E+02, 2.9327153E+02, 5.2153530E+03| 0.0000000E+00| 8)
9 prt(o:2| 1.5617383E+03;-1.3321459E+03,-5.8806255E+02, 5.6444313E+02| 0.0000000E+00| 9)
========================================================================
========================================================================
Event #7
------------------------------------------------------------------------
Unweighted = F
Normalization = 'sigma'
Helicity handling = drop
Keep correlations = F
------------------------------------------------------------------------
Squared matrix el. (ref) = 1.59038E+00
Squared matrix el. (prc) = 5.12258E-07
Event weight (ref) = 6.11028E-03
Event weight (prc) = 1.96811E-09
------------------------------------------------------------------------
Selected MCI group = 1
Selected term = 1
Selected channel = 1
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
2255705969.0, 3362628724.0, 2952502488.0,
3217231987.0, 2487643470.0, 2150867474.0,
]
Beginning substream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Initial stream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(1)
E = 5.160490E+03
P = 0.000000E+00 0.000000E+00 5.160490E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(21)
E = 1.595951E+03
P = 0.000000E+00 0.000000E+00 -1.595951E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(-92*)
E = 1.339510E+03
P = 0.000000E+00 0.000000E+00 1.339510E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(93*)
E = 4.904049E+03
P = 0.000000E+00 0.000000E+00 -4.904049E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.597254E+03
P = 1.673304E+00 6.625245E-01 -1.594648E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(1)
E = 5.159187E+03
P = -1.673304E+00 -6.625245E-01 5.159187E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
3067832660.0, 4275592703.0, 1632202331.0,
3461487745.0, 2283704839.0, 3609569101.0,
]
Beginning substream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Initial stream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 6.387070E+03
P = 0.000000E+00 0.000000E+00 6.387070E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(21)
E = 2.145160E+03
P = 0.000000E+00 0.000000E+00 -2.145160E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 1.129304E+02
P = 0.000000E+00 0.000000E+00 1.129304E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(93*)
E = 4.354840E+03
P = 0.000000E+00 0.000000E+00 -4.354840E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.704843E+03
P = 6.679665E+02 2.947910E+02 -1.537886E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 5.265648E+03
P = 6.641794E+02 2.932715E+02 5.215353E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 1.561738E+03
P = -1.332146E+03 -5.880626E+02 5.644431E+02
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 4.990885634E-09
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.160490E+03
P = 0.000000E+00 0.000000E+00 5.160490E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(-2)
E = 1.595951E+03
P = 0.000000E+00 0.000000E+00 -1.595951E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(-92*)
E = 1.339510E+03
P = 0.000000E+00 0.000000E+00 1.339510E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 4.904049E+03
P = 0.000000E+00 0.000000E+00 -4.904049E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.597254E+03
P = 1.673304E+00 6.625245E-01 -1.594648E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 5.159187E+03
P = -1.673304E+00 -6.625245E-01 5.159187E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 6.387070E+03
P = 0.000000E+00 0.000000E+00 6.387070E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 2.145160E+03
P = 0.000000E+00 0.000000E+00 -2.145160E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 1.129304E+02
P = 0.000000E+00 0.000000E+00 1.129304E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 4.354840E+03
P = 0.000000E+00 0.000000E+00 -4.354840E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.704843E+03
P = 6.679665E+02 2.947910E+02 -1.537886E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 5.265648E+03
P = 6.641794E+02 2.932715E+02 5.215353E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 1.561738E+03
P = -1.332146E+03 -5.880626E+02 5.644431E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 6.387070E+03
P = 0.000000E+00 0.000000E+00 6.387070E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 2.145160E+03
P = 0.000000E+00 0.000000E+00 -2.145160E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 1.129304E+02
P = 0.000000E+00 0.000000E+00 1.129304E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 4.354840E+03
P = 0.000000E+00 0.000000E+00 -4.354840E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.704843E+03
P = 6.679665E+02 2.947910E+02 -1.537886E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 5.265648E+03
P = 6.641794E+02 2.932715E+02 5.215353E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 1.561738E+03
P = -1.332146E+03 -5.880626E+02 5.644431E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(21)
E = 5.160490E+03
P = 0.000000E+00 0.000000E+00 5.160490E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 1.595951E+03
P = 0.000000E+00 0.000000E+00 -1.595951E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(93*)
E = 1.339510E+03
P = 0.000000E+00 0.000000E+00 1.339510E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 4.904049E+03
P = 0.000000E+00 0.000000E+00 -4.904049E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.485301E+03
P = 1.555760E+00 6.159843E-01 -1.482498E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 4.251072E+02
P = 1.420108E+01 3.664827E+02 2.149533E+02
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 4.846033E+03
P = -1.575684E+01 -3.670987E+02 4.832083E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 6.387070E+03
P = 0.000000E+00 0.000000E+00 6.387070E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(21)
E = 2.145160E+03
P = 0.000000E+00 0.000000E+00 -2.145160E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 1.129304E+02
P = 0.000000E+00 0.000000E+00 1.129304E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(93*)
E = 4.354840E+03
P = 0.000000E+00 0.000000E+00 -4.354840E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.704843E+03
P = 6.679665E+02 2.947910E+02 -1.537886E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 5.265648E+03
P = 6.641794E+02 2.932715E+02 5.215353E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 1.561738E+03
P = -1.332146E+03 -5.880626E+02 5.644431E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 7.40305E+03
n_in* => 2
n_out* => 5
n_tot* => 7
$process_id* => "nlo_ppzj_sim_4_p1"
process_num_id* => [unknown integer]
sqme* => 5.12258E-07
sqme_ref* => 1.59038E+00
event_index* => 7
event_weight* => 1.96811E-09
event_weight_ref* => 6.11028E-03
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:2|-6.3870696E+03; 0.0000000E+00, 0.0000000E+00,-6.3870696E+03| 0.0000000E+00| 3)
4 prt(i:2|-2.1451599E+03; 0.0000000E+00, 0.0000000E+00, 2.1451599E+03| 0.0000000E+00| 4)
5 prt(o:-92| 1.1293035E+02; 0.0000000E+00, 0.0000000E+00, 1.1293035E+02| 0.0000000E+00| 5)
6 prt(o:-92| 4.3548401E+03; 0.0000000E+00, 0.0000000E+00,-4.3548401E+03| 0.0000000E+00| 6)
7 prt(o:23| 1.7048433E+03; 6.6796651E+02, 2.9479103E+02,-1.5378864E+03| 8.3152513E+03| 7)
8 prt(o:2| 5.2656480E+03; 6.6417942E+02, 2.9327153E+02, 5.2153530E+03| 0.0000000E+00| 8)
9 prt(o:2| 1.5617383E+03;-1.3321459E+03,-5.8806255E+02, 5.6444313E+02| 0.0000000E+00| 9)
========================================================================
========================================================================
Event #7
------------------------------------------------------------------------
Unweighted = F
Normalization = 'sigma'
Helicity handling = drop
Keep correlations = F
------------------------------------------------------------------------
Squared matrix el. (ref) = 1.59038E+00
Squared matrix el. (prc) = 1.59038E+00
Event weight (ref) = 6.11028E-03
Event weight (prc) = 6.11028E-03
------------------------------------------------------------------------
Selected MCI group = 1
Selected term = 1
Selected channel = 1
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
2255705969.0, 3362628724.0, 2952502488.0,
3217231987.0, 2487643470.0, 2150867474.0,
]
Beginning substream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Initial stream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(1)
E = 5.160490E+03
P = 0.000000E+00 0.000000E+00 5.160490E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(21)
E = 1.595951E+03
P = 0.000000E+00 0.000000E+00 -1.595951E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(-92*)
E = 1.339510E+03
P = 0.000000E+00 0.000000E+00 1.339510E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(93*)
E = 4.904049E+03
P = 0.000000E+00 0.000000E+00 -4.904049E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.597254E+03
P = 1.673304E+00 6.625245E-01 -1.594648E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(1)
E = 5.159187E+03
P = -1.673304E+00 -6.625245E-01 5.159187E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
3067832660.0, 4275592703.0, 1632202331.0,
3461487745.0, 2283704839.0, 3609569101.0,
]
Beginning substream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Initial stream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 6.387070E+03
P = 0.000000E+00 0.000000E+00 6.387070E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(21)
E = 2.145160E+03
P = 0.000000E+00 0.000000E+00 -2.145160E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 1.129304E+02
P = 0.000000E+00 0.000000E+00 1.129304E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(93*)
E = 4.354840E+03
P = 0.000000E+00 0.000000E+00 -4.354840E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.704843E+03
P = 6.679665E+02 2.947910E+02 -1.537886E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 5.265648E+03
P = 6.641794E+02 2.932715E+02 5.215353E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 1.561738E+03
P = -1.332146E+03 -5.880626E+02 5.644431E+02
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 4.990885634E-09
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.160490E+03
P = 0.000000E+00 0.000000E+00 5.160490E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(-2)
E = 1.595951E+03
P = 0.000000E+00 0.000000E+00 -1.595951E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(-92*)
E = 1.339510E+03
P = 0.000000E+00 0.000000E+00 1.339510E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 4.904049E+03
P = 0.000000E+00 0.000000E+00 -4.904049E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.597254E+03
P = 1.673304E+00 6.625245E-01 -1.594648E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 5.159187E+03
P = -1.673304E+00 -6.625245E-01 5.159187E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 6.387070E+03
P = 0.000000E+00 0.000000E+00 6.387070E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 2.145160E+03
P = 0.000000E+00 0.000000E+00 -2.145160E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 1.129304E+02
P = 0.000000E+00 0.000000E+00 1.129304E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 4.354840E+03
P = 0.000000E+00 0.000000E+00 -4.354840E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.704843E+03
P = 6.679665E+02 2.947910E+02 -1.537886E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 5.265648E+03
P = 6.641794E+02 2.932715E+02 5.215353E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 1.561738E+03
P = -1.332146E+03 -5.880626E+02 5.644431E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 6.387070E+03
P = 0.000000E+00 0.000000E+00 6.387070E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 2.145160E+03
P = 0.000000E+00 0.000000E+00 -2.145160E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 1.129304E+02
P = 0.000000E+00 0.000000E+00 1.129304E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 4.354840E+03
P = 0.000000E+00 0.000000E+00 -4.354840E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.704843E+03
P = 6.679665E+02 2.947910E+02 -1.537886E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 5.265648E+03
P = 6.641794E+02 2.932715E+02 5.215353E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 1.561738E+03
P = -1.332146E+03 -5.880626E+02 5.644431E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(21)
E = 5.160490E+03
P = 0.000000E+00 0.000000E+00 5.160490E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 1.595951E+03
P = 0.000000E+00 0.000000E+00 -1.595951E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(93*)
E = 1.339510E+03
P = 0.000000E+00 0.000000E+00 1.339510E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 4.904049E+03
P = 0.000000E+00 0.000000E+00 -4.904049E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.485301E+03
P = 1.555760E+00 6.159843E-01 -1.482498E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 4.251072E+02
P = 1.420108E+01 3.664827E+02 2.149533E+02
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 4.846033E+03
P = -1.575684E+01 -3.670987E+02 4.832083E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 6.387070E+03
P = 0.000000E+00 0.000000E+00 6.387070E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(21)
E = 2.145160E+03
P = 0.000000E+00 0.000000E+00 -2.145160E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 1.129304E+02
P = 0.000000E+00 0.000000E+00 1.129304E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(93*)
E = 4.354840E+03
P = 0.000000E+00 0.000000E+00 -4.354840E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.704843E+03
P = 6.679665E+02 2.947910E+02 -1.537886E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 5.265648E+03
P = 6.641794E+02 2.932715E+02 5.215353E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 1.561738E+03
P = -1.332146E+03 -5.880626E+02 5.644431E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 5.73965E+03
n_in* => 2
n_out* => 5
n_tot* => 7
$process_id* => "nlo_ppzj_sim_4_p1"
process_num_id* => [unknown integer]
sqme* => 1.59038E+00
sqme_ref* => 1.59038E+00
event_index* => 7
event_weight* => 6.11028E-03
event_weight_ref* => 6.11028E-03
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:21|-5.1604898E+03; 0.0000000E+00, 0.0000000E+00,-5.1604898E+03| 0.0000000E+00| 3)
4 prt(i:2|-1.5959512E+03; 0.0000000E+00, 0.0000000E+00, 1.5959512E+03| 0.0000000E+00| 4)
5 prt(o:93| 1.3395102E+03; 0.0000000E+00, 0.0000000E+00, 1.3395102E+03| 0.0000000E+00| 5)
6 prt(o:-92| 4.9040488E+03; 0.0000000E+00, 0.0000000E+00,-4.9040488E+03| 0.0000000E+00| 6)
7 prt(o:23| 1.4853006E+03; 1.5557598E+00, 6.1598427E-01,-1.4824978E+03| 8.3152513E+03| 7)
8 prt(o:2| 4.2510723E+02; 1.4201082E+01, 3.6648270E+02, 2.1495328E+02| 0.0000000E+00| 8)
9 prt(o:21| 4.8460332E+03;-1.5756841E+01,-3.6709869E+02, 4.8320832E+03| 0.0000000E+00| 9)
========================================================================
========================================================================
Event #7
------------------------------------------------------------------------
Unweighted = F
Normalization = 'sigma'
Helicity handling = drop
Keep correlations = F
------------------------------------------------------------------------
Squared matrix el. (ref) = 1.59038E+00
Squared matrix el. (prc) = 4.99089E-09
Event weight (ref) = 6.11028E-03
Event weight (prc) = 1.91751E-11
------------------------------------------------------------------------
Selected MCI group = 1
Selected term = 1
Selected channel = 1
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
2255705969.0, 3362628724.0, 2952502488.0,
3217231987.0, 2487643470.0, 2150867474.0,
]
Beginning substream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Initial stream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(1)
E = 5.160490E+03
P = 0.000000E+00 0.000000E+00 5.160490E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(21)
E = 1.595951E+03
P = 0.000000E+00 0.000000E+00 -1.595951E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(-92*)
E = 1.339510E+03
P = 0.000000E+00 0.000000E+00 1.339510E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(93*)
E = 4.904049E+03
P = 0.000000E+00 0.000000E+00 -4.904049E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.597254E+03
P = 1.673304E+00 6.625245E-01 -1.594648E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(1)
E = 5.159187E+03
P = -1.673304E+00 -6.625245E-01 5.159187E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
3067832660.0, 4275592703.0, 1632202331.0,
3461487745.0, 2283704839.0, 3609569101.0,
]
Beginning substream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Initial stream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 6.387070E+03
P = 0.000000E+00 0.000000E+00 6.387070E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(21)
E = 2.145160E+03
P = 0.000000E+00 0.000000E+00 -2.145160E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 1.129304E+02
P = 0.000000E+00 0.000000E+00 1.129304E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(93*)
E = 4.354840E+03
P = 0.000000E+00 0.000000E+00 -4.354840E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.704843E+03
P = 6.679665E+02 2.947910E+02 -1.537886E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 5.265648E+03
P = 6.641794E+02 2.932715E+02 5.215353E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 1.561738E+03
P = -1.332146E+03 -5.880626E+02 5.644431E+02
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 4.990885634E-09
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.160490E+03
P = 0.000000E+00 0.000000E+00 5.160490E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(-2)
E = 1.595951E+03
P = 0.000000E+00 0.000000E+00 -1.595951E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(-92*)
E = 1.339510E+03
P = 0.000000E+00 0.000000E+00 1.339510E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 4.904049E+03
P = 0.000000E+00 0.000000E+00 -4.904049E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.597254E+03
P = 1.673304E+00 6.625245E-01 -1.594648E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 5.159187E+03
P = -1.673304E+00 -6.625245E-01 5.159187E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 6.387070E+03
P = 0.000000E+00 0.000000E+00 6.387070E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 2.145160E+03
P = 0.000000E+00 0.000000E+00 -2.145160E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 1.129304E+02
P = 0.000000E+00 0.000000E+00 1.129304E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 4.354840E+03
P = 0.000000E+00 0.000000E+00 -4.354840E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.704843E+03
P = 6.679665E+02 2.947910E+02 -1.537886E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 5.265648E+03
P = 6.641794E+02 2.932715E+02 5.215353E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 1.561738E+03
P = -1.332146E+03 -5.880626E+02 5.644431E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 6.387070E+03
P = 0.000000E+00 0.000000E+00 6.387070E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 2.145160E+03
P = 0.000000E+00 0.000000E+00 -2.145160E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 1.129304E+02
P = 0.000000E+00 0.000000E+00 1.129304E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 4.354840E+03
P = 0.000000E+00 0.000000E+00 -4.354840E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.704843E+03
P = 6.679665E+02 2.947910E+02 -1.537886E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 5.265648E+03
P = 6.641794E+02 2.932715E+02 5.215353E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 1.561738E+03
P = -1.332146E+03 -5.880626E+02 5.644431E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(21)
E = 5.160490E+03
P = 0.000000E+00 0.000000E+00 5.160490E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 1.595951E+03
P = 0.000000E+00 0.000000E+00 -1.595951E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(93*)
E = 1.339510E+03
P = 0.000000E+00 0.000000E+00 1.339510E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 4.904049E+03
P = 0.000000E+00 0.000000E+00 -4.904049E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.485301E+03
P = 1.555760E+00 6.159843E-01 -1.482498E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 4.251072E+02
P = 1.420108E+01 3.664827E+02 2.149533E+02
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 4.846033E+03
P = -1.575684E+01 -3.670987E+02 4.832083E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 6.387070E+03
P = 0.000000E+00 0.000000E+00 6.387070E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(21)
E = 2.145160E+03
P = 0.000000E+00 0.000000E+00 -2.145160E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 1.129304E+02
P = 0.000000E+00 0.000000E+00 1.129304E+02
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(93*)
E = 4.354840E+03
P = 0.000000E+00 0.000000E+00 -4.354840E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.704843E+03
P = 6.679665E+02 2.947910E+02 -1.537886E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 5.265648E+03
P = 6.641794E+02 2.932715E+02 5.215353E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 1.561738E+03
P = -1.332146E+03 -5.880626E+02 5.644431E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 7.40305E+03
n_in* => 2
n_out* => 5
n_tot* => 7
$process_id* => "nlo_ppzj_sim_4_p1"
process_num_id* => [unknown integer]
sqme* => 4.99089E-09
sqme_ref* => 1.59038E+00
event_index* => 7
event_weight* => 1.91751E-11
event_weight_ref* => 6.11028E-03
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:2|-6.3870696E+03; 0.0000000E+00, 0.0000000E+00,-6.3870696E+03| 0.0000000E+00| 3)
4 prt(i:21|-2.1451599E+03; 0.0000000E+00, 0.0000000E+00, 2.1451599E+03| 0.0000000E+00| 4)
5 prt(o:-92| 1.1293035E+02; 0.0000000E+00, 0.0000000E+00, 1.1293035E+02| 0.0000000E+00| 5)
6 prt(o:93| 4.3548401E+03; 0.0000000E+00, 0.0000000E+00,-4.3548401E+03| 0.0000000E+00| 6)
7 prt(o:23| 1.7048433E+03; 6.6796651E+02, 2.9479103E+02,-1.5378864E+03| 8.3152513E+03| 7)
8 prt(o:2| 5.2656480E+03; 6.6417942E+02, 2.9327153E+02, 5.2153530E+03| 0.0000000E+00| 8)
9 prt(o:21| 1.5617383E+03;-1.3321459E+03,-5.8806255E+02, 5.6444313E+02| 0.0000000E+00| 9)
========================================================================
========================================================================
Event #8
------------------------------------------------------------------------
Unweighted = F
Normalization = 'sigma'
Helicity handling = drop
Keep correlations = F
------------------------------------------------------------------------
Squared matrix el. (ref) = 1.22205E-05
Squared matrix el. (prc) = 0.00000E+00
Event weight (ref) = 1.52416E-07
Event weight (prc) = 0.00000E+00
------------------------------------------------------------------------
Selected MCI group = 1
Selected term = 1
Selected channel = 1
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
1192482036.0, 1968883869.0, 1938438900.0,
3234925546.0, 3131790489.0, 1230733295.0,
]
Beginning substream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Initial stream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 4.606912E+03
P = 0.000000E+00 0.000000E+00 4.606912E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(-2)
E = 5.554724E+03
P = 0.000000E+00 0.000000E+00 -5.554724E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(-92*)
E = 1.893088E+03
P = 0.000000E+00 0.000000E+00 1.893088E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 9.452759E+02
P = 0.000000E+00 0.000000E+00 -9.452759E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 4.607389E+03
P = -5.099099E+01 -1.354577E+01 4.606185E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 5.554247E+03
P = 5.099099E+01 1.354577E+01 -5.553996E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
2087395566.0, 3425230159.0, 3778769805.0,
1373308892.0, 4077747007.0, 949488640.0,
]
Beginning substream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Initial stream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 4.622765E+03
P = 0.000000E+00 0.000000E+00 4.622765E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 5.902555E+03
P = 0.000000E+00 0.000000E+00 -5.902555E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 1.877235E+03
P = 0.000000E+00 0.000000E+00 1.877235E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 5.974449E+02
P = 0.000000E+00 0.000000E+00 -5.974449E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 4.607172E+03
P = 1.397037E+01 1.989221E+01 4.606205E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 5.555525E+03
P = 1.159513E+02 4.698324E+01 -5.554116E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 3.626239E+02
P = -1.299217E+02 -6.687545E+01 -3.318796E+02
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 2.717795893E-05
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 4.606912E+03
P = 0.000000E+00 0.000000E+00 4.606912E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(-2)
E = 5.554724E+03
P = 0.000000E+00 0.000000E+00 -5.554724E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(-92*)
E = 1.893088E+03
P = 0.000000E+00 0.000000E+00 1.893088E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 9.452759E+02
P = 0.000000E+00 0.000000E+00 -9.452759E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 4.607389E+03
P = -5.099099E+01 -1.354577E+01 4.606185E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 5.554247E+03
P = 5.099099E+01 1.354577E+01 -5.553996E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 4.622765E+03
P = 0.000000E+00 0.000000E+00 4.622765E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 5.902555E+03
P = 0.000000E+00 0.000000E+00 -5.902555E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 1.877235E+03
P = 0.000000E+00 0.000000E+00 1.877235E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 5.974449E+02
P = 0.000000E+00 0.000000E+00 -5.974449E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 4.607172E+03
P = 1.397037E+01 1.989221E+01 4.606205E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 5.555525E+03
P = 1.159513E+02 4.698324E+01 -5.554116E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 3.626239E+02
P = -1.299217E+02 -6.687545E+01 -3.318796E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 4.622765E+03
P = 0.000000E+00 0.000000E+00 4.622765E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 5.902555E+03
P = 0.000000E+00 0.000000E+00 -5.902555E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 1.877235E+03
P = 0.000000E+00 0.000000E+00 1.877235E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 5.974449E+02
P = 0.000000E+00 0.000000E+00 -5.974449E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 4.607172E+03
P = 1.397037E+01 1.989221E+01 4.606205E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 5.555525E+03
P = 1.159513E+02 4.698324E+01 -5.554116E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 3.626239E+02
P = -1.299217E+02 -6.687545E+01 -3.318796E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 4.606912E+03
P = 0.000000E+00 0.000000E+00 4.606912E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 5.554724E+03
P = 0.000000E+00 0.000000E+00 -5.554724E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 1.893088E+03
P = 0.000000E+00 0.000000E+00 1.893088E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 9.452759E+02
P = 0.000000E+00 0.000000E+00 -9.452759E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.899078E+03
P = -3.207596E+01 -8.520988E+00 2.897454E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 5.337513E+03
P = 9.979866E+02 -1.039449E+03 -5.139320E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 1.925046E+03
P = -9.659106E+02 1.047970E+03 1.294055E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 4.622765E+03
P = 0.000000E+00 0.000000E+00 4.622765E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 5.902555E+03
P = 0.000000E+00 0.000000E+00 -5.902555E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 1.877235E+03
P = 0.000000E+00 0.000000E+00 1.877235E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 5.974449E+02
P = 0.000000E+00 0.000000E+00 -5.974449E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 4.607172E+03
P = 1.397037E+01 1.989221E+01 4.606205E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 5.555525E+03
P = 1.159513E+02 4.698324E+01 -5.554116E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 3.626239E+02
P = -1.299217E+02 -6.687545E+01 -3.318796E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 1.01173E+04
n_in* => 2
n_out* => 4
n_tot* => 6
$process_id* => "nlo_ppzj_sim_4_p1"
process_num_id* => [unknown integer]
sqme* => 0.00000E+00
sqme_ref* => 1.22205E-05
event_index* => 8
event_weight* => 0.00000E+00
event_weight_ref* => 1.52416E-07
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:2|-4.6069122E+03; 0.0000000E+00, 0.0000000E+00,-4.6069122E+03| 0.0000000E+00| 3)
4 prt(i:-2|-5.5547241E+03; 0.0000000E+00, 0.0000000E+00, 5.5547241E+03| 0.0000000E+00| 4)
5 prt(o:-92| 1.8930878E+03; 0.0000000E+00, 0.0000000E+00, 1.8930878E+03| 0.0000000E+00| 5)
6 prt(o:92| 9.4527590E+02; 0.0000000E+00, 0.0000000E+00,-9.4527590E+02| 0.0000000E+00| 6)
7 prt(o:23| 4.6073893E+03;-5.0990985E+01,-1.3545771E+01, 4.6061846E+03| 8.3152513E+03| 7)
8 prt(o:21| 5.5542471E+03; 5.0990985E+01, 1.3545771E+01,-5.5539965E+03| 0.0000000E+00| 8)
========================================================================
========================================================================
Event #8
------------------------------------------------------------------------
Unweighted = F
Normalization = 'sigma'
Helicity handling = drop
Keep correlations = F
------------------------------------------------------------------------
Squared matrix el. (ref) = 1.22205E-05
Squared matrix el. (prc) = 2.27337E-01
Event weight (ref) = 1.52416E-07
Event weight (prc) = 0.00000E+00
------------------------------------------------------------------------
Selected MCI group = 1
Selected term = 1
Selected channel = 1
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
1192482036.0, 1968883869.0, 1938438900.0,
3234925546.0, 3131790489.0, 1230733295.0,
]
Beginning substream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Initial stream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 4.606912E+03
P = 0.000000E+00 0.000000E+00 4.606912E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(-2)
E = 5.554724E+03
P = 0.000000E+00 0.000000E+00 -5.554724E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(-92*)
E = 1.893088E+03
P = 0.000000E+00 0.000000E+00 1.893088E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 9.452759E+02
P = 0.000000E+00 0.000000E+00 -9.452759E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 4.607389E+03
P = -5.099099E+01 -1.354577E+01 4.606185E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 5.554247E+03
P = 5.099099E+01 1.354577E+01 -5.553996E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
2087395566.0, 3425230159.0, 3778769805.0,
1373308892.0, 4077747007.0, 949488640.0,
]
Beginning substream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Initial stream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 4.622765E+03
P = 0.000000E+00 0.000000E+00 4.622765E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 5.902555E+03
P = 0.000000E+00 0.000000E+00 -5.902555E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 1.877235E+03
P = 0.000000E+00 0.000000E+00 1.877235E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 5.974449E+02
P = 0.000000E+00 0.000000E+00 -5.974449E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 4.607172E+03
P = 1.397037E+01 1.989221E+01 4.606205E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 5.555525E+03
P = 1.159513E+02 4.698324E+01 -5.554116E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 3.626239E+02
P = -1.299217E+02 -6.687545E+01 -3.318796E+02
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 2.717795893E-05
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 4.606912E+03
P = 0.000000E+00 0.000000E+00 4.606912E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(-2)
E = 5.554724E+03
P = 0.000000E+00 0.000000E+00 -5.554724E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(-92*)
E = 1.893088E+03
P = 0.000000E+00 0.000000E+00 1.893088E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 9.452759E+02
P = 0.000000E+00 0.000000E+00 -9.452759E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 4.607389E+03
P = -5.099099E+01 -1.354577E+01 4.606185E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 5.554247E+03
P = 5.099099E+01 1.354577E+01 -5.553996E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 4.622765E+03
P = 0.000000E+00 0.000000E+00 4.622765E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 5.902555E+03
P = 0.000000E+00 0.000000E+00 -5.902555E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 1.877235E+03
P = 0.000000E+00 0.000000E+00 1.877235E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 5.974449E+02
P = 0.000000E+00 0.000000E+00 -5.974449E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 4.607172E+03
P = 1.397037E+01 1.989221E+01 4.606205E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 5.555525E+03
P = 1.159513E+02 4.698324E+01 -5.554116E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 3.626239E+02
P = -1.299217E+02 -6.687545E+01 -3.318796E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 4.622765E+03
P = 0.000000E+00 0.000000E+00 4.622765E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 5.902555E+03
P = 0.000000E+00 0.000000E+00 -5.902555E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 1.877235E+03
P = 0.000000E+00 0.000000E+00 1.877235E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 5.974449E+02
P = 0.000000E+00 0.000000E+00 -5.974449E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 4.607172E+03
P = 1.397037E+01 1.989221E+01 4.606205E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 5.555525E+03
P = 1.159513E+02 4.698324E+01 -5.554116E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 3.626239E+02
P = -1.299217E+02 -6.687545E+01 -3.318796E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 4.606912E+03
P = 0.000000E+00 0.000000E+00 4.606912E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 5.554724E+03
P = 0.000000E+00 0.000000E+00 -5.554724E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 1.893088E+03
P = 0.000000E+00 0.000000E+00 1.893088E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 9.452759E+02
P = 0.000000E+00 0.000000E+00 -9.452759E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.899078E+03
P = -3.207596E+01 -8.520988E+00 2.897454E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 5.337513E+03
P = 9.979866E+02 -1.039449E+03 -5.139320E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 1.925046E+03
P = -9.659106E+02 1.047970E+03 1.294055E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 4.622765E+03
P = 0.000000E+00 0.000000E+00 4.622765E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 5.902555E+03
P = 0.000000E+00 0.000000E+00 -5.902555E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 1.877235E+03
P = 0.000000E+00 0.000000E+00 1.877235E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 5.974449E+02
P = 0.000000E+00 0.000000E+00 -5.974449E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 4.607172E+03
P = 1.397037E+01 1.989221E+01 4.606205E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 5.555525E+03
P = 1.159513E+02 4.698324E+01 -5.554116E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 3.626239E+02
P = -1.299217E+02 -6.687545E+01 -3.318796E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 1.04472E+04
n_in* => 2
n_out* => 5
n_tot* => 7
$process_id* => "nlo_ppzj_sim_4_p1"
process_num_id* => [unknown integer]
sqme* => 2.27337E-01
sqme_ref* => 1.22205E-05
event_index* => 8
event_weight* => 0.00000E+00
event_weight_ref* => 1.52416E-07
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:-2|-4.6227648E+03; 0.0000000E+00, 0.0000000E+00,-4.6227648E+03| 0.0000000E+00| 3)
4 prt(i:-2|-5.9025551E+03; 0.0000000E+00, 0.0000000E+00, 5.9025551E+03| 0.0000000E+00| 4)
5 prt(o:92| 1.8772352E+03; 0.0000000E+00, 0.0000000E+00, 1.8772352E+03| 0.0000000E+00| 5)
6 prt(o:92| 5.9744485E+02; 0.0000000E+00, 0.0000000E+00,-5.9744485E+02| 0.0000000E+00| 6)
7 prt(o:23| 4.6071716E+03; 1.3970372E+01, 1.9892208E+01, 4.6062049E+03| 8.3152513E+03| 7)
8 prt(o:-2| 5.5555245E+03; 1.1595135E+02, 4.6983238E+01,-5.5541156E+03| 0.0000000E+00| 8)
9 prt(o:-2| 3.6262385E+02;-1.2992172E+02,-6.6875446E+01,-3.3187962E+02| 0.0000000E+00| 9)
========================================================================
========================================================================
Event #8
------------------------------------------------------------------------
Unweighted = F
Normalization = 'sigma'
Helicity handling = drop
Keep correlations = F
------------------------------------------------------------------------
Squared matrix el. (ref) = 1.22205E-05
Squared matrix el. (prc) = 1.64837E-02
Event weight (ref) = 1.52416E-07
Event weight (prc) = 0.00000E+00
------------------------------------------------------------------------
Selected MCI group = 1
Selected term = 1
Selected channel = 1
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
1192482036.0, 1968883869.0, 1938438900.0,
3234925546.0, 3131790489.0, 1230733295.0,
]
Beginning substream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Initial stream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 4.606912E+03
P = 0.000000E+00 0.000000E+00 4.606912E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(-2)
E = 5.554724E+03
P = 0.000000E+00 0.000000E+00 -5.554724E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(-92*)
E = 1.893088E+03
P = 0.000000E+00 0.000000E+00 1.893088E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 9.452759E+02
P = 0.000000E+00 0.000000E+00 -9.452759E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 4.607389E+03
P = -5.099099E+01 -1.354577E+01 4.606185E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 5.554247E+03
P = 5.099099E+01 1.354577E+01 -5.553996E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
2087395566.0, 3425230159.0, 3778769805.0,
1373308892.0, 4077747007.0, 949488640.0,
]
Beginning substream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Initial stream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 4.622765E+03
P = 0.000000E+00 0.000000E+00 4.622765E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 5.902555E+03
P = 0.000000E+00 0.000000E+00 -5.902555E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 1.877235E+03
P = 0.000000E+00 0.000000E+00 1.877235E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 5.974449E+02
P = 0.000000E+00 0.000000E+00 -5.974449E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 4.607172E+03
P = 1.397037E+01 1.989221E+01 4.606205E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 5.555525E+03
P = 1.159513E+02 4.698324E+01 -5.554116E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 3.626239E+02
P = -1.299217E+02 -6.687545E+01 -3.318796E+02
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 2.717795893E-05
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 4.606912E+03
P = 0.000000E+00 0.000000E+00 4.606912E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(-2)
E = 5.554724E+03
P = 0.000000E+00 0.000000E+00 -5.554724E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(-92*)
E = 1.893088E+03
P = 0.000000E+00 0.000000E+00 1.893088E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 9.452759E+02
P = 0.000000E+00 0.000000E+00 -9.452759E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 4.607389E+03
P = -5.099099E+01 -1.354577E+01 4.606185E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 5.554247E+03
P = 5.099099E+01 1.354577E+01 -5.553996E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 4.622765E+03
P = 0.000000E+00 0.000000E+00 4.622765E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 5.902555E+03
P = 0.000000E+00 0.000000E+00 -5.902555E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 1.877235E+03
P = 0.000000E+00 0.000000E+00 1.877235E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 5.974449E+02
P = 0.000000E+00 0.000000E+00 -5.974449E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 4.607172E+03
P = 1.397037E+01 1.989221E+01 4.606205E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 5.555525E+03
P = 1.159513E+02 4.698324E+01 -5.554116E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 3.626239E+02
P = -1.299217E+02 -6.687545E+01 -3.318796E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 4.622765E+03
P = 0.000000E+00 0.000000E+00 4.622765E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 5.902555E+03
P = 0.000000E+00 0.000000E+00 -5.902555E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 1.877235E+03
P = 0.000000E+00 0.000000E+00 1.877235E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 5.974449E+02
P = 0.000000E+00 0.000000E+00 -5.974449E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 4.607172E+03
P = 1.397037E+01 1.989221E+01 4.606205E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 5.555525E+03
P = 1.159513E+02 4.698324E+01 -5.554116E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 3.626239E+02
P = -1.299217E+02 -6.687545E+01 -3.318796E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 4.606912E+03
P = 0.000000E+00 0.000000E+00 4.606912E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 5.554724E+03
P = 0.000000E+00 0.000000E+00 -5.554724E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 1.893088E+03
P = 0.000000E+00 0.000000E+00 1.893088E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 9.452759E+02
P = 0.000000E+00 0.000000E+00 -9.452759E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.899078E+03
P = -3.207596E+01 -8.520988E+00 2.897454E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 5.337513E+03
P = 9.979866E+02 -1.039449E+03 -5.139320E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 1.925046E+03
P = -9.659106E+02 1.047970E+03 1.294055E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 4.622765E+03
P = 0.000000E+00 0.000000E+00 4.622765E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 5.902555E+03
P = 0.000000E+00 0.000000E+00 -5.902555E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 1.877235E+03
P = 0.000000E+00 0.000000E+00 1.877235E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 5.974449E+02
P = 0.000000E+00 0.000000E+00 -5.974449E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 4.607172E+03
P = 1.397037E+01 1.989221E+01 4.606205E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 5.555525E+03
P = 1.159513E+02 4.698324E+01 -5.554116E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 3.626239E+02
P = -1.299217E+02 -6.687545E+01 -3.318796E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 1.04472E+04
n_in* => 2
n_out* => 5
n_tot* => 7
$process_id* => "nlo_ppzj_sim_4_p1"
process_num_id* => [unknown integer]
sqme* => 1.64837E-02
sqme_ref* => 1.22205E-05
event_index* => 8
event_weight* => 0.00000E+00
event_weight_ref* => 1.52416E-07
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:-2|-4.6227648E+03; 0.0000000E+00, 0.0000000E+00,-4.6227648E+03| 0.0000000E+00| 3)
4 prt(i:-2|-5.9025551E+03; 0.0000000E+00, 0.0000000E+00, 5.9025551E+03| 0.0000000E+00| 4)
5 prt(o:92| 1.8772352E+03; 0.0000000E+00, 0.0000000E+00, 1.8772352E+03| 0.0000000E+00| 5)
6 prt(o:92| 5.9744485E+02; 0.0000000E+00, 0.0000000E+00,-5.9744485E+02| 0.0000000E+00| 6)
7 prt(o:23| 4.6071716E+03; 1.3970372E+01, 1.9892208E+01, 4.6062049E+03| 8.3152513E+03| 7)
8 prt(o:-2| 5.5555245E+03; 1.1595135E+02, 4.6983238E+01,-5.5541156E+03| 0.0000000E+00| 8)
9 prt(o:-2| 3.6262385E+02;-1.2992172E+02,-6.6875446E+01,-3.3187962E+02| 0.0000000E+00| 9)
========================================================================
========================================================================
Event #8
------------------------------------------------------------------------
Unweighted = F
Normalization = 'sigma'
Helicity handling = drop
Keep correlations = F
------------------------------------------------------------------------
Squared matrix el. (ref) = 1.22205E-05
Squared matrix el. (prc) = 1.22205E-05
Event weight (ref) = 1.52416E-07
Event weight (prc) = 1.52416E-07
------------------------------------------------------------------------
Selected MCI group = 1
Selected term = 1
Selected channel = 1
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
1192482036.0, 1968883869.0, 1938438900.0,
3234925546.0, 3131790489.0, 1230733295.0,
]
Beginning substream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Initial stream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 4.606912E+03
P = 0.000000E+00 0.000000E+00 4.606912E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(-2)
E = 5.554724E+03
P = 0.000000E+00 0.000000E+00 -5.554724E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(-92*)
E = 1.893088E+03
P = 0.000000E+00 0.000000E+00 1.893088E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 9.452759E+02
P = 0.000000E+00 0.000000E+00 -9.452759E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 4.607389E+03
P = -5.099099E+01 -1.354577E+01 4.606185E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 5.554247E+03
P = 5.099099E+01 1.354577E+01 -5.553996E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
2087395566.0, 3425230159.0, 3778769805.0,
1373308892.0, 4077747007.0, 949488640.0,
]
Beginning substream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Initial stream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 4.622765E+03
P = 0.000000E+00 0.000000E+00 4.622765E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 5.902555E+03
P = 0.000000E+00 0.000000E+00 -5.902555E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 1.877235E+03
P = 0.000000E+00 0.000000E+00 1.877235E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 5.974449E+02
P = 0.000000E+00 0.000000E+00 -5.974449E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 4.607172E+03
P = 1.397037E+01 1.989221E+01 4.606205E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 5.555525E+03
P = 1.159513E+02 4.698324E+01 -5.554116E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 3.626239E+02
P = -1.299217E+02 -6.687545E+01 -3.318796E+02
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 2.717795893E-05
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 4.606912E+03
P = 0.000000E+00 0.000000E+00 4.606912E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(-2)
E = 5.554724E+03
P = 0.000000E+00 0.000000E+00 -5.554724E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(-92*)
E = 1.893088E+03
P = 0.000000E+00 0.000000E+00 1.893088E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 9.452759E+02
P = 0.000000E+00 0.000000E+00 -9.452759E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 4.607389E+03
P = -5.099099E+01 -1.354577E+01 4.606185E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 5.554247E+03
P = 5.099099E+01 1.354577E+01 -5.553996E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 4.622765E+03
P = 0.000000E+00 0.000000E+00 4.622765E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 5.902555E+03
P = 0.000000E+00 0.000000E+00 -5.902555E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 1.877235E+03
P = 0.000000E+00 0.000000E+00 1.877235E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 5.974449E+02
P = 0.000000E+00 0.000000E+00 -5.974449E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 4.607172E+03
P = 1.397037E+01 1.989221E+01 4.606205E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 5.555525E+03
P = 1.159513E+02 4.698324E+01 -5.554116E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 3.626239E+02
P = -1.299217E+02 -6.687545E+01 -3.318796E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 4.622765E+03
P = 0.000000E+00 0.000000E+00 4.622765E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 5.902555E+03
P = 0.000000E+00 0.000000E+00 -5.902555E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 1.877235E+03
P = 0.000000E+00 0.000000E+00 1.877235E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 5.974449E+02
P = 0.000000E+00 0.000000E+00 -5.974449E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 4.607172E+03
P = 1.397037E+01 1.989221E+01 4.606205E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 5.555525E+03
P = 1.159513E+02 4.698324E+01 -5.554116E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 3.626239E+02
P = -1.299217E+02 -6.687545E+01 -3.318796E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 4.606912E+03
P = 0.000000E+00 0.000000E+00 4.606912E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 5.554724E+03
P = 0.000000E+00 0.000000E+00 -5.554724E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 1.893088E+03
P = 0.000000E+00 0.000000E+00 1.893088E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 9.452759E+02
P = 0.000000E+00 0.000000E+00 -9.452759E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.899078E+03
P = -3.207596E+01 -8.520988E+00 2.897454E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 5.337513E+03
P = 9.979866E+02 -1.039449E+03 -5.139320E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 1.925046E+03
P = -9.659106E+02 1.047970E+03 1.294055E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 4.622765E+03
P = 0.000000E+00 0.000000E+00 4.622765E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 5.902555E+03
P = 0.000000E+00 0.000000E+00 -5.902555E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 1.877235E+03
P = 0.000000E+00 0.000000E+00 1.877235E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 5.974449E+02
P = 0.000000E+00 0.000000E+00 -5.974449E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 4.607172E+03
P = 1.397037E+01 1.989221E+01 4.606205E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 5.555525E+03
P = 1.159513E+02 4.698324E+01 -5.554116E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 3.626239E+02
P = -1.299217E+02 -6.687545E+01 -3.318796E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 1.01173E+04
n_in* => 2
n_out* => 5
n_tot* => 7
$process_id* => "nlo_ppzj_sim_4_p1"
process_num_id* => [unknown integer]
sqme* => 1.22205E-05
sqme_ref* => 1.22205E-05
event_index* => 8
event_weight* => 1.52416E-07
event_weight_ref* => 1.52416E-07
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:2|-4.6069122E+03; 0.0000000E+00, 0.0000000E+00,-4.6069122E+03| 0.0000000E+00| 3)
4 prt(i:-2|-5.5547241E+03; 0.0000000E+00, 0.0000000E+00, 5.5547241E+03| 0.0000000E+00| 4)
5 prt(o:-92| 1.8930878E+03; 0.0000000E+00, 0.0000000E+00, 1.8930878E+03| 0.0000000E+00| 5)
6 prt(o:92| 9.4527590E+02; 0.0000000E+00, 0.0000000E+00,-9.4527590E+02| 0.0000000E+00| 6)
7 prt(o:23| 2.8990781E+03;-3.2075958E+01,-8.5209881E+00, 2.8974536E+03| 8.3152513E+03| 7)
8 prt(o:-2| 5.3375126E+03; 9.9798657E+02,-1.0394486E+03,-5.1393200E+03| 0.0000000E+00| 8)
9 prt(o:2| 1.9250457E+03;-9.6591061E+02, 1.0479696E+03, 1.2940545E+03| 0.0000000E+00| 9)
========================================================================
========================================================================
Event #8
------------------------------------------------------------------------
Unweighted = F
Normalization = 'sigma'
Helicity handling = drop
Keep correlations = F
------------------------------------------------------------------------
Squared matrix el. (ref) = 1.22205E-05
Squared matrix el. (prc) = 2.71780E-05
Event weight (ref) = 1.52416E-07
Event weight (prc) = 0.00000E+00
------------------------------------------------------------------------
Selected MCI group = 1
Selected term = 1
Selected channel = 1
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
1192482036.0, 1968883869.0, 1938438900.0,
3234925546.0, 3131790489.0, 1230733295.0,
]
Beginning substream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Initial stream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 4.606912E+03
P = 0.000000E+00 0.000000E+00 4.606912E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(-2)
E = 5.554724E+03
P = 0.000000E+00 0.000000E+00 -5.554724E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(-92*)
E = 1.893088E+03
P = 0.000000E+00 0.000000E+00 1.893088E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 9.452759E+02
P = 0.000000E+00 0.000000E+00 -9.452759E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 4.607389E+03
P = -5.099099E+01 -1.354577E+01 4.606185E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 5.554247E+03
P = 5.099099E+01 1.354577E+01 -5.553996E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
2087395566.0, 3425230159.0, 3778769805.0,
1373308892.0, 4077747007.0, 949488640.0,
]
Beginning substream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Initial stream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 4.622765E+03
P = 0.000000E+00 0.000000E+00 4.622765E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 5.902555E+03
P = 0.000000E+00 0.000000E+00 -5.902555E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 1.877235E+03
P = 0.000000E+00 0.000000E+00 1.877235E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 5.974449E+02
P = 0.000000E+00 0.000000E+00 -5.974449E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 4.607172E+03
P = 1.397037E+01 1.989221E+01 4.606205E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 5.555525E+03
P = 1.159513E+02 4.698324E+01 -5.554116E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 3.626239E+02
P = -1.299217E+02 -6.687545E+01 -3.318796E+02
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 2.717795893E-05
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 4.606912E+03
P = 0.000000E+00 0.000000E+00 4.606912E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(-2)
E = 5.554724E+03
P = 0.000000E+00 0.000000E+00 -5.554724E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(-92*)
E = 1.893088E+03
P = 0.000000E+00 0.000000E+00 1.893088E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 9.452759E+02
P = 0.000000E+00 0.000000E+00 -9.452759E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 4.607389E+03
P = -5.099099E+01 -1.354577E+01 4.606185E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 5.554247E+03
P = 5.099099E+01 1.354577E+01 -5.553996E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 4.622765E+03
P = 0.000000E+00 0.000000E+00 4.622765E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 5.902555E+03
P = 0.000000E+00 0.000000E+00 -5.902555E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 1.877235E+03
P = 0.000000E+00 0.000000E+00 1.877235E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 5.974449E+02
P = 0.000000E+00 0.000000E+00 -5.974449E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 4.607172E+03
P = 1.397037E+01 1.989221E+01 4.606205E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 5.555525E+03
P = 1.159513E+02 4.698324E+01 -5.554116E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 3.626239E+02
P = -1.299217E+02 -6.687545E+01 -3.318796E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-2)
E = 4.622765E+03
P = 0.000000E+00 0.000000E+00 4.622765E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 5.902555E+03
P = 0.000000E+00 0.000000E+00 -5.902555E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 1.877235E+03
P = 0.000000E+00 0.000000E+00 1.877235E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 5.974449E+02
P = 0.000000E+00 0.000000E+00 -5.974449E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 4.607172E+03
P = 1.397037E+01 1.989221E+01 4.606205E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 5.555525E+03
P = 1.159513E+02 4.698324E+01 -5.554116E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-2)
E = 3.626239E+02
P = -1.299217E+02 -6.687545E+01 -3.318796E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 4.606912E+03
P = 0.000000E+00 0.000000E+00 4.606912E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-2)
E = 5.554724E+03
P = 0.000000E+00 0.000000E+00 -5.554724E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 1.893088E+03
P = 0.000000E+00 0.000000E+00 1.893088E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 9.452759E+02
P = 0.000000E+00 0.000000E+00 -9.452759E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.899078E+03
P = -3.207596E+01 -8.520988E+00 2.897454E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-2)
E = 5.337513E+03
P = 9.979866E+02 -1.039449E+03 -5.139320E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 1.925046E+03
P = -9.659106E+02 1.047970E+03 1.294055E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 4.622765E+03
P = 0.000000E+00 0.000000E+00 4.622765E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 5.902555E+03
P = 0.000000E+00 0.000000E+00 -5.902555E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 1.877235E+03
P = 0.000000E+00 0.000000E+00 1.877235E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 5.974449E+02
P = 0.000000E+00 0.000000E+00 -5.974449E+02
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 4.607172E+03
P = 1.397037E+01 1.989221E+01 4.606205E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 5.555525E+03
P = 1.159513E+02 4.698324E+01 -5.554116E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 3.626239E+02
P = -1.299217E+02 -6.687545E+01 -3.318796E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 1.04472E+04
n_in* => 2
n_out* => 5
n_tot* => 7
$process_id* => "nlo_ppzj_sim_4_p1"
process_num_id* => [unknown integer]
sqme* => 2.71780E-05
sqme_ref* => 1.22205E-05
event_index* => 8
event_weight* => 0.00000E+00
event_weight_ref* => 1.52416E-07
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:-3|-4.6227648E+03; 0.0000000E+00, 0.0000000E+00,-4.6227648E+03| 0.0000000E+00| 3)
4 prt(i:-3|-5.9025551E+03; 0.0000000E+00, 0.0000000E+00, 5.9025551E+03| 0.0000000E+00| 4)
5 prt(o:92| 1.8772352E+03; 0.0000000E+00, 0.0000000E+00, 1.8772352E+03| 0.0000000E+00| 5)
6 prt(o:92| 5.9744485E+02; 0.0000000E+00, 0.0000000E+00,-5.9744485E+02| 0.0000000E+00| 6)
7 prt(o:23| 4.6071716E+03; 1.3970372E+01, 1.9892208E+01, 4.6062049E+03| 8.3152513E+03| 7)
8 prt(o:-3| 5.5555245E+03; 1.1595135E+02, 4.6983238E+01,-5.5541156E+03| 0.0000000E+00| 8)
9 prt(o:-3| 3.6262385E+02;-1.2992172E+02,-6.6875446E+01,-3.3187962E+02| 0.0000000E+00| 9)
========================================================================
========================================================================
Event #9
------------------------------------------------------------------------
Unweighted = F
Normalization = 'sigma'
Helicity handling = drop
Keep correlations = F
------------------------------------------------------------------------
Squared matrix el. (ref) = 6.87798E-02
Squared matrix el. (prc) = 3.69806E-02
Event weight (ref) = 2.15380E+03
Event weight (prc) = 1.15803E+03
------------------------------------------------------------------------
Selected MCI group = 1
Selected term = 1
Selected channel = 5
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
1512051135.0, 1203905778.0, 997990153.0,
1372508840.0, 174420764.0, 1915192798.0,
]
Beginning substream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Initial stream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(1)
E = 3.627770E+03
P = 0.000000E+00 0.000000E+00 3.627770E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(21)
E = 8.416992E+02
P = 0.000000E+00 0.000000E+00 -8.416992E+02
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(-92*)
E = 2.872230E+03
P = 0.000000E+00 0.000000E+00 2.872230E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(93*)
E = 5.658301E+03
P = 0.000000E+00 0.000000E+00 -5.658301E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.806059E+03
P = 4.091975E+01 1.592726E+03 2.308073E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(1)
E = 1.663410E+03
P = -4.091975E+01 -1.592726E+03 4.779977E+02
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
2293767915.0, 1571521972.0, 1787825103.0,
1998056376.0, 691167578.0, 1043540656.0,
]
Beginning substream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Initial stream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.205149E+03
P = 0.000000E+00 0.000000E+00 5.205149E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(21)
E = 1.973730E+03
P = 0.000000E+00 0.000000E+00 -1.973730E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 1.294851E+03
P = 0.000000E+00 0.000000E+00 1.294851E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(93*)
E = 4.526270E+03
P = 0.000000E+00 0.000000E+00 -4.526270E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.733957E+03
P = 8.940481E+02 1.243035E+03 2.263128E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 2.427012E+03
P = 9.730507E+02 -2.008346E+03 9.539933E+02
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 2.017911E+03
P = -1.867099E+03 7.653116E+02 1.429867E+01
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 3.749803235E-05
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 3.627770E+03
P = 0.000000E+00 0.000000E+00 3.627770E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(21)
E = 8.416992E+02
P = 0.000000E+00 0.000000E+00 -8.416992E+02
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(-92*)
E = 2.872230E+03
P = 0.000000E+00 0.000000E+00 2.872230E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(93*)
E = 5.658301E+03
P = 0.000000E+00 0.000000E+00 -5.658301E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.806059E+03
P = 4.091975E+01 1.592726E+03 2.308073E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 1.663410E+03
P = -4.091975E+01 -1.592726E+03 4.779977E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.205149E+03
P = 0.000000E+00 0.000000E+00 5.205149E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 1.973730E+03
P = 0.000000E+00 0.000000E+00 -1.973730E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 1.294851E+03
P = 0.000000E+00 0.000000E+00 1.294851E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 4.526270E+03
P = 0.000000E+00 0.000000E+00 -4.526270E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.733957E+03
P = 8.940481E+02 1.243035E+03 2.263128E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 2.427012E+03
P = 9.730507E+02 -2.008346E+03 9.539933E+02
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 2.017911E+03
P = -1.867099E+03 7.653116E+02 1.429867E+01
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.205149E+03
P = 0.000000E+00 0.000000E+00 5.205149E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(1)
E = 1.973730E+03
P = 0.000000E+00 0.000000E+00 -1.973730E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 1.294851E+03
P = 0.000000E+00 0.000000E+00 1.294851E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 4.526270E+03
P = 0.000000E+00 0.000000E+00 -4.526270E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.733957E+03
P = 8.940481E+02 1.243035E+03 2.263128E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(1)
E = 2.427012E+03
P = 9.730507E+02 -2.008346E+03 9.539933E+02
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 2.017911E+03
P = -1.867099E+03 7.653116E+02 1.429867E+01
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 3.627770E+03
P = 0.000000E+00 0.000000E+00 3.627770E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(21)
E = 8.416992E+02
P = 0.000000E+00 0.000000E+00 -8.416992E+02
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 2.872230E+03
P = 0.000000E+00 0.000000E+00 2.872230E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(93*)
E = 5.658301E+03
P = 0.000000E+00 0.000000E+00 -5.658301E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.107334E+03
P = 3.070468E+01 1.195123E+03 1.732997E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 7.104315E+02
P = -6.638103E+02 9.283670E+01 2.354785E+02
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 1.651704E+03
P = 6.331056E+02 -1.287960E+03 8.175957E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.205149E+03
P = 0.000000E+00 0.000000E+00 5.205149E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(21)
E = 1.973730E+03
P = 0.000000E+00 0.000000E+00 -1.973730E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 1.294851E+03
P = 0.000000E+00 0.000000E+00 1.294851E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(93*)
E = 4.526270E+03
P = 0.000000E+00 0.000000E+00 -4.526270E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.733957E+03
P = 8.940481E+02 1.243035E+03 2.263128E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 2.427012E+03
P = 9.730507E+02 -2.008346E+03 9.539933E+02
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 2.017911E+03
P = -1.867099E+03 7.653116E+02 1.429867E+01
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 3.49485E+03
n_in* => 2
n_out* => 4
n_tot* => 6
$process_id* => "nlo_ppzj_sim_4_p1"
process_num_id* => [unknown integer]
sqme* => 3.69806E-02
sqme_ref* => 6.87798E-02
event_index* => 9
event_weight* => 1.15803E+03
event_weight_ref* => 2.15380E+03
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:2|-3.6277701E+03; 0.0000000E+00, 0.0000000E+00,-3.6277701E+03| 0.0000000E+00| 3)
4 prt(i:21|-8.4169922E+02; 0.0000000E+00, 0.0000000E+00, 8.4169922E+02| 0.0000000E+00| 4)
5 prt(o:-92| 2.8722299E+03; 0.0000000E+00, 0.0000000E+00, 2.8722299E+03| 0.0000000E+00| 5)
6 prt(o:93| 5.6583008E+03; 0.0000000E+00, 0.0000000E+00,-5.6583008E+03| 0.0000000E+00| 6)
7 prt(o:23| 2.8060592E+03; 4.0919748E+01, 1.5927262E+03, 2.3080732E+03| 8.3152513E+03| 7)
8 prt(o:2| 1.6634101E+03;-4.0919748E+01,-1.5927262E+03, 4.7799770E+02| 0.0000000E+00| 8)
========================================================================
========================================================================
Event #9
------------------------------------------------------------------------
Unweighted = F
Normalization = 'sigma'
Helicity handling = drop
Keep correlations = F
------------------------------------------------------------------------
Squared matrix el. (ref) = 6.87798E-02
Squared matrix el. (prc) = 2.00173E-04
Event weight (ref) = 2.15380E+03
Event weight (prc) = 6.26830E+00
------------------------------------------------------------------------
Selected MCI group = 1
Selected term = 1
Selected channel = 5
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
1512051135.0, 1203905778.0, 997990153.0,
1372508840.0, 174420764.0, 1915192798.0,
]
Beginning substream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Initial stream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(1)
E = 3.627770E+03
P = 0.000000E+00 0.000000E+00 3.627770E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(21)
E = 8.416992E+02
P = 0.000000E+00 0.000000E+00 -8.416992E+02
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(-92*)
E = 2.872230E+03
P = 0.000000E+00 0.000000E+00 2.872230E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(93*)
E = 5.658301E+03
P = 0.000000E+00 0.000000E+00 -5.658301E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.806059E+03
P = 4.091975E+01 1.592726E+03 2.308073E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(1)
E = 1.663410E+03
P = -4.091975E+01 -1.592726E+03 4.779977E+02
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
2293767915.0, 1571521972.0, 1787825103.0,
1998056376.0, 691167578.0, 1043540656.0,
]
Beginning substream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Initial stream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.205149E+03
P = 0.000000E+00 0.000000E+00 5.205149E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(21)
E = 1.973730E+03
P = 0.000000E+00 0.000000E+00 -1.973730E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 1.294851E+03
P = 0.000000E+00 0.000000E+00 1.294851E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(93*)
E = 4.526270E+03
P = 0.000000E+00 0.000000E+00 -4.526270E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.733957E+03
P = 8.940481E+02 1.243035E+03 2.263128E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 2.427012E+03
P = 9.730507E+02 -2.008346E+03 9.539933E+02
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 2.017911E+03
P = -1.867099E+03 7.653116E+02 1.429867E+01
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 3.749803235E-05
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 3.627770E+03
P = 0.000000E+00 0.000000E+00 3.627770E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(21)
E = 8.416992E+02
P = 0.000000E+00 0.000000E+00 -8.416992E+02
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(-92*)
E = 2.872230E+03
P = 0.000000E+00 0.000000E+00 2.872230E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(93*)
E = 5.658301E+03
P = 0.000000E+00 0.000000E+00 -5.658301E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.806059E+03
P = 4.091975E+01 1.592726E+03 2.308073E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 1.663410E+03
P = -4.091975E+01 -1.592726E+03 4.779977E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.205149E+03
P = 0.000000E+00 0.000000E+00 5.205149E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 1.973730E+03
P = 0.000000E+00 0.000000E+00 -1.973730E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 1.294851E+03
P = 0.000000E+00 0.000000E+00 1.294851E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 4.526270E+03
P = 0.000000E+00 0.000000E+00 -4.526270E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.733957E+03
P = 8.940481E+02 1.243035E+03 2.263128E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 2.427012E+03
P = 9.730507E+02 -2.008346E+03 9.539933E+02
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 2.017911E+03
P = -1.867099E+03 7.653116E+02 1.429867E+01
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.205149E+03
P = 0.000000E+00 0.000000E+00 5.205149E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(1)
E = 1.973730E+03
P = 0.000000E+00 0.000000E+00 -1.973730E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 1.294851E+03
P = 0.000000E+00 0.000000E+00 1.294851E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 4.526270E+03
P = 0.000000E+00 0.000000E+00 -4.526270E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.733957E+03
P = 8.940481E+02 1.243035E+03 2.263128E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(1)
E = 2.427012E+03
P = 9.730507E+02 -2.008346E+03 9.539933E+02
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 2.017911E+03
P = -1.867099E+03 7.653116E+02 1.429867E+01
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 3.627770E+03
P = 0.000000E+00 0.000000E+00 3.627770E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(21)
E = 8.416992E+02
P = 0.000000E+00 0.000000E+00 -8.416992E+02
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 2.872230E+03
P = 0.000000E+00 0.000000E+00 2.872230E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(93*)
E = 5.658301E+03
P = 0.000000E+00 0.000000E+00 -5.658301E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.107334E+03
P = 3.070468E+01 1.195123E+03 1.732997E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 7.104315E+02
P = -6.638103E+02 9.283670E+01 2.354785E+02
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 1.651704E+03
P = 6.331056E+02 -1.287960E+03 8.175957E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.205149E+03
P = 0.000000E+00 0.000000E+00 5.205149E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(21)
E = 1.973730E+03
P = 0.000000E+00 0.000000E+00 -1.973730E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 1.294851E+03
P = 0.000000E+00 0.000000E+00 1.294851E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(93*)
E = 4.526270E+03
P = 0.000000E+00 0.000000E+00 -4.526270E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.733957E+03
P = 8.940481E+02 1.243035E+03 2.263128E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 2.427012E+03
P = 9.730507E+02 -2.008346E+03 9.539933E+02
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 2.017911E+03
P = -1.867099E+03 7.653116E+02 1.429867E+01
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 6.41048E+03
n_in* => 2
n_out* => 5
n_tot* => 7
$process_id* => "nlo_ppzj_sim_4_p1"
process_num_id* => [unknown integer]
sqme* => 2.00173E-04
sqme_ref* => 6.87798E-02
event_index* => 9
event_weight* => 6.26830E+00
event_weight_ref* => 2.15380E+03
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:2|-5.2051492E+03; 0.0000000E+00, 0.0000000E+00,-5.2051492E+03| 0.0000000E+00| 3)
4 prt(i:2|-1.9737297E+03; 0.0000000E+00, 0.0000000E+00, 1.9737297E+03| 0.0000000E+00| 4)
5 prt(o:-92| 1.2948508E+03; 0.0000000E+00, 0.0000000E+00, 1.2948508E+03| 0.0000000E+00| 5)
6 prt(o:-92| 4.5262703E+03; 0.0000000E+00, 0.0000000E+00,-4.5262703E+03| 0.0000000E+00| 6)
7 prt(o:23| 2.7339565E+03; 8.9404807E+02, 1.2430345E+03, 2.2631275E+03| 8.3152513E+03| 7)
8 prt(o:2| 2.4270115E+03; 9.7305067E+02,-2.0083461E+03, 9.5399329E+02| 0.0000000E+00| 8)
9 prt(o:2| 2.0179108E+03;-1.8670987E+03, 7.6531158E+02, 1.4298675E+01| 0.0000000E+00| 9)
========================================================================
========================================================================
Event #9
------------------------------------------------------------------------
Unweighted = F
Normalization = 'sigma'
Helicity handling = drop
Keep correlations = F
------------------------------------------------------------------------
Squared matrix el. (ref) = 6.87798E-02
Squared matrix el. (prc) = 6.90100E-05
Event weight (ref) = 2.15380E+03
Event weight (prc) = 2.16101E+00
------------------------------------------------------------------------
Selected MCI group = 1
Selected term = 1
Selected channel = 5
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
1512051135.0, 1203905778.0, 997990153.0,
1372508840.0, 174420764.0, 1915192798.0,
]
Beginning substream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Initial stream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(1)
E = 3.627770E+03
P = 0.000000E+00 0.000000E+00 3.627770E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(21)
E = 8.416992E+02
P = 0.000000E+00 0.000000E+00 -8.416992E+02
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(-92*)
E = 2.872230E+03
P = 0.000000E+00 0.000000E+00 2.872230E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(93*)
E = 5.658301E+03
P = 0.000000E+00 0.000000E+00 -5.658301E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.806059E+03
P = 4.091975E+01 1.592726E+03 2.308073E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(1)
E = 1.663410E+03
P = -4.091975E+01 -1.592726E+03 4.779977E+02
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
2293767915.0, 1571521972.0, 1787825103.0,
1998056376.0, 691167578.0, 1043540656.0,
]
Beginning substream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Initial stream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.205149E+03
P = 0.000000E+00 0.000000E+00 5.205149E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(21)
E = 1.973730E+03
P = 0.000000E+00 0.000000E+00 -1.973730E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 1.294851E+03
P = 0.000000E+00 0.000000E+00 1.294851E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(93*)
E = 4.526270E+03
P = 0.000000E+00 0.000000E+00 -4.526270E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.733957E+03
P = 8.940481E+02 1.243035E+03 2.263128E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 2.427012E+03
P = 9.730507E+02 -2.008346E+03 9.539933E+02
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 2.017911E+03
P = -1.867099E+03 7.653116E+02 1.429867E+01
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 3.749803235E-05
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 3.627770E+03
P = 0.000000E+00 0.000000E+00 3.627770E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(21)
E = 8.416992E+02
P = 0.000000E+00 0.000000E+00 -8.416992E+02
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(-92*)
E = 2.872230E+03
P = 0.000000E+00 0.000000E+00 2.872230E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(93*)
E = 5.658301E+03
P = 0.000000E+00 0.000000E+00 -5.658301E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.806059E+03
P = 4.091975E+01 1.592726E+03 2.308073E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 1.663410E+03
P = -4.091975E+01 -1.592726E+03 4.779977E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.205149E+03
P = 0.000000E+00 0.000000E+00 5.205149E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 1.973730E+03
P = 0.000000E+00 0.000000E+00 -1.973730E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 1.294851E+03
P = 0.000000E+00 0.000000E+00 1.294851E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 4.526270E+03
P = 0.000000E+00 0.000000E+00 -4.526270E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.733957E+03
P = 8.940481E+02 1.243035E+03 2.263128E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 2.427012E+03
P = 9.730507E+02 -2.008346E+03 9.539933E+02
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 2.017911E+03
P = -1.867099E+03 7.653116E+02 1.429867E+01
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.205149E+03
P = 0.000000E+00 0.000000E+00 5.205149E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(1)
E = 1.973730E+03
P = 0.000000E+00 0.000000E+00 -1.973730E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 1.294851E+03
P = 0.000000E+00 0.000000E+00 1.294851E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 4.526270E+03
P = 0.000000E+00 0.000000E+00 -4.526270E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.733957E+03
P = 8.940481E+02 1.243035E+03 2.263128E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(1)
E = 2.427012E+03
P = 9.730507E+02 -2.008346E+03 9.539933E+02
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 2.017911E+03
P = -1.867099E+03 7.653116E+02 1.429867E+01
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 3.627770E+03
P = 0.000000E+00 0.000000E+00 3.627770E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(21)
E = 8.416992E+02
P = 0.000000E+00 0.000000E+00 -8.416992E+02
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 2.872230E+03
P = 0.000000E+00 0.000000E+00 2.872230E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(93*)
E = 5.658301E+03
P = 0.000000E+00 0.000000E+00 -5.658301E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.107334E+03
P = 3.070468E+01 1.195123E+03 1.732997E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 7.104315E+02
P = -6.638103E+02 9.283670E+01 2.354785E+02
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 1.651704E+03
P = 6.331056E+02 -1.287960E+03 8.175957E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.205149E+03
P = 0.000000E+00 0.000000E+00 5.205149E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(21)
E = 1.973730E+03
P = 0.000000E+00 0.000000E+00 -1.973730E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 1.294851E+03
P = 0.000000E+00 0.000000E+00 1.294851E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(93*)
E = 4.526270E+03
P = 0.000000E+00 0.000000E+00 -4.526270E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.733957E+03
P = 8.940481E+02 1.243035E+03 2.263128E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 2.427012E+03
P = 9.730507E+02 -2.008346E+03 9.539933E+02
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 2.017911E+03
P = -1.867099E+03 7.653116E+02 1.429867E+01
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 6.41048E+03
n_in* => 2
n_out* => 5
n_tot* => 7
$process_id* => "nlo_ppzj_sim_4_p1"
process_num_id* => [unknown integer]
sqme* => 6.90100E-05
sqme_ref* => 6.87798E-02
event_index* => 9
event_weight* => 2.16101E+00
event_weight_ref* => 2.15380E+03
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:2|-5.2051492E+03; 0.0000000E+00, 0.0000000E+00,-5.2051492E+03| 0.0000000E+00| 3)
4 prt(i:1|-1.9737297E+03; 0.0000000E+00, 0.0000000E+00, 1.9737297E+03| 0.0000000E+00| 4)
5 prt(o:-92| 1.2948508E+03; 0.0000000E+00, 0.0000000E+00, 1.2948508E+03| 0.0000000E+00| 5)
6 prt(o:-92| 4.5262703E+03; 0.0000000E+00, 0.0000000E+00,-4.5262703E+03| 0.0000000E+00| 6)
7 prt(o:23| 2.7339565E+03; 8.9404807E+02, 1.2430345E+03, 2.2631275E+03| 8.3152513E+03| 7)
8 prt(o:1| 2.4270115E+03; 9.7305067E+02,-2.0083461E+03, 9.5399329E+02| 0.0000000E+00| 8)
9 prt(o:2| 2.0179108E+03;-1.8670987E+03, 7.6531158E+02, 1.4298675E+01| 0.0000000E+00| 9)
========================================================================
========================================================================
Event #9
------------------------------------------------------------------------
Unweighted = F
Normalization = 'sigma'
Helicity handling = drop
Keep correlations = F
------------------------------------------------------------------------
Squared matrix el. (ref) = 6.87798E-02
Squared matrix el. (prc) = 3.14925E-02
Event weight (ref) = 2.15380E+03
Event weight (prc) = 9.86168E+02
------------------------------------------------------------------------
Selected MCI group = 1
Selected term = 1
Selected channel = 5
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
1512051135.0, 1203905778.0, 997990153.0,
1372508840.0, 174420764.0, 1915192798.0,
]
Beginning substream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Initial stream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(1)
E = 3.627770E+03
P = 0.000000E+00 0.000000E+00 3.627770E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(21)
E = 8.416992E+02
P = 0.000000E+00 0.000000E+00 -8.416992E+02
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(-92*)
E = 2.872230E+03
P = 0.000000E+00 0.000000E+00 2.872230E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(93*)
E = 5.658301E+03
P = 0.000000E+00 0.000000E+00 -5.658301E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.806059E+03
P = 4.091975E+01 1.592726E+03 2.308073E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(1)
E = 1.663410E+03
P = -4.091975E+01 -1.592726E+03 4.779977E+02
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
2293767915.0, 1571521972.0, 1787825103.0,
1998056376.0, 691167578.0, 1043540656.0,
]
Beginning substream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Initial stream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.205149E+03
P = 0.000000E+00 0.000000E+00 5.205149E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(21)
E = 1.973730E+03
P = 0.000000E+00 0.000000E+00 -1.973730E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 1.294851E+03
P = 0.000000E+00 0.000000E+00 1.294851E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(93*)
E = 4.526270E+03
P = 0.000000E+00 0.000000E+00 -4.526270E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.733957E+03
P = 8.940481E+02 1.243035E+03 2.263128E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 2.427012E+03
P = 9.730507E+02 -2.008346E+03 9.539933E+02
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 2.017911E+03
P = -1.867099E+03 7.653116E+02 1.429867E+01
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 3.749803235E-05
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 3.627770E+03
P = 0.000000E+00 0.000000E+00 3.627770E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(21)
E = 8.416992E+02
P = 0.000000E+00 0.000000E+00 -8.416992E+02
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(-92*)
E = 2.872230E+03
P = 0.000000E+00 0.000000E+00 2.872230E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(93*)
E = 5.658301E+03
P = 0.000000E+00 0.000000E+00 -5.658301E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.806059E+03
P = 4.091975E+01 1.592726E+03 2.308073E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 1.663410E+03
P = -4.091975E+01 -1.592726E+03 4.779977E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.205149E+03
P = 0.000000E+00 0.000000E+00 5.205149E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 1.973730E+03
P = 0.000000E+00 0.000000E+00 -1.973730E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 1.294851E+03
P = 0.000000E+00 0.000000E+00 1.294851E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 4.526270E+03
P = 0.000000E+00 0.000000E+00 -4.526270E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.733957E+03
P = 8.940481E+02 1.243035E+03 2.263128E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 2.427012E+03
P = 9.730507E+02 -2.008346E+03 9.539933E+02
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 2.017911E+03
P = -1.867099E+03 7.653116E+02 1.429867E+01
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.205149E+03
P = 0.000000E+00 0.000000E+00 5.205149E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(1)
E = 1.973730E+03
P = 0.000000E+00 0.000000E+00 -1.973730E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 1.294851E+03
P = 0.000000E+00 0.000000E+00 1.294851E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 4.526270E+03
P = 0.000000E+00 0.000000E+00 -4.526270E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.733957E+03
P = 8.940481E+02 1.243035E+03 2.263128E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(1)
E = 2.427012E+03
P = 9.730507E+02 -2.008346E+03 9.539933E+02
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 2.017911E+03
P = -1.867099E+03 7.653116E+02 1.429867E+01
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 3.627770E+03
P = 0.000000E+00 0.000000E+00 3.627770E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(21)
E = 8.416992E+02
P = 0.000000E+00 0.000000E+00 -8.416992E+02
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 2.872230E+03
P = 0.000000E+00 0.000000E+00 2.872230E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(93*)
E = 5.658301E+03
P = 0.000000E+00 0.000000E+00 -5.658301E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.107334E+03
P = 3.070468E+01 1.195123E+03 1.732997E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 7.104315E+02
P = -6.638103E+02 9.283670E+01 2.354785E+02
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 1.651704E+03
P = 6.331056E+02 -1.287960E+03 8.175957E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.205149E+03
P = 0.000000E+00 0.000000E+00 5.205149E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(21)
E = 1.973730E+03
P = 0.000000E+00 0.000000E+00 -1.973730E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 1.294851E+03
P = 0.000000E+00 0.000000E+00 1.294851E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(93*)
E = 4.526270E+03
P = 0.000000E+00 0.000000E+00 -4.526270E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.733957E+03
P = 8.940481E+02 1.243035E+03 2.263128E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 2.427012E+03
P = 9.730507E+02 -2.008346E+03 9.539933E+02
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 2.017911E+03
P = -1.867099E+03 7.653116E+02 1.429867E+01
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 3.49485E+03
n_in* => 2
n_out* => 5
n_tot* => 7
$process_id* => "nlo_ppzj_sim_4_p1"
process_num_id* => [unknown integer]
sqme* => 3.14925E-02
sqme_ref* => 6.87798E-02
event_index* => 9
event_weight* => 9.86168E+02
event_weight_ref* => 2.15380E+03
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:2|-3.6277701E+03; 0.0000000E+00, 0.0000000E+00,-3.6277701E+03| 0.0000000E+00| 3)
4 prt(i:21|-8.4169922E+02; 0.0000000E+00, 0.0000000E+00, 8.4169922E+02| 0.0000000E+00| 4)
5 prt(o:-92| 2.8722299E+03; 0.0000000E+00, 0.0000000E+00, 2.8722299E+03| 0.0000000E+00| 5)
6 prt(o:93| 5.6583008E+03; 0.0000000E+00, 0.0000000E+00,-5.6583008E+03| 0.0000000E+00| 6)
7 prt(o:23| 2.1073337E+03; 3.0704678E+01, 1.1951234E+03, 1.7329967E+03| 8.3152513E+03| 7)
8 prt(o:2| 7.1043147E+02;-6.6381029E+02, 9.2836702E+01, 2.3547851E+02| 0.0000000E+00| 8)
9 prt(o:21| 1.6517041E+03; 6.3310561E+02,-1.2879601E+03, 8.1759571E+02| 0.0000000E+00| 9)
========================================================================
========================================================================
Event #9
------------------------------------------------------------------------
Unweighted = F
Normalization = 'sigma'
Helicity handling = drop
Keep correlations = F
------------------------------------------------------------------------
Squared matrix el. (ref) = 6.87798E-02
Squared matrix el. (prc) = 3.74980E-05
Event weight (ref) = 2.15380E+03
Event weight (prc) = 1.17423E+00
------------------------------------------------------------------------
Selected MCI group = 1
Selected term = 1
Selected channel = 5
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
1512051135.0, 1203905778.0, 997990153.0,
1372508840.0, 174420764.0, 1915192798.0,
]
Beginning substream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Initial stream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(1)
E = 3.627770E+03
P = 0.000000E+00 0.000000E+00 3.627770E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(21)
E = 8.416992E+02
P = 0.000000E+00 0.000000E+00 -8.416992E+02
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(-92*)
E = 2.872230E+03
P = 0.000000E+00 0.000000E+00 2.872230E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(93*)
E = 5.658301E+03
P = 0.000000E+00 0.000000E+00 -5.658301E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.806059E+03
P = 4.091975E+01 1.592726E+03 2.308073E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(1)
E = 1.663410E+03
P = -4.091975E+01 -1.592726E+03 4.779977E+02
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
2293767915.0, 1571521972.0, 1787825103.0,
1998056376.0, 691167578.0, 1043540656.0,
]
Beginning substream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Initial stream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.205149E+03
P = 0.000000E+00 0.000000E+00 5.205149E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(21)
E = 1.973730E+03
P = 0.000000E+00 0.000000E+00 -1.973730E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 1.294851E+03
P = 0.000000E+00 0.000000E+00 1.294851E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(93*)
E = 4.526270E+03
P = 0.000000E+00 0.000000E+00 -4.526270E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.733957E+03
P = 8.940481E+02 1.243035E+03 2.263128E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 2.427012E+03
P = 9.730507E+02 -2.008346E+03 9.539933E+02
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 2.017911E+03
P = -1.867099E+03 7.653116E+02 1.429867E+01
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 3.749803235E-05
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 3.627770E+03
P = 0.000000E+00 0.000000E+00 3.627770E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(21)
E = 8.416992E+02
P = 0.000000E+00 0.000000E+00 -8.416992E+02
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(-92*)
E = 2.872230E+03
P = 0.000000E+00 0.000000E+00 2.872230E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(93*)
E = 5.658301E+03
P = 0.000000E+00 0.000000E+00 -5.658301E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.806059E+03
P = 4.091975E+01 1.592726E+03 2.308073E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 1.663410E+03
P = -4.091975E+01 -1.592726E+03 4.779977E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.205149E+03
P = 0.000000E+00 0.000000E+00 5.205149E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 1.973730E+03
P = 0.000000E+00 0.000000E+00 -1.973730E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 1.294851E+03
P = 0.000000E+00 0.000000E+00 1.294851E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 4.526270E+03
P = 0.000000E+00 0.000000E+00 -4.526270E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.733957E+03
P = 8.940481E+02 1.243035E+03 2.263128E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 2.427012E+03
P = 9.730507E+02 -2.008346E+03 9.539933E+02
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 2.017911E+03
P = -1.867099E+03 7.653116E+02 1.429867E+01
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.205149E+03
P = 0.000000E+00 0.000000E+00 5.205149E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(1)
E = 1.973730E+03
P = 0.000000E+00 0.000000E+00 -1.973730E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 1.294851E+03
P = 0.000000E+00 0.000000E+00 1.294851E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 4.526270E+03
P = 0.000000E+00 0.000000E+00 -4.526270E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.733957E+03
P = 8.940481E+02 1.243035E+03 2.263128E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(1)
E = 2.427012E+03
P = 9.730507E+02 -2.008346E+03 9.539933E+02
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 2.017911E+03
P = -1.867099E+03 7.653116E+02 1.429867E+01
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 3.627770E+03
P = 0.000000E+00 0.000000E+00 3.627770E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(21)
E = 8.416992E+02
P = 0.000000E+00 0.000000E+00 -8.416992E+02
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 2.872230E+03
P = 0.000000E+00 0.000000E+00 2.872230E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(93*)
E = 5.658301E+03
P = 0.000000E+00 0.000000E+00 -5.658301E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.107334E+03
P = 3.070468E+01 1.195123E+03 1.732997E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 7.104315E+02
P = -6.638103E+02 9.283670E+01 2.354785E+02
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 1.651704E+03
P = 6.331056E+02 -1.287960E+03 8.175957E+02
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 5.205149E+03
P = 0.000000E+00 0.000000E+00 5.205149E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(21)
E = 1.973730E+03
P = 0.000000E+00 0.000000E+00 -1.973730E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 1.294851E+03
P = 0.000000E+00 0.000000E+00 1.294851E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(93*)
E = 4.526270E+03
P = 0.000000E+00 0.000000E+00 -4.526270E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 2.733957E+03
P = 8.940481E+02 1.243035E+03 2.263128E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 2.427012E+03
P = 9.730507E+02 -2.008346E+03 9.539933E+02
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 2.017911E+03
P = -1.867099E+03 7.653116E+02 1.429867E+01
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 6.41048E+03
n_in* => 2
n_out* => 5
n_tot* => 7
$process_id* => "nlo_ppzj_sim_4_p1"
process_num_id* => [unknown integer]
sqme* => 3.74980E-05
sqme_ref* => 6.87798E-02
event_index* => 9
event_weight* => 1.17423E+00
event_weight_ref* => 2.15380E+03
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:2|-5.2051492E+03; 0.0000000E+00, 0.0000000E+00,-5.2051492E+03| 0.0000000E+00| 3)
4 prt(i:21|-1.9737297E+03; 0.0000000E+00, 0.0000000E+00, 1.9737297E+03| 0.0000000E+00| 4)
5 prt(o:-92| 1.2948508E+03; 0.0000000E+00, 0.0000000E+00, 1.2948508E+03| 0.0000000E+00| 5)
6 prt(o:93| 4.5262703E+03; 0.0000000E+00, 0.0000000E+00,-4.5262703E+03| 0.0000000E+00| 6)
7 prt(o:23| 2.7339565E+03; 8.9404807E+02, 1.2430345E+03, 2.2631275E+03| 8.3152513E+03| 7)
8 prt(o:2| 2.4270115E+03; 9.7305067E+02,-2.0083461E+03, 9.5399329E+02| 0.0000000E+00| 8)
9 prt(o:21| 2.0179108E+03;-1.8670987E+03, 7.6531158E+02, 1.4298675E+01| 0.0000000E+00| 9)
========================================================================
========================================================================
Event #10
------------------------------------------------------------------------
Unweighted = F
Normalization = 'sigma'
Helicity handling = drop
Keep correlations = F
------------------------------------------------------------------------
Squared matrix el. (ref) = 3.34862E-01
Squared matrix el. (prc) = 0.00000E+00
Event weight (ref) = 2.52527E+00
Event weight (prc) = 0.00000E+00
------------------------------------------------------------------------
Selected MCI group = 1
Selected term = 1
Selected channel = 1
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
2983027650.0, 3954456348.0, 820541032.0,
1356439795.0, 1307043688.0, 2503941125.0,
]
Beginning substream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Initial stream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 1.647607E+03
P = 0.000000E+00 0.000000E+00 1.647607E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(21)
E = 2.012307E+03
P = 0.000000E+00 0.000000E+00 -2.012307E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(-92*)
E = 4.852393E+03
P = 0.000000E+00 0.000000E+00 4.852393E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(93*)
E = 4.487693E+03
P = 0.000000E+00 0.000000E+00 -4.487693E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.649380E+03
P = -8.425284E+01 -1.069289E+02 1.641221E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 2.010535E+03
P = 8.425284E+01 1.069289E+02 -2.005921E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
1036201964.0, 1083956786.0, 3279260699.0,
1254374503.0, 845919053.0, 3191810516.0,
]
Beginning substream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Initial stream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(21)
E = 3.732490E+03
P = 0.000000E+00 0.000000E+00 3.732490E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 2.327555E+03
P = 0.000000E+00 0.000000E+00 -2.327555E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(93*)
E = 2.767510E+03
P = 0.000000E+00 0.000000E+00 2.767510E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 4.172445E+03
P = 0.000000E+00 0.000000E+00 -4.172445E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.754503E+03
P = 4.174890E+02 -4.861456E+02 1.630746E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 2.117428E+03
P = 5.856190E+02 -2.720039E+02 -2.016572E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 2.188115E+03
P = -1.003108E+03 7.581495E+02 1.790762E+03
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 2.437161293E-03
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 1.647607E+03
P = 0.000000E+00 0.000000E+00 1.647607E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(21)
E = 2.012307E+03
P = 0.000000E+00 0.000000E+00 -2.012307E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(-92*)
E = 4.852393E+03
P = 0.000000E+00 0.000000E+00 4.852393E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(93*)
E = 4.487693E+03
P = 0.000000E+00 0.000000E+00 -4.487693E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.649380E+03
P = -8.425284E+01 -1.069289E+02 1.641221E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 2.010535E+03
P = 8.425284E+01 1.069289E+02 -2.005921E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 3.732490E+03
P = 0.000000E+00 0.000000E+00 3.732490E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(21)
E = 2.327555E+03
P = 0.000000E+00 0.000000E+00 -2.327555E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 2.767510E+03
P = 0.000000E+00 0.000000E+00 2.767510E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(93*)
E = 4.172445E+03
P = 0.000000E+00 0.000000E+00 -4.172445E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.754503E+03
P = 4.174890E+02 -4.861456E+02 1.630746E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 2.117428E+03
P = 5.856190E+02 -2.720039E+02 -2.016572E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 2.188115E+03
P = -1.003108E+03 7.581495E+02 1.790762E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 3.732490E+03
P = 0.000000E+00 0.000000E+00 3.732490E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 2.327555E+03
P = 0.000000E+00 0.000000E+00 -2.327555E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 2.767510E+03
P = 0.000000E+00 0.000000E+00 2.767510E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 4.172445E+03
P = 0.000000E+00 0.000000E+00 -4.172445E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.754503E+03
P = 4.174890E+02 -4.861456E+02 1.630746E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 2.117428E+03
P = 5.856190E+02 -2.720039E+02 -2.016572E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 2.188115E+03
P = -1.003108E+03 7.581495E+02 1.790762E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 1.647607E+03
P = 0.000000E+00 0.000000E+00 1.647607E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 2.012307E+03
P = 0.000000E+00 0.000000E+00 -2.012307E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 4.852393E+03
P = 0.000000E+00 0.000000E+00 4.852393E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 4.487693E+03
P = 0.000000E+00 0.000000E+00 -4.487693E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.603444E+03
P = -8.189974E+01 -1.039425E+02 1.595370E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 5.264079E+02
P = 8.523230E+01 -2.284204E+02 -4.665457E+02
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 1.530063E+03
P = -3.332554E+00 3.323628E+02 -1.493524E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(21)
E = 3.732490E+03
P = 0.000000E+00 0.000000E+00 3.732490E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 2.327555E+03
P = 0.000000E+00 0.000000E+00 -2.327555E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(93*)
E = 2.767510E+03
P = 0.000000E+00 0.000000E+00 2.767510E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 4.172445E+03
P = 0.000000E+00 0.000000E+00 -4.172445E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.754503E+03
P = 4.174890E+02 -4.861456E+02 1.630746E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 2.117428E+03
P = 5.856190E+02 -2.720039E+02 -2.016572E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 2.188115E+03
P = -1.003108E+03 7.581495E+02 1.790762E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 3.64170E+03
n_in* => 2
n_out* => 4
n_tot* => 6
$process_id* => "nlo_ppzj_sim_4_p1"
process_num_id* => [unknown integer]
sqme* => 0.00000E+00
sqme_ref* => 3.34862E-01
event_index* => 10
event_weight* => 0.00000E+00
event_weight_ref* => 2.52527E+00
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:2|-1.6476073E+03; 0.0000000E+00, 0.0000000E+00,-1.6476073E+03| 0.0000000E+00| 3)
4 prt(i:21|-2.0123073E+03; 0.0000000E+00, 0.0000000E+00, 2.0123073E+03| 0.0000000E+00| 4)
5 prt(o:-92| 4.8523927E+03; 0.0000000E+00, 0.0000000E+00, 4.8523927E+03| 0.0000000E+00| 5)
6 prt(o:93| 4.4876927E+03; 0.0000000E+00, 0.0000000E+00,-4.4876927E+03| 0.0000000E+00| 6)
7 prt(o:23| 1.6493797E+03;-8.4252843E+01,-1.0692888E+02, 1.6412208E+03| 8.3152513E+03| 7)
8 prt(o:2| 2.0105349E+03; 8.4252843E+01, 1.0692888E+02,-2.0059208E+03| 0.0000000E+00| 8)
========================================================================
========================================================================
Event #10
------------------------------------------------------------------------
Unweighted = F
Normalization = 'sigma'
Helicity handling = drop
Keep correlations = F
------------------------------------------------------------------------
Squared matrix el. (ref) = 3.34862E-01
Squared matrix el. (prc) = 3.99287E-02
Event weight (ref) = 2.52527E+00
Event weight (prc) = 3.01110E-01
------------------------------------------------------------------------
Selected MCI group = 1
Selected term = 1
Selected channel = 1
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
2983027650.0, 3954456348.0, 820541032.0,
1356439795.0, 1307043688.0, 2503941125.0,
]
Beginning substream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Initial stream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 1.647607E+03
P = 0.000000E+00 0.000000E+00 1.647607E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(21)
E = 2.012307E+03
P = 0.000000E+00 0.000000E+00 -2.012307E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(-92*)
E = 4.852393E+03
P = 0.000000E+00 0.000000E+00 4.852393E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(93*)
E = 4.487693E+03
P = 0.000000E+00 0.000000E+00 -4.487693E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.649380E+03
P = -8.425284E+01 -1.069289E+02 1.641221E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 2.010535E+03
P = 8.425284E+01 1.069289E+02 -2.005921E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
1036201964.0, 1083956786.0, 3279260699.0,
1254374503.0, 845919053.0, 3191810516.0,
]
Beginning substream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Initial stream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(21)
E = 3.732490E+03
P = 0.000000E+00 0.000000E+00 3.732490E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 2.327555E+03
P = 0.000000E+00 0.000000E+00 -2.327555E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(93*)
E = 2.767510E+03
P = 0.000000E+00 0.000000E+00 2.767510E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 4.172445E+03
P = 0.000000E+00 0.000000E+00 -4.172445E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.754503E+03
P = 4.174890E+02 -4.861456E+02 1.630746E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 2.117428E+03
P = 5.856190E+02 -2.720039E+02 -2.016572E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 2.188115E+03
P = -1.003108E+03 7.581495E+02 1.790762E+03
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 2.437161293E-03
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 1.647607E+03
P = 0.000000E+00 0.000000E+00 1.647607E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(21)
E = 2.012307E+03
P = 0.000000E+00 0.000000E+00 -2.012307E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(-92*)
E = 4.852393E+03
P = 0.000000E+00 0.000000E+00 4.852393E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(93*)
E = 4.487693E+03
P = 0.000000E+00 0.000000E+00 -4.487693E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.649380E+03
P = -8.425284E+01 -1.069289E+02 1.641221E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 2.010535E+03
P = 8.425284E+01 1.069289E+02 -2.005921E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 3.732490E+03
P = 0.000000E+00 0.000000E+00 3.732490E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(21)
E = 2.327555E+03
P = 0.000000E+00 0.000000E+00 -2.327555E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 2.767510E+03
P = 0.000000E+00 0.000000E+00 2.767510E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(93*)
E = 4.172445E+03
P = 0.000000E+00 0.000000E+00 -4.172445E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.754503E+03
P = 4.174890E+02 -4.861456E+02 1.630746E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 2.117428E+03
P = 5.856190E+02 -2.720039E+02 -2.016572E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 2.188115E+03
P = -1.003108E+03 7.581495E+02 1.790762E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 3.732490E+03
P = 0.000000E+00 0.000000E+00 3.732490E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 2.327555E+03
P = 0.000000E+00 0.000000E+00 -2.327555E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 2.767510E+03
P = 0.000000E+00 0.000000E+00 2.767510E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 4.172445E+03
P = 0.000000E+00 0.000000E+00 -4.172445E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.754503E+03
P = 4.174890E+02 -4.861456E+02 1.630746E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 2.117428E+03
P = 5.856190E+02 -2.720039E+02 -2.016572E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 2.188115E+03
P = -1.003108E+03 7.581495E+02 1.790762E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 1.647607E+03
P = 0.000000E+00 0.000000E+00 1.647607E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 2.012307E+03
P = 0.000000E+00 0.000000E+00 -2.012307E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 4.852393E+03
P = 0.000000E+00 0.000000E+00 4.852393E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 4.487693E+03
P = 0.000000E+00 0.000000E+00 -4.487693E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.603444E+03
P = -8.189974E+01 -1.039425E+02 1.595370E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 5.264079E+02
P = 8.523230E+01 -2.284204E+02 -4.665457E+02
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 1.530063E+03
P = -3.332554E+00 3.323628E+02 -1.493524E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(21)
E = 3.732490E+03
P = 0.000000E+00 0.000000E+00 3.732490E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 2.327555E+03
P = 0.000000E+00 0.000000E+00 -2.327555E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(93*)
E = 2.767510E+03
P = 0.000000E+00 0.000000E+00 2.767510E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 4.172445E+03
P = 0.000000E+00 0.000000E+00 -4.172445E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.754503E+03
P = 4.174890E+02 -4.861456E+02 1.630746E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 2.117428E+03
P = 5.856190E+02 -2.720039E+02 -2.016572E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 2.188115E+03
P = -1.003108E+03 7.581495E+02 1.790762E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 5.89494E+03
n_in* => 2
n_out* => 5
n_tot* => 7
$process_id* => "nlo_ppzj_sim_4_p1"
process_num_id* => [unknown integer]
sqme* => 3.99287E-02
sqme_ref* => 3.34862E-01
event_index* => 10
event_weight* => 3.01110E-01
event_weight_ref* => 2.52527E+00
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:2|-3.7324903E+03; 0.0000000E+00, 0.0000000E+00,-3.7324903E+03| 0.0000000E+00| 3)
4 prt(i:21|-2.3275549E+03; 0.0000000E+00, 0.0000000E+00, 2.3275549E+03| 0.0000000E+00| 4)
5 prt(o:-92| 2.7675097E+03; 0.0000000E+00, 0.0000000E+00, 2.7675097E+03| 0.0000000E+00| 5)
6 prt(o:93| 4.1724451E+03; 0.0000000E+00, 0.0000000E+00,-4.1724451E+03| 0.0000000E+00| 6)
7 prt(o:23| 1.7545031E+03; 4.1748895E+02,-4.8614557E+02, 1.6307456E+03| 8.3152513E+03| 7)
8 prt(o:21| 2.1174276E+03; 5.8561904E+02,-2.7200393E+02,-2.0165723E+03| 0.0000000E+00| 8)
9 prt(o:2| 2.1881146E+03;-1.0031080E+03, 7.5814951E+02, 1.7907621E+03| 0.0000000E+00| 9)
========================================================================
========================================================================
Event #10
------------------------------------------------------------------------
Unweighted = F
Normalization = 'sigma'
Helicity handling = drop
Keep correlations = F
------------------------------------------------------------------------
Squared matrix el. (ref) = 3.34862E-01
Squared matrix el. (prc) = 2.92497E-01
Event weight (ref) = 2.52527E+00
Event weight (prc) = 2.20578E+00
------------------------------------------------------------------------
Selected MCI group = 1
Selected term = 1
Selected channel = 1
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
2983027650.0, 3954456348.0, 820541032.0,
1356439795.0, 1307043688.0, 2503941125.0,
]
Beginning substream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Initial stream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 1.647607E+03
P = 0.000000E+00 0.000000E+00 1.647607E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(21)
E = 2.012307E+03
P = 0.000000E+00 0.000000E+00 -2.012307E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(-92*)
E = 4.852393E+03
P = 0.000000E+00 0.000000E+00 4.852393E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(93*)
E = 4.487693E+03
P = 0.000000E+00 0.000000E+00 -4.487693E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.649380E+03
P = -8.425284E+01 -1.069289E+02 1.641221E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 2.010535E+03
P = 8.425284E+01 1.069289E+02 -2.005921E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
1036201964.0, 1083956786.0, 3279260699.0,
1254374503.0, 845919053.0, 3191810516.0,
]
Beginning substream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Initial stream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(21)
E = 3.732490E+03
P = 0.000000E+00 0.000000E+00 3.732490E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 2.327555E+03
P = 0.000000E+00 0.000000E+00 -2.327555E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(93*)
E = 2.767510E+03
P = 0.000000E+00 0.000000E+00 2.767510E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 4.172445E+03
P = 0.000000E+00 0.000000E+00 -4.172445E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.754503E+03
P = 4.174890E+02 -4.861456E+02 1.630746E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 2.117428E+03
P = 5.856190E+02 -2.720039E+02 -2.016572E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 2.188115E+03
P = -1.003108E+03 7.581495E+02 1.790762E+03
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 2.437161293E-03
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 1.647607E+03
P = 0.000000E+00 0.000000E+00 1.647607E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(21)
E = 2.012307E+03
P = 0.000000E+00 0.000000E+00 -2.012307E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(-92*)
E = 4.852393E+03
P = 0.000000E+00 0.000000E+00 4.852393E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(93*)
E = 4.487693E+03
P = 0.000000E+00 0.000000E+00 -4.487693E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.649380E+03
P = -8.425284E+01 -1.069289E+02 1.641221E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 2.010535E+03
P = 8.425284E+01 1.069289E+02 -2.005921E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 3.732490E+03
P = 0.000000E+00 0.000000E+00 3.732490E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(21)
E = 2.327555E+03
P = 0.000000E+00 0.000000E+00 -2.327555E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 2.767510E+03
P = 0.000000E+00 0.000000E+00 2.767510E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(93*)
E = 4.172445E+03
P = 0.000000E+00 0.000000E+00 -4.172445E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.754503E+03
P = 4.174890E+02 -4.861456E+02 1.630746E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 2.117428E+03
P = 5.856190E+02 -2.720039E+02 -2.016572E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 2.188115E+03
P = -1.003108E+03 7.581495E+02 1.790762E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 3.732490E+03
P = 0.000000E+00 0.000000E+00 3.732490E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 2.327555E+03
P = 0.000000E+00 0.000000E+00 -2.327555E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 2.767510E+03
P = 0.000000E+00 0.000000E+00 2.767510E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 4.172445E+03
P = 0.000000E+00 0.000000E+00 -4.172445E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.754503E+03
P = 4.174890E+02 -4.861456E+02 1.630746E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 2.117428E+03
P = 5.856190E+02 -2.720039E+02 -2.016572E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 2.188115E+03
P = -1.003108E+03 7.581495E+02 1.790762E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 1.647607E+03
P = 0.000000E+00 0.000000E+00 1.647607E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 2.012307E+03
P = 0.000000E+00 0.000000E+00 -2.012307E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 4.852393E+03
P = 0.000000E+00 0.000000E+00 4.852393E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 4.487693E+03
P = 0.000000E+00 0.000000E+00 -4.487693E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.603444E+03
P = -8.189974E+01 -1.039425E+02 1.595370E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 5.264079E+02
P = 8.523230E+01 -2.284204E+02 -4.665457E+02
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 1.530063E+03
P = -3.332554E+00 3.323628E+02 -1.493524E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(21)
E = 3.732490E+03
P = 0.000000E+00 0.000000E+00 3.732490E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 2.327555E+03
P = 0.000000E+00 0.000000E+00 -2.327555E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(93*)
E = 2.767510E+03
P = 0.000000E+00 0.000000E+00 2.767510E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 4.172445E+03
P = 0.000000E+00 0.000000E+00 -4.172445E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.754503E+03
P = 4.174890E+02 -4.861456E+02 1.630746E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 2.117428E+03
P = 5.856190E+02 -2.720039E+02 -2.016572E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 2.188115E+03
P = -1.003108E+03 7.581495E+02 1.790762E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 5.89494E+03
n_in* => 2
n_out* => 5
n_tot* => 7
$process_id* => "nlo_ppzj_sim_4_p1"
process_num_id* => [unknown integer]
sqme* => 2.92497E-01
sqme_ref* => 3.34862E-01
event_index* => 10
event_weight* => 2.20578E+00
event_weight_ref* => 2.52527E+00
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:2|-3.7324903E+03; 0.0000000E+00, 0.0000000E+00,-3.7324903E+03| 0.0000000E+00| 3)
4 prt(i:2|-2.3275549E+03; 0.0000000E+00, 0.0000000E+00, 2.3275549E+03| 0.0000000E+00| 4)
5 prt(o:-92| 2.7675097E+03; 0.0000000E+00, 0.0000000E+00, 2.7675097E+03| 0.0000000E+00| 5)
6 prt(o:-92| 4.1724451E+03; 0.0000000E+00, 0.0000000E+00,-4.1724451E+03| 0.0000000E+00| 6)
7 prt(o:23| 1.7545031E+03; 4.1748895E+02,-4.8614557E+02, 1.6307456E+03| 8.3152513E+03| 7)
8 prt(o:2| 2.1174276E+03; 5.8561904E+02,-2.7200393E+02,-2.0165723E+03| 0.0000000E+00| 8)
9 prt(o:2| 2.1881146E+03;-1.0031080E+03, 7.5814951E+02, 1.7907621E+03| 0.0000000E+00| 9)
========================================================================
========================================================================
Event #10
------------------------------------------------------------------------
Unweighted = F
Normalization = 'sigma'
Helicity handling = drop
Keep correlations = F
------------------------------------------------------------------------
Squared matrix el. (ref) = 3.34862E-01
Squared matrix el. (prc) = 2.07912E+01
Event weight (ref) = 2.52527E+00
Event weight (prc) = 0.00000E+00
------------------------------------------------------------------------
Selected MCI group = 1
Selected term = 1
Selected channel = 1
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
2983027650.0, 3954456348.0, 820541032.0,
1356439795.0, 1307043688.0, 2503941125.0,
]
Beginning substream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Initial stream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 1.647607E+03
P = 0.000000E+00 0.000000E+00 1.647607E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(21)
E = 2.012307E+03
P = 0.000000E+00 0.000000E+00 -2.012307E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(-92*)
E = 4.852393E+03
P = 0.000000E+00 0.000000E+00 4.852393E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(93*)
E = 4.487693E+03
P = 0.000000E+00 0.000000E+00 -4.487693E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.649380E+03
P = -8.425284E+01 -1.069289E+02 1.641221E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 2.010535E+03
P = 8.425284E+01 1.069289E+02 -2.005921E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
1036201964.0, 1083956786.0, 3279260699.0,
1254374503.0, 845919053.0, 3191810516.0,
]
Beginning substream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Initial stream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(21)
E = 3.732490E+03
P = 0.000000E+00 0.000000E+00 3.732490E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 2.327555E+03
P = 0.000000E+00 0.000000E+00 -2.327555E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(93*)
E = 2.767510E+03
P = 0.000000E+00 0.000000E+00 2.767510E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 4.172445E+03
P = 0.000000E+00 0.000000E+00 -4.172445E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.754503E+03
P = 4.174890E+02 -4.861456E+02 1.630746E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 2.117428E+03
P = 5.856190E+02 -2.720039E+02 -2.016572E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 2.188115E+03
P = -1.003108E+03 7.581495E+02 1.790762E+03
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 2.437161293E-03
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 1.647607E+03
P = 0.000000E+00 0.000000E+00 1.647607E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(21)
E = 2.012307E+03
P = 0.000000E+00 0.000000E+00 -2.012307E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(-92*)
E = 4.852393E+03
P = 0.000000E+00 0.000000E+00 4.852393E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(93*)
E = 4.487693E+03
P = 0.000000E+00 0.000000E+00 -4.487693E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.649380E+03
P = -8.425284E+01 -1.069289E+02 1.641221E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 2.010535E+03
P = 8.425284E+01 1.069289E+02 -2.005921E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 3.732490E+03
P = 0.000000E+00 0.000000E+00 3.732490E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(21)
E = 2.327555E+03
P = 0.000000E+00 0.000000E+00 -2.327555E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 2.767510E+03
P = 0.000000E+00 0.000000E+00 2.767510E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(93*)
E = 4.172445E+03
P = 0.000000E+00 0.000000E+00 -4.172445E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.754503E+03
P = 4.174890E+02 -4.861456E+02 1.630746E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 2.117428E+03
P = 5.856190E+02 -2.720039E+02 -2.016572E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 2.188115E+03
P = -1.003108E+03 7.581495E+02 1.790762E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 3.732490E+03
P = 0.000000E+00 0.000000E+00 3.732490E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 2.327555E+03
P = 0.000000E+00 0.000000E+00 -2.327555E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 2.767510E+03
P = 0.000000E+00 0.000000E+00 2.767510E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 4.172445E+03
P = 0.000000E+00 0.000000E+00 -4.172445E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.754503E+03
P = 4.174890E+02 -4.861456E+02 1.630746E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 2.117428E+03
P = 5.856190E+02 -2.720039E+02 -2.016572E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 2.188115E+03
P = -1.003108E+03 7.581495E+02 1.790762E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 1.647607E+03
P = 0.000000E+00 0.000000E+00 1.647607E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 2.012307E+03
P = 0.000000E+00 0.000000E+00 -2.012307E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 4.852393E+03
P = 0.000000E+00 0.000000E+00 4.852393E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 4.487693E+03
P = 0.000000E+00 0.000000E+00 -4.487693E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.603444E+03
P = -8.189974E+01 -1.039425E+02 1.595370E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 5.264079E+02
P = 8.523230E+01 -2.284204E+02 -4.665457E+02
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 1.530063E+03
P = -3.332554E+00 3.323628E+02 -1.493524E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(21)
E = 3.732490E+03
P = 0.000000E+00 0.000000E+00 3.732490E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 2.327555E+03
P = 0.000000E+00 0.000000E+00 -2.327555E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(93*)
E = 2.767510E+03
P = 0.000000E+00 0.000000E+00 2.767510E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 4.172445E+03
P = 0.000000E+00 0.000000E+00 -4.172445E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.754503E+03
P = 4.174890E+02 -4.861456E+02 1.630746E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 2.117428E+03
P = 5.856190E+02 -2.720039E+02 -2.016572E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 2.188115E+03
P = -1.003108E+03 7.581495E+02 1.790762E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 3.64170E+03
n_in* => 2
n_out* => 5
n_tot* => 7
$process_id* => "nlo_ppzj_sim_4_p1"
process_num_id* => [unknown integer]
sqme* => 2.07912E+01
sqme_ref* => 3.34862E-01
event_index* => 10
event_weight* => 0.00000E+00
event_weight_ref* => 2.52527E+00
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:-3|-1.6476073E+03; 0.0000000E+00, 0.0000000E+00,-1.6476073E+03| 0.0000000E+00| 3)
4 prt(i:-3|-2.0123073E+03; 0.0000000E+00, 0.0000000E+00, 2.0123073E+03| 0.0000000E+00| 4)
5 prt(o:92| 4.8523927E+03; 0.0000000E+00, 0.0000000E+00, 4.8523927E+03| 0.0000000E+00| 5)
6 prt(o:92| 4.4876927E+03; 0.0000000E+00, 0.0000000E+00,-4.4876927E+03| 0.0000000E+00| 6)
7 prt(o:23| 1.6034441E+03;-8.1899744E+01,-1.0394246E+02, 1.5953702E+03| 8.3152513E+03| 7)
8 prt(o:-3| 5.2640787E+02; 8.5232298E+01,-2.2842035E+02,-4.6654565E+02| 0.0000000E+00| 8)
9 prt(o:-3| 1.5300626E+03;-3.3325538E+00, 3.3236282E+02,-1.4935245E+03| 0.0000000E+00| 9)
========================================================================
========================================================================
Event #10
------------------------------------------------------------------------
Unweighted = F
Normalization = 'sigma'
Helicity handling = drop
Keep correlations = F
------------------------------------------------------------------------
Squared matrix el. (ref) = 3.34862E-01
Squared matrix el. (prc) = 2.43716E-03
Event weight (ref) = 2.52527E+00
Event weight (prc) = 1.83791E-02
------------------------------------------------------------------------
Selected MCI group = 1
Selected term = 1
Selected channel = 1
------------------------------------------------------------------------
Passed selection = T
Reweighting factor = 1.00000E+00
Analysis flag = T
========================================================================
Event transform: trivial (hard process)
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
2983027650.0, 3954456348.0, 820541032.0,
1356439795.0, 1307043688.0, 2503941125.0,
]
Beginning substream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Initial stream = [
1610596087.0, 4212350275.0, 4138421822.0,
4034943078.0, 4116981983.0, 1719049444.0,
]
Number of tries = 1
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 1.647607E+03
P = 0.000000E+00 0.000000E+00 1.647607E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(21)
E = 2.012307E+03
P = 0.000000E+00 0.000000E+00 -2.012307E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(-92*)
E = 4.852393E+03
P = 0.000000E+00 0.000000E+00 4.852393E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(93*)
E = 4.487693E+03
P = 0.000000E+00 0.000000E+00 -4.487693E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.649380E+03
P = -8.425284E+01 -1.069289E+02 1.641221E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 2.010535E+03
P = 8.425284E+01 1.069289E+02 -2.005921E+03
T = 0.000000000E+00
Parents: 3 4
========================================================================
========================================================================
Event transform: NLO
------------------------------------------------------------------------
Associated process: 'nlo_ppzj_sim_4_p1'
RNG Stream generator
Current position = [
1036201964.0, 1083956786.0, 3279260699.0,
1254374503.0, 845919053.0, 3191810516.0,
]
Beginning substream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Initial stream = [
2511166652.0, 982063369.0, 168404907.0,
1176180105.0, 1865281356.0, 236745015.0,
]
Number of tries = 0
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(21)
E = 3.732490E+03
P = 0.000000E+00 0.000000E+00 3.732490E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 2.327555E+03
P = 0.000000E+00 0.000000E+00 -2.327555E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(93*)
E = 2.767510E+03
P = 0.000000E+00 0.000000E+00 2.767510E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 4.172445E+03
P = 0.000000E+00 0.000000E+00 -4.172445E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.754503E+03
P = 4.174890E+02 -4.861456E+02 1.630746E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 2.117428E+03
P = 5.856190E+02 -2.720039E+02 -2.016572E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 2.188115E+03
P = -1.003108E+03 7.581495E+02 1.790762E+03
T = 0.000000000E+00
Parents: 3 4
sqme_rad = 2.437161293E-03
i_evaluation = 0
------------------------------------------------------------------------
Radiated particle sets:
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 1.647607E+03
P = 0.000000E+00 0.000000E+00 1.647607E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8
Particle 4 [i] f(21)
E = 2.012307E+03
P = 0.000000E+00 0.000000E+00 -2.012307E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8
Particle 5 [x] f(-92*)
E = 4.852393E+03
P = 0.000000E+00 0.000000E+00 4.852393E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(93*)
E = 4.487693E+03
P = 0.000000E+00 0.000000E+00 -4.487693E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.649380E+03
P = -8.425284E+01 -1.069289E+02 1.641221E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 2.010535E+03
P = 8.425284E+01 1.069289E+02 -2.005921E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 3.732490E+03
P = 0.000000E+00 0.000000E+00 3.732490E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(21)
E = 2.327555E+03
P = 0.000000E+00 0.000000E+00 -2.327555E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 2.767510E+03
P = 0.000000E+00 0.000000E+00 2.767510E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(93*)
E = 4.172445E+03
P = 0.000000E+00 0.000000E+00 -4.172445E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.754503E+03
P = 4.174890E+02 -4.861456E+02 1.630746E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(21)
E = 2.117428E+03
P = 5.856190E+02 -2.720039E+02 -2.016572E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 2.188115E+03
P = -1.003108E+03 7.581495E+02 1.790762E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(2)
E = 3.732490E+03
P = 0.000000E+00 0.000000E+00 3.732490E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 2.327555E+03
P = 0.000000E+00 0.000000E+00 -2.327555E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(-92*)
E = 2.767510E+03
P = 0.000000E+00 0.000000E+00 2.767510E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 4.172445E+03
P = 0.000000E+00 0.000000E+00 -4.172445E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.754503E+03
P = 4.174890E+02 -4.861456E+02 1.630746E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 2.117428E+03
P = 5.856190E+02 -2.720039E+02 -2.016572E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(2)
E = 2.188115E+03
P = -1.003108E+03 7.581495E+02 1.790762E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(-3)
E = 1.647607E+03
P = 0.000000E+00 0.000000E+00 1.647607E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(-3)
E = 2.012307E+03
P = 0.000000E+00 0.000000E+00 -2.012307E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(92*)
E = 4.852393E+03
P = 0.000000E+00 0.000000E+00 4.852393E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(92*)
E = 4.487693E+03
P = 0.000000E+00 0.000000E+00 -4.487693E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.603444E+03
P = -8.189974E+01 -1.039425E+02 1.595370E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(-3)
E = 5.264079E+02
P = 8.523230E+01 -2.284204E+02 -4.665457E+02
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(-3)
E = 1.530063E+03
P = -3.332554E+00 3.323628E+02 -1.493524E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
Particle set:
------------------------------------------------------------------------
Particle 1 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 6.500000E+03
T = 0.000000000E+00
Children: 3 5
Particle 2 [b] f(2212)
E = 6.500000E+03
P = 0.000000E+00 0.000000E+00 -6.500000E+03
T = 0.000000000E+00
Children: 4 6
Particle 3 [i] f(21)
E = 3.732490E+03
P = 0.000000E+00 0.000000E+00 3.732490E+03
T = 0.000000000E+00
Parents: 1
Children: 7 8 9
Particle 4 [i] f(2)
E = 2.327555E+03
P = 0.000000E+00 0.000000E+00 -2.327555E+03
T = 0.000000000E+00
Parents: 2
Children: 7 8 9
Particle 5 [x] f(93*)
E = 2.767510E+03
P = 0.000000E+00 0.000000E+00 2.767510E+03
T = 0.000000000E+00
Parents: 1
Particle 6 [x] f(-92*)
E = 4.172445E+03
P = 0.000000E+00 0.000000E+00 -4.172445E+03
T = 0.000000000E+00
Parents: 2
Particle 7 [o] f(23)
E = 1.754503E+03
P = 4.174890E+02 -4.861456E+02 1.630746E+03
T = 8.315251344E+03
Parents: 3 4
Particle 8 [o] f(2)
E = 2.117428E+03
P = 5.856190E+02 -2.720039E+02 -2.016572E+03
T = 0.000000000E+00
Parents: 3 4
Particle 9 [o] f(21)
E = 2.188115E+03
P = -1.003108E+03 7.581495E+02 1.790762E+03
T = 0.000000000E+00
Parents: 3 4
------------------------------------------------------------------------
========================================================================
Local variables:
------------------------------------------------------------------------
sqrts* = 1.30000E+04
sqrts_hat* => 5.89494E+03
n_in* => 2
n_out* => 5
n_tot* => 7
$process_id* => "nlo_ppzj_sim_4_p1"
process_num_id* => [unknown integer]
sqme* => 2.43716E-03
sqme_ref* => 3.34862E-01
event_index* => 10
event_weight* => 1.83791E-02
event_weight_ref* => 2.52527E+00
event_excess* => 0.00000E+00
------------------------------------------------------------------------
subevent:
1 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00,-6.5000000E+03| 0.0000000E+00| 1)
2 prt(b:2212|-6.5000000E+03; 0.0000000E+00, 0.0000000E+00, 6.5000000E+03| 0.0000000E+00| 2)
3 prt(i:21|-3.7324903E+03; 0.0000000E+00, 0.0000000E+00,-3.7324903E+03| 0.0000000E+00| 3)
4 prt(i:2|-2.3275549E+03; 0.0000000E+00, 0.0000000E+00, 2.3275549E+03| 0.0000000E+00| 4)
5 prt(o:93| 2.7675097E+03; 0.0000000E+00, 0.0000000E+00, 2.7675097E+03| 0.0000000E+00| 5)
6 prt(o:-92| 4.1724451E+03; 0.0000000E+00, 0.0000000E+00,-4.1724451E+03| 0.0000000E+00| 6)
7 prt(o:23| 1.7545031E+03; 4.1748895E+02,-4.8614557E+02, 1.6307456E+03| 8.3152513E+03| 7)
8 prt(o:2| 2.1174276E+03; 5.8561904E+02,-2.7200393E+02,-2.0165723E+03| 0.0000000E+00| 8)
9 prt(o:21| 2.1881146E+03;-1.0031080E+03, 7.5814951E+02, 1.7907621E+03| 0.0000000E+00| 9)
========================================================================
Index: trunk/share/tests/ext_tests_nlo/ref-output/nlo_eettww.ref
===================================================================
--- trunk/share/tests/ext_tests_nlo/ref-output/nlo_eettww.ref (revision 8482)
+++ trunk/share/tests/ext_tests_nlo/ref-output/nlo_eettww.ref (revision 8483)
@@ -1,164 +1,166 @@
?openmp_logging = false
?vis_history = false
?integration_timer = false
openmp_num_threads = 1
?debug_decay = false
?debug_process = false
?debug_verbose = false
?write_raw = false
| Switching to model 'SM', scheme 'GF_MW_MZ'
$blha_ew_scheme = "alpha_qed"
SM.mZ => 9.118800000000E+01
SM.mW => 8.041900200000E+01
SM.mH => 1.250000000000E+02
SM.GF => 1.166390000000E-05
SM.wZ => 0.000000000000E+00
SM.wtop => 0.000000000000E+00
SM.wW => 0.000000000000E+00
SM.wH => 0.000000000000E+00
SM.ms => 0.000000000000E+00
SM.mc => 0.000000000000E+00
SM.mb => 0.000000000000E+00
SM.mtop => 1.732000000000E+02
SM.me => 0.000000000000E+00
SM.mmu => 0.000000000000E+00
SM.mtau => 1.777000000000E+00
SM.alphas => 1.180000000000E-01
?alphas_is_fixed = false
?alphas_from_mz = true
?alphas_from_lambda_qcd = false
alphas_nf = 5
alphas_order = 2
[user variable] jet = PDG(2, -2, 1, -1, 3, -3, 4, -4, 5, -5, 21)
$exclude_gauge_splittings = "t"
$method = "openloops"
seed = 8131
sqrts = 1.000000000000E+03
jet_algorithm = 2
jet_r = 5.000000000000E-01
-?use_vamp_equivalences = false
$integration_method = "vamp2"
$rng_method = "rng_stream"
| End of included 'nlo_settings.sin'
alpha_power = 4
alphas_power = 0
| Process library 'nlo_eettww_lib': recorded process 'nlo_eettww_p1'
| Integrate: current process library needs compilation
| Process library 'nlo_eettww_lib': compiling ...
| Process library 'nlo_eettww_lib': writing makefile
| Process library 'nlo_eettww_lib': removing old files
| Process library 'nlo_eettww_lib': writing driver
| Process library 'nlo_eettww_lib': creating source code
| Process library 'nlo_eettww_lib': compiling sources
| Process library 'nlo_eettww_lib': linking
| Process library 'nlo_eettww_lib': loading
| Process library 'nlo_eettww_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 8131
| Initializing integration for process nlo_eettww_p1:
| Beam structure: [any particles]
| Beam data (collision):
| e- (mass = 0.0000000E+00 GeV)
| e+ (mass = 0.0000000E+00 GeV)
| sqrts = 1.000000000000E+03 GeV
| Phase space: generating configuration ...
| Phase space: ... success.
| Phase space: writing configuration file 'nlo_eettww_p1.i1.phs'
| Phase space: generating configuration ...
| Phase space: ... success.
| Phase space: writing configuration file 'nlo_eettww_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: [...]
| 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]: 'nlo_eettww_p1'
| Library name = 'nlo_eettww_lib'
| Process index = 1
| Process components:
| 1: 'nlo_eettww_p1_i1': e-, e+ => t, tbar, W+, W- [openloops]
| 2: 'nlo_eettww_p1_i2': e-, e+ => t, tbar, W+, W-, gl [openloops], [real]
| 3: 'nlo_eettww_p1_i3': e-, e+ => t, tbar, W+, W- [openloops], [virtual]
| 4: 'nlo_eettww_p1_i4': e-, e+ => t, tbar, W+, W- [inactive], [subtraction]
| ------------------------------------------------------------------------
| Phase space: 8 channels, 8 dimensions
| Phase space: found 8 channels, collected in 3 groves.
-| Phase space: no equivalences between channels used.
+| Phase space: Using 8 equivalences between channels.
| Phase space: wood
| Phase space: 8 channels, 11 dimensions
| Phase space: found 8 channels, collected in 3 groves.
-| Phase space: no equivalences between channels used.
+| Phase space: Using 8 equivalences between channels.
| Phase space: wood
| Phase space: 8 channels, 8 dimensions
| Phase space: found 8 channels, collected in 3 groves.
-| Phase space: no equivalences between channels used.
+| Phase space: Using 8 equivalences between channels.
| Phase space: wood
Warning: No cuts have been defined.
| Using user-defined general scale.
| Starting integration for process 'nlo_eettww_p1' part 'born'
| Integrate: iterations = 1:100:"gw"
| Integrator: 3 chains, 8 channels, 8 dimensions
+| Integrator: Using VAMP2 channel equivalences
| 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 'nlo_eettww_p1.m1.vg2'.
| VAMP2: set chain: use chained weights.
1 100 1.6643469E-01 5.55E-02 33.34 3.33* 10.69
|-----------------------------------------------------------------------------|
1 100 1.6643469E-01 5.55E-02 33.34 3.33 10.69
|=============================================================================|
| Starting integration for process 'nlo_eettww_p1' part 'real'
| Integrate: iterations = 1:100:"gw"
| Integrator: 3 chains, 8 channels, 11 dimensions
+| Integrator: Using VAMP2 channel equivalences
| 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 'nlo_eettww_p1.m2.vg2'.
| VAMP2: set chain: use chained weights.
1 102 -3.0683483E-02 1.20E-02 39.14 3.95* 10.91
|-----------------------------------------------------------------------------|
1 102 -3.0683483E-02 1.20E-02 39.14 3.95 10.91
|=============================================================================|
| Starting integration for process 'nlo_eettww_p1' part 'virtual'
| Integrate: iterations = 1:100:"gw"
| Integrator: 3 chains, 8 channels, 8 dimensions
+| Integrator: Using VAMP2 channel equivalences
| 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 'nlo_eettww_p1.m3.vg2'.
| VAMP2: set chain: use chained weights.
1 100 8.9943033E-02 2.32E-02 25.84 2.58* 14.23
|-----------------------------------------------------------------------------|
1 100 8.9943033E-02 2.32E-02 25.84 2.58 14.23
|=============================================================================|
| Integrate: sum of all components
|=============================================================================|
| It Calls Integral[fb] Error[fb] Err[%] Acc Eff[%] Chi2 N[It] |
|=============================================================================|
1 0 2.2569424E-01 6.13E-02 27.18 0.00* 10.31
| NLO Correction: [O(alpha_s+1)/O(alpha_s)]
| ( 35.6053 +- 19.69732 ) %
|=============================================================================|
| There were no errors and 1 warning(s).
| WHIZARD run finished.
|=============================================================================|
Index: trunk/share/tests/ext_tests_nlo/ref-output/nlo_eettzjj.ref
===================================================================
--- trunk/share/tests/ext_tests_nlo/ref-output/nlo_eettzjj.ref (revision 8482)
+++ trunk/share/tests/ext_tests_nlo/ref-output/nlo_eettzjj.ref (revision 8483)
@@ -1,166 +1,168 @@
?openmp_logging = false
?vis_history = false
?integration_timer = false
openmp_num_threads = 1
?debug_decay = false
?debug_process = false
?debug_verbose = false
?write_raw = false
| Switching to model 'SM', scheme 'GF_MW_MZ'
$blha_ew_scheme = "alpha_qed"
SM.mZ => 9.118800000000E+01
SM.mW => 8.041900200000E+01
SM.mH => 1.250000000000E+02
SM.GF => 1.166390000000E-05
SM.wZ => 0.000000000000E+00
SM.wtop => 0.000000000000E+00
SM.wW => 0.000000000000E+00
SM.wH => 0.000000000000E+00
SM.ms => 0.000000000000E+00
SM.mc => 0.000000000000E+00
SM.mb => 0.000000000000E+00
SM.mtop => 1.732000000000E+02
SM.me => 0.000000000000E+00
SM.mmu => 0.000000000000E+00
SM.mtau => 1.777000000000E+00
SM.alphas => 1.180000000000E-01
?alphas_is_fixed = false
?alphas_from_mz = true
?alphas_from_lambda_qcd = false
alphas_nf = 5
alphas_order = 2
[user variable] jet = PDG(2, -2, 1, -1, 3, -3, 4, -4, 5, -5, 21)
$exclude_gauge_splittings = "t"
$method = "openloops"
seed = 8131
sqrts = 1.000000000000E+03
jet_algorithm = 2
jet_r = 5.000000000000E-01
-?use_vamp_equivalences = false
$integration_method = "vamp2"
$rng_method = "rng_stream"
| End of included 'nlo_settings.sin'
alpha_power = 3
alphas_power = 2
| Process library 'nlo_eettzjj_lib': recorded process 'nlo_eettzjj_p1'
| Integrate: current process library needs compilation
| Process library 'nlo_eettzjj_lib': compiling ...
| Process library 'nlo_eettzjj_lib': writing makefile
| Process library 'nlo_eettzjj_lib': removing old files
| Process library 'nlo_eettzjj_lib': writing driver
| Process library 'nlo_eettzjj_lib': creating source code
| Process library 'nlo_eettzjj_lib': compiling sources
| Process library 'nlo_eettzjj_lib': linking
| Process library 'nlo_eettzjj_lib': loading
| Process library 'nlo_eettzjj_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 8131
| Initializing integration for process nlo_eettzjj_p1:
| Beam structure: [any particles]
| Beam data (collision):
| e- (mass = 0.0000000E+00 GeV)
| e+ (mass = 0.0000000E+00 GeV)
| sqrts = 1.000000000000E+03 GeV
| Phase space: generating configuration ...
Warning: Intermediate decay of zero-width particle Z may be possible.
Warning: Intermediate decay of zero-width particle H may be possible.
| Phase space: ... success.
| Phase space: writing configuration file 'nlo_eettzjj_p1.i1.phs'
| Phase space: generating configuration ...
| Phase space: ... success.
| Phase space: writing configuration file 'nlo_eettzjj_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: [...]
| 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]: 'nlo_eettzjj_p1'
| Library name = 'nlo_eettzjj_lib'
| Process index = 1
| Process components:
| 1: 'nlo_eettzjj_p1_i1': e-, e+ => t, tbar, Z, u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl, u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl [openloops]
| 2: 'nlo_eettzjj_p1_i2': e-, e+ => t, tbar, Z, d:dbar:u:ubar:s:sbar:c:cbar:b:bbar:gl, d:dbar:u:ubar:s:sbar:c:cbar:b:bbar:gl, d:dbar:u:ubar:s:sbar:c:cbar:b:bbar:gl [openloops], [real]
| 3: 'nlo_eettzjj_p1_i3': e-, e+ => t, tbar, Z, u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl, u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl [openloops], [virtual]
| 4: 'nlo_eettzjj_p1_i4': e-, e+ => t, tbar, Z, u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl, u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl [inactive], [subtraction]
| ------------------------------------------------------------------------
| Phase space: 94 channels, 11 dimensions
| Phase space: found 94 channels, collected in 7 groves.
-| Phase space: no equivalences between channels used.
+| Phase space: Using 146 equivalences between channels.
| Phase space: wood
| Phase space: 94 channels, 14 dimensions
| Phase space: found 94 channels, collected in 7 groves.
-| Phase space: no equivalences between channels used.
+| Phase space: Using 146 equivalences between channels.
| Phase space: wood
| Phase space: 94 channels, 11 dimensions
| Phase space: found 94 channels, collected in 7 groves.
-| Phase space: no equivalences between channels used.
+| Phase space: Using 146 equivalences between channels.
| Phase space: wood
| Applying user-defined cuts.
| Using user-defined general scale.
| Starting integration for process 'nlo_eettzjj_p1' part 'born'
| Integrate: iterations = 1:940:"gw"
| Integrator: 7 chains, 94 channels, 11 dimensions
+| Integrator: Using VAMP2 channel equivalences
| Integrator: 940 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 'nlo_eettzjj_p1.m1.vg2'.
| VAMP2: set chain: use chained weights.
1 970 7.0600481E-02 2.23E-02 31.55 9.82* 11.13
|-----------------------------------------------------------------------------|
1 970 7.0600481E-02 2.23E-02 31.55 9.82 11.13
|=============================================================================|
| Starting integration for process 'nlo_eettzjj_p1' part 'real'
| Integrate: iterations = 1:940:"gw"
| Integrator: 7 chains, 94 channels, 14 dimensions
+| Integrator: Using VAMP2 channel equivalences
| Integrator: 940 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 'nlo_eettzjj_p1.m2.vg2'.
| VAMP2: set chain: use chained weights.
1 970 -2.6270605E-02 4.96E-02 188.73 58.78* 10.36
|-----------------------------------------------------------------------------|
1 970 -2.6270605E-02 4.96E-02 188.73 58.78 10.36
|=============================================================================|
| Starting integration for process 'nlo_eettzjj_p1' part 'virtual'
| Integrate: iterations = 1:940:"gw"
| Integrator: 7 chains, 94 channels, 11 dimensions
+| Integrator: Using VAMP2 channel equivalences
| Integrator: 940 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 'nlo_eettzjj_p1.m3.vg2'.
| VAMP2: set chain: use chained weights.
1 980 6.3218338E-03 2.91E-03 46.03 14.41* 10.99
|-----------------------------------------------------------------------------|
1 980 6.3218338E-03 2.91E-03 46.03 14.41 10.99
|=============================================================================|
| Integrate: sum of all components
|=============================================================================|
| It Calls Integral[fb] Error[fb] Err[%] Acc Eff[%] Chi2 N[It] |
|=============================================================================|
1 0 5.0651710E-02 5.44E-02 107.46 0.00* 7.32
| NLO Correction: [O(alpha_s+1)/O(alpha_s)]
| (-28.2559 +- 70.91089 ) %
|=============================================================================|
| There were no errors and 2 warning(s).
| WHIZARD run finished.
|=============================================================================|
Index: trunk/share/tests/ext_tests_nlo/ref-output/nlo_eetthh.ref
===================================================================
--- trunk/share/tests/ext_tests_nlo/ref-output/nlo_eetthh.ref (revision 8482)
+++ trunk/share/tests/ext_tests_nlo/ref-output/nlo_eetthh.ref (revision 8483)
@@ -1,166 +1,168 @@
?openmp_logging = false
?vis_history = false
?integration_timer = false
openmp_num_threads = 1
?debug_decay = false
?debug_process = false
?debug_verbose = false
?write_raw = false
| Switching to model 'SM', scheme 'GF_MW_MZ'
$blha_ew_scheme = "alpha_qed"
SM.mZ => 9.118800000000E+01
SM.mW => 8.041900200000E+01
SM.mH => 1.250000000000E+02
SM.GF => 1.166390000000E-05
SM.wZ => 0.000000000000E+00
SM.wtop => 0.000000000000E+00
SM.wW => 0.000000000000E+00
SM.wH => 0.000000000000E+00
SM.ms => 0.000000000000E+00
SM.mc => 0.000000000000E+00
SM.mb => 0.000000000000E+00
SM.mtop => 1.732000000000E+02
SM.me => 0.000000000000E+00
SM.mmu => 0.000000000000E+00
SM.mtau => 1.777000000000E+00
SM.alphas => 1.180000000000E-01
?alphas_is_fixed = false
?alphas_from_mz = true
?alphas_from_lambda_qcd = false
alphas_nf = 5
alphas_order = 2
[user variable] jet = PDG(2, -2, 1, -1, 3, -3, 4, -4, 5, -5, 21)
$exclude_gauge_splittings = "t"
$method = "openloops"
seed = 8131
sqrts = 1.000000000000E+03
jet_algorithm = 2
jet_r = 5.000000000000E-01
-?use_vamp_equivalences = false
$integration_method = "vamp2"
$rng_method = "rng_stream"
| End of included 'nlo_settings.sin'
alpha_power = 4
alphas_power = 0
| Process library 'nlo_eetthh_lib': recorded process 'nlo_eetthh_p1'
| Integrate: current process library needs compilation
| Process library 'nlo_eetthh_lib': compiling ...
| Process library 'nlo_eetthh_lib': writing makefile
| Process library 'nlo_eetthh_lib': removing old files
| Process library 'nlo_eetthh_lib': writing driver
| Process library 'nlo_eetthh_lib': creating source code
| Process library 'nlo_eetthh_lib': compiling sources
| Process library 'nlo_eetthh_lib': linking
| Process library 'nlo_eetthh_lib': loading
| Process library 'nlo_eetthh_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 8131
| Initializing integration for process nlo_eetthh_p1:
| Beam structure: [any particles]
| Beam data (collision):
| e- (mass = 0.0000000E+00 GeV)
| e+ (mass = 0.0000000E+00 GeV)
| sqrts = 1.000000000000E+03 GeV
| Phase space: generating configuration ...
| Phase space: ... failed. Increasing phs_off_shell ...
| Phase space: ... success.
| Phase space: writing configuration file 'nlo_eetthh_p1.i1.phs'
| Phase space: generating configuration ...
| Phase space: ... failed. Increasing phs_off_shell ...
| Phase space: ... success.
| Phase space: writing configuration file 'nlo_eetthh_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: [...]
| 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]: 'nlo_eetthh_p1'
| Library name = 'nlo_eetthh_lib'
| Process index = 1
| Process components:
| 1: 'nlo_eetthh_p1_i1': e-, e+ => t, tbar, H, H [openloops]
| 2: 'nlo_eetthh_p1_i2': e-, e+ => t, tbar, H, H, gl [openloops], [real]
| 3: 'nlo_eetthh_p1_i3': e-, e+ => t, tbar, H, H [openloops], [virtual]
| 4: 'nlo_eetthh_p1_i4': e-, e+ => t, tbar, H, H [inactive], [subtraction]
| ------------------------------------------------------------------------
| Phase space: 12 channels, 8 dimensions
| Phase space: found 12 channels, collected in 1 grove.
-| Phase space: no equivalences between channels used.
+| Phase space: Using 24 equivalences between channels.
| Phase space: wood
| Phase space: 12 channels, 11 dimensions
| Phase space: found 12 channels, collected in 1 grove.
-| Phase space: no equivalences between channels used.
+| Phase space: Using 24 equivalences between channels.
| Phase space: wood
| Phase space: 12 channels, 8 dimensions
| Phase space: found 12 channels, collected in 1 grove.
-| Phase space: no equivalences between channels used.
+| Phase space: Using 24 equivalences between channels.
| Phase space: wood
Warning: No cuts have been defined.
| Using user-defined general scale.
| Starting integration for process 'nlo_eetthh_p1' part 'born'
| Integrate: iterations = 1:120:"gw"
| Integrator: 1 chains, 12 channels, 8 dimensions
+| Integrator: Using VAMP2 channel equivalences
| Integrator: 120 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 'nlo_eetthh_p1.m1.vg2'.
| VAMP2: set chain: use chained weights.
1 120 1.4402584E-02 1.91E-03 13.28 1.45* 25.31
|-----------------------------------------------------------------------------|
1 120 1.4402584E-02 1.91E-03 13.28 1.45 25.31
|=============================================================================|
| Starting integration for process 'nlo_eetthh_p1' part 'real'
| Integrate: iterations = 1:120:"gw"
| Integrator: 1 chains, 12 channels, 11 dimensions
+| Integrator: Using VAMP2 channel equivalences
| Integrator: 120 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 'nlo_eetthh_p1.m2.vg2'.
| VAMP2: set chain: use chained weights.
1 120 -2.7756784E-03 4.27E-04 15.39 1.69* 25.07
|-----------------------------------------------------------------------------|
1 120 -2.7756784E-03 4.27E-04 15.39 1.69 25.07
|=============================================================================|
| Starting integration for process 'nlo_eetthh_p1' part 'virtual'
| Integrate: iterations = 1:120:"gw"
| Integrator: 1 chains, 12 channels, 8 dimensions
+| Integrator: Using VAMP2 channel equivalences
| Integrator: 120 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 'nlo_eetthh_p1.m3.vg2'.
| VAMP2: set chain: use chained weights.
1 120 8.0975983E-04 1.36E-04 16.78 1.84* 23.76
|-----------------------------------------------------------------------------|
1 120 8.0975983E-04 1.36E-04 16.78 1.84 23.76
|=============================================================================|
| Integrate: sum of all components
|=============================================================================|
| It Calls Integral[fb] Error[fb] Err[%] Acc Eff[%] Chi2 N[It] |
|=============================================================================|
1 0 1.2436666E-02 1.96E-03 15.80 0.00* 20.62
| NLO Correction: [O(alpha_s+1)/O(alpha_s)]
| (-13.6498 +- 3.60157 ) %
|=============================================================================|
| There were no errors and 1 warning(s).
| WHIZARD run finished.
|=============================================================================|
Index: trunk/share/tests/ext_tests_nlo/ref-output/nlo_eetthj.ref
===================================================================
--- trunk/share/tests/ext_tests_nlo/ref-output/nlo_eetthj.ref (revision 8482)
+++ trunk/share/tests/ext_tests_nlo/ref-output/nlo_eetthj.ref (revision 8483)
@@ -1,163 +1,165 @@
?openmp_logging = false
?vis_history = false
?integration_timer = false
openmp_num_threads = 1
?debug_decay = false
?debug_process = false
?debug_verbose = false
?write_raw = false
| Switching to model 'SM', scheme 'GF_MW_MZ'
$blha_ew_scheme = "alpha_qed"
SM.mZ => 9.118800000000E+01
SM.mW => 8.041900200000E+01
SM.mH => 1.250000000000E+02
SM.GF => 1.166390000000E-05
SM.wZ => 0.000000000000E+00
SM.wtop => 0.000000000000E+00
SM.wW => 0.000000000000E+00
SM.wH => 0.000000000000E+00
SM.ms => 0.000000000000E+00
SM.mc => 0.000000000000E+00
SM.mb => 0.000000000000E+00
SM.mtop => 1.732000000000E+02
SM.me => 0.000000000000E+00
SM.mmu => 0.000000000000E+00
SM.mtau => 1.777000000000E+00
SM.alphas => 1.180000000000E-01
?alphas_is_fixed = false
?alphas_from_mz = true
?alphas_from_lambda_qcd = false
alphas_nf = 5
alphas_order = 2
[user variable] jet = PDG(2, -2, 1, -1, 3, -3, 4, -4, 5, -5, 21)
$exclude_gauge_splittings = "t"
$method = "openloops"
seed = 8131
sqrts = 1.000000000000E+03
jet_algorithm = 2
jet_r = 5.000000000000E-01
-?use_vamp_equivalences = false
$integration_method = "vamp2"
$rng_method = "rng_stream"
| End of included 'nlo_settings.sin'
alpha_power = 3
alphas_power = 1
| Process library 'nlo_eetthj_lib': recorded process 'nlo_eetthj_p1'
| Integrate: current process library needs compilation
| Process library 'nlo_eetthj_lib': compiling ...
| Process library 'nlo_eetthj_lib': writing makefile
| Process library 'nlo_eetthj_lib': removing old files
| Process library 'nlo_eetthj_lib': writing driver
| Process library 'nlo_eetthj_lib': creating source code
| Process library 'nlo_eetthj_lib': compiling sources
| Process library 'nlo_eetthj_lib': linking
| Process library 'nlo_eetthj_lib': loading
| Process library 'nlo_eetthj_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 8131
| Initializing integration for process nlo_eetthj_p1:
| Beam structure: [any particles]
| Beam data (collision):
| e- (mass = 0.0000000E+00 GeV)
| e+ (mass = 0.0000000E+00 GeV)
| sqrts = 1.000000000000E+03 GeV
| Phase space: generating configuration ...
| Phase space: ... success.
| Phase space: writing configuration file 'nlo_eetthj_p1.i1.phs'
| Phase space: generating configuration ...
| Phase space: ... success.
| Phase space: writing configuration file 'nlo_eetthj_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: [...]
| 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]: 'nlo_eetthj_p1'
| Library name = 'nlo_eetthj_lib'
| Process index = 1
| Process components:
| 1: 'nlo_eetthj_p1_i1': e-, e+ => t, tbar, H, u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl [openloops]
| 2: 'nlo_eetthj_p1_i2': e-, e+ => t, tbar, H, d:dbar:u:ubar:s:sbar:c:cbar:b:bbar:gl, d:dbar:u:ubar:s:sbar:c:cbar:b:bbar:gl [openloops], [real]
| 3: 'nlo_eetthj_p1_i3': e-, e+ => t, tbar, H, u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl [openloops], [virtual]
| 4: 'nlo_eetthj_p1_i4': e-, e+ => t, tbar, H, u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl [inactive], [subtraction]
| ------------------------------------------------------------------------
| Phase space: 6 channels, 8 dimensions
| Phase space: found 6 channels, collected in 1 grove.
-| Phase space: no equivalences between channels used.
+| Phase space: Using 6 equivalences between channels.
| Phase space: wood
| Phase space: 6 channels, 11 dimensions
| Phase space: found 6 channels, collected in 1 grove.
-| Phase space: no equivalences between channels used.
+| Phase space: Using 6 equivalences between channels.
| Phase space: wood
| Phase space: 6 channels, 8 dimensions
| Phase space: found 6 channels, collected in 1 grove.
-| Phase space: no equivalences between channels used.
+| Phase space: Using 6 equivalences between channels.
| Phase space: wood
| Applying user-defined cuts.
| Using user-defined general scale.
| Starting integration for process 'nlo_eetthj_p1' part 'born'
| Integrate: iterations = 1:100:"gw"
| Integrator: 1 chains, 6 channels, 8 dimensions
+| Integrator: Using VAMP2 channel equivalences
| 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 'nlo_eetthj_p1.m1.vg2'.
| VAMP2: set chain: use chained weights.
1 102 2.1971622E-01 5.21E-02 23.71 2.39* 12.91
|-----------------------------------------------------------------------------|
1 102 2.1971622E-01 5.21E-02 23.71 2.39 12.91
|=============================================================================|
| Starting integration for process 'nlo_eetthj_p1' part 'real'
| Integrate: iterations = 1:100:"gw"
| Integrator: 1 chains, 6 channels, 11 dimensions
+| Integrator: Using VAMP2 channel equivalences
| 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 'nlo_eetthj_p1.m2.vg2'.
| VAMP2: set chain: use chained weights.
1 102 4.1144864E-03 2.13E-02 517.36 52.25* 10.40
|-----------------------------------------------------------------------------|
1 102 4.1144864E-03 2.13E-02 517.36 52.25 10.40
|=============================================================================|
| Starting integration for process 'nlo_eetthj_p1' part 'virtual'
| Integrate: iterations = 1:100:"gw"
| Integrator: 1 chains, 6 channels, 8 dimensions
+| Integrator: Using VAMP2 channel equivalences
| 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 'nlo_eetthj_p1.m3.vg2'.
| VAMP2: set chain: use chained weights.
1 102 1.7075037E-02 5.97E-03 34.97 3.53* 9.79
|-----------------------------------------------------------------------------|
1 102 1.7075037E-02 5.97E-03 34.97 3.53 9.79
|=============================================================================|
| Integrate: sum of all components
|=============================================================================|
| It Calls Integral[fb] Error[fb] Err[%] Acc Eff[%] Chi2 N[It] |
|=============================================================================|
1 0 2.4090574E-01 5.66E-02 23.49 0.00* 12.57
| NLO Correction: [O(alpha_s+1)/O(alpha_s)]
| ( 9.6440 +- 10.31875 ) %
|=============================================================================|
| WHIZARD run finished.
|=============================================================================|
Index: trunk/share/tests/ext_tests_nlo/ref-output/nlo_eettjj.ref
===================================================================
--- trunk/share/tests/ext_tests_nlo/ref-output/nlo_eettjj.ref (revision 8482)
+++ trunk/share/tests/ext_tests_nlo/ref-output/nlo_eettjj.ref (revision 8483)
@@ -1,166 +1,168 @@
?openmp_logging = false
?vis_history = false
?integration_timer = false
openmp_num_threads = 1
?debug_decay = false
?debug_process = false
?debug_verbose = false
?write_raw = false
| Switching to model 'SM', scheme 'GF_MW_MZ'
$blha_ew_scheme = "alpha_qed"
SM.mZ => 9.118800000000E+01
SM.mW => 8.041900200000E+01
SM.mH => 1.250000000000E+02
SM.GF => 1.166390000000E-05
SM.wZ => 0.000000000000E+00
SM.wtop => 0.000000000000E+00
SM.wW => 0.000000000000E+00
SM.wH => 0.000000000000E+00
SM.ms => 0.000000000000E+00
SM.mc => 0.000000000000E+00
SM.mb => 0.000000000000E+00
SM.mtop => 1.732000000000E+02
SM.me => 0.000000000000E+00
SM.mmu => 0.000000000000E+00
SM.mtau => 1.777000000000E+00
SM.alphas => 1.180000000000E-01
?alphas_is_fixed = false
?alphas_from_mz = true
?alphas_from_lambda_qcd = false
alphas_nf = 5
alphas_order = 2
[user variable] jet = PDG(2, -2, 1, -1, 3, -3, 4, -4, 5, -5, 21)
$exclude_gauge_splittings = "t"
$method = "openloops"
seed = 8131
sqrts = 1.000000000000E+03
jet_algorithm = 2
jet_r = 5.000000000000E-01
-?use_vamp_equivalences = false
$integration_method = "vamp2"
$rng_method = "rng_stream"
| End of included 'nlo_settings.sin'
alpha_power = 2
alphas_power = 2
| Process library 'nlo_eettjj_lib': recorded process 'nlo_eettjj_p1'
| Integrate: current process library needs compilation
| Process library 'nlo_eettjj_lib': compiling ...
| Process library 'nlo_eettjj_lib': writing makefile
| Process library 'nlo_eettjj_lib': removing old files
| Process library 'nlo_eettjj_lib': writing driver
| Process library 'nlo_eettjj_lib': creating source code
| Process library 'nlo_eettjj_lib': compiling sources
| Process library 'nlo_eettjj_lib': linking
| Process library 'nlo_eettjj_lib': loading
| Process library 'nlo_eettjj_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 8131
| Initializing integration for process nlo_eettjj_p1:
| Beam structure: [any particles]
| Beam data (collision):
| e- (mass = 0.0000000E+00 GeV)
| e+ (mass = 0.0000000E+00 GeV)
| sqrts = 1.000000000000E+03 GeV
| Phase space: generating configuration ...
Warning: Intermediate decay of zero-width particle Z may be possible.
Warning: Intermediate decay of zero-width particle H may be possible.
| Phase space: ... success.
| Phase space: writing configuration file 'nlo_eettjj_p1.i1.phs'
| Phase space: generating configuration ...
| Phase space: ... success.
| Phase space: writing configuration file 'nlo_eettjj_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: [...]
| 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]: 'nlo_eettjj_p1'
| Library name = 'nlo_eettjj_lib'
| Process index = 1
| Process components:
| 1: 'nlo_eettjj_p1_i1': e-, e+ => t, tbar, u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl, u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl [openloops]
| 2: 'nlo_eettjj_p1_i2': e-, e+ => t, tbar, d:dbar:u:ubar:s:sbar:c:cbar:b:bbar:gl, d:dbar:u:ubar:s:sbar:c:cbar:b:bbar:gl, d:dbar:u:ubar:s:sbar:c:cbar:b:bbar:gl [openloops], [real]
| 3: 'nlo_eettjj_p1_i3': e-, e+ => t, tbar, u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl, u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl [openloops], [virtual]
| 4: 'nlo_eettjj_p1_i4': e-, e+ => t, tbar, u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl, u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl [inactive], [subtraction]
| ------------------------------------------------------------------------
| Phase space: 18 channels, 8 dimensions
| Phase space: found 18 channels, collected in 5 groves.
-| Phase space: no equivalences between channels used.
+| Phase space: Using 24 equivalences between channels.
| Phase space: wood
| Phase space: 18 channels, 11 dimensions
| Phase space: found 18 channels, collected in 5 groves.
-| Phase space: no equivalences between channels used.
+| Phase space: Using 24 equivalences between channels.
| Phase space: wood
| Phase space: 18 channels, 8 dimensions
| Phase space: found 18 channels, collected in 5 groves.
-| Phase space: no equivalences between channels used.
+| Phase space: Using 24 equivalences between channels.
| Phase space: wood
| Applying user-defined cuts.
| Using user-defined general scale.
| Starting integration for process 'nlo_eettjj_p1' part 'born'
| Integrate: iterations = 1:180:"gw"
| Integrator: 5 chains, 18 channels, 8 dimensions
+| Integrator: Using VAMP2 channel equivalences
| Integrator: 180 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 'nlo_eettjj_p1.m1.vg2'.
| VAMP2: set chain: use chained weights.
1 190 1.4441407E+01 7.60E+00 52.64 7.26* 11.58
|-----------------------------------------------------------------------------|
1 190 1.4441407E+01 7.60E+00 52.64 7.26 11.58
|=============================================================================|
| Starting integration for process 'nlo_eettjj_p1' part 'real'
| Integrate: iterations = 1:180:"gw"
| Integrator: 5 chains, 18 channels, 11 dimensions
+| Integrator: Using VAMP2 channel equivalences
| Integrator: 180 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 'nlo_eettjj_p1.m2.vg2'.
| VAMP2: set chain: use chained weights.
1 190 -2.3800632E+00 3.08E+00 129.59 17.86* 12.11
|-----------------------------------------------------------------------------|
1 190 -2.3800632E+00 3.08E+00 129.59 17.86 12.11
|=============================================================================|
| Starting integration for process 'nlo_eettjj_p1' part 'virtual'
| Integrate: iterations = 1:180:"gw"
| Integrator: 5 chains, 18 channels, 8 dimensions
+| Integrator: Using VAMP2 channel equivalences
| Integrator: 180 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 'nlo_eettjj_p1.m3.vg2'.
| VAMP2: set chain: use chained weights.
1 184 6.3942161E-01 5.43E-01 84.96 11.52* 13.70
|-----------------------------------------------------------------------------|
1 184 6.3942161E-01 5.43E-01 84.96 11.52 13.70
|=============================================================================|
| Integrate: sum of all components
|=============================================================================|
| It Calls Integral[fb] Error[fb] Err[%] Acc Eff[%] Chi2 N[It] |
|=============================================================================|
1 0 1.2700765E+01 8.22E+00 64.73 0.00* 9.81
| NLO Correction: [O(alpha_s+1)/O(alpha_s)]
| (-12.0531 +- 22.59596 ) %
|=============================================================================|
| There were no errors and 2 warning(s).
| WHIZARD run finished.
|=============================================================================|
Index: trunk/share/tests/ext_tests_nlo/ref-output/nlo_eettzz.ref
===================================================================
--- trunk/share/tests/ext_tests_nlo/ref-output/nlo_eettzz.ref (revision 8482)
+++ trunk/share/tests/ext_tests_nlo/ref-output/nlo_eettzz.ref (revision 8483)
@@ -1,164 +1,166 @@
?openmp_logging = false
?vis_history = false
?integration_timer = false
openmp_num_threads = 1
?debug_decay = false
?debug_process = false
?debug_verbose = false
?write_raw = false
| Switching to model 'SM', scheme 'GF_MW_MZ'
$blha_ew_scheme = "alpha_qed"
SM.mZ => 9.118800000000E+01
SM.mW => 8.041900200000E+01
SM.mH => 1.250000000000E+02
SM.GF => 1.166390000000E-05
SM.wZ => 0.000000000000E+00
SM.wtop => 0.000000000000E+00
SM.wW => 0.000000000000E+00
SM.wH => 0.000000000000E+00
SM.ms => 0.000000000000E+00
SM.mc => 0.000000000000E+00
SM.mb => 0.000000000000E+00
SM.mtop => 1.732000000000E+02
SM.me => 0.000000000000E+00
SM.mmu => 0.000000000000E+00
SM.mtau => 1.777000000000E+00
SM.alphas => 1.180000000000E-01
?alphas_is_fixed = false
?alphas_from_mz = true
?alphas_from_lambda_qcd = false
alphas_nf = 5
alphas_order = 2
[user variable] jet = PDG(2, -2, 1, -1, 3, -3, 4, -4, 5, -5, 21)
$exclude_gauge_splittings = "t"
$method = "openloops"
seed = 8131
sqrts = 1.000000000000E+03
jet_algorithm = 2
jet_r = 5.000000000000E-01
-?use_vamp_equivalences = false
$integration_method = "vamp2"
$rng_method = "rng_stream"
| End of included 'nlo_settings.sin'
alpha_power = 4
alphas_power = 0
| Process library 'nlo_eettzz_lib': recorded process 'nlo_eettzz_p1'
| Integrate: current process library needs compilation
| Process library 'nlo_eettzz_lib': compiling ...
| Process library 'nlo_eettzz_lib': writing makefile
| Process library 'nlo_eettzz_lib': removing old files
| Process library 'nlo_eettzz_lib': writing driver
| Process library 'nlo_eettzz_lib': creating source code
| Process library 'nlo_eettzz_lib': compiling sources
| Process library 'nlo_eettzz_lib': linking
| Process library 'nlo_eettzz_lib': loading
| Process library 'nlo_eettzz_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 8131
| Initializing integration for process nlo_eettzz_p1:
| Beam structure: [any particles]
| Beam data (collision):
| e- (mass = 0.0000000E+00 GeV)
| e+ (mass = 0.0000000E+00 GeV)
| sqrts = 1.000000000000E+03 GeV
| Phase space: generating configuration ...
| Phase space: ... success.
| Phase space: writing configuration file 'nlo_eettzz_p1.i1.phs'
| Phase space: generating configuration ...
| Phase space: ... success.
| Phase space: writing configuration file 'nlo_eettzz_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: [...]
| 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]: 'nlo_eettzz_p1'
| Library name = 'nlo_eettzz_lib'
| Process index = 1
| Process components:
| 1: 'nlo_eettzz_p1_i1': e-, e+ => t, tbar, Z, Z [openloops]
| 2: 'nlo_eettzz_p1_i2': e-, e+ => t, tbar, Z, Z, gl [openloops], [real]
| 3: 'nlo_eettzz_p1_i3': e-, e+ => t, tbar, Z, Z [openloops], [virtual]
| 4: 'nlo_eettzz_p1_i4': e-, e+ => t, tbar, Z, Z [inactive], [subtraction]
| ------------------------------------------------------------------------
| Phase space: 20 channels, 8 dimensions
| Phase space: found 20 channels, collected in 3 groves.
-| Phase space: no equivalences between channels used.
+| Phase space: Using 64 equivalences between channels.
| Phase space: wood
| Phase space: 20 channels, 11 dimensions
| Phase space: found 20 channels, collected in 3 groves.
-| Phase space: no equivalences between channels used.
+| Phase space: Using 64 equivalences between channels.
| Phase space: wood
| Phase space: 20 channels, 8 dimensions
| Phase space: found 20 channels, collected in 3 groves.
-| Phase space: no equivalences between channels used.
+| Phase space: Using 64 equivalences between channels.
| Phase space: wood
Warning: No cuts have been defined.
| Using user-defined general scale.
| Starting integration for process 'nlo_eettzz_p1' part 'born'
| Integrate: iterations = 1:200:"gw"
| Integrator: 3 chains, 20 channels, 8 dimensions
+| Integrator: Using VAMP2 channel equivalences
| Integrator: 200 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 'nlo_eettzz_p1.m1.vg2'.
| VAMP2: set chain: use chained weights.
1 200 4.0872323E-02 9.12E-03 22.31 3.16* 15.41
|-----------------------------------------------------------------------------|
1 200 4.0872323E-02 9.12E-03 22.31 3.16 15.41
|=============================================================================|
| Starting integration for process 'nlo_eettzz_p1' part 'real'
| Integrate: iterations = 1:200:"gw"
| Integrator: 3 chains, 20 channels, 11 dimensions
+| Integrator: Using VAMP2 channel equivalences
| Integrator: 200 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 'nlo_eettzz_p1.m2.vg2'.
| VAMP2: set chain: use chained weights.
1 200 -1.4381791E-02 4.73E-03 32.86 4.65* 14.22
|-----------------------------------------------------------------------------|
1 200 -1.4381791E-02 4.73E-03 32.86 4.65 14.22
|=============================================================================|
| Starting integration for process 'nlo_eettzz_p1' part 'virtual'
| Integrate: iterations = 1:200:"gw"
| Integrator: 3 chains, 20 channels, 8 dimensions
+| Integrator: Using VAMP2 channel equivalences
| Integrator: 200 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 'nlo_eettzz_p1.m3.vg2'.
| VAMP2: set chain: use chained weights.
1 204 1.6832366E-02 3.67E-03 21.78 3.11* 15.60
|-----------------------------------------------------------------------------|
1 204 1.6832366E-02 3.67E-03 21.78 3.11 15.60
|=============================================================================|
| Integrate: sum of all components
|=============================================================================|
| It Calls Integral[fb] Error[fb] Err[%] Acc Eff[%] Chi2 N[It] |
|=============================================================================|
1 0 4.3322897E-02 1.09E-02 25.17 0.00* 11.61
| NLO Correction: [O(alpha_s+1)/O(alpha_s)]
| ( 5.9957 +- 14.69597 ) %
|=============================================================================|
| There were no errors and 1 warning(s).
| WHIZARD run finished.
|=============================================================================|
Index: trunk/share/tests/ext_tests_nlo/ref-output/nlo_eejjj.ref
===================================================================
--- trunk/share/tests/ext_tests_nlo/ref-output/nlo_eejjj.ref (revision 8482)
+++ trunk/share/tests/ext_tests_nlo/ref-output/nlo_eejjj.ref (revision 8483)
@@ -1,166 +1,168 @@
?openmp_logging = false
?vis_history = false
?integration_timer = false
openmp_num_threads = 1
?debug_decay = false
?debug_process = false
?debug_verbose = false
?write_raw = false
| Switching to model 'SM', scheme 'GF_MW_MZ'
$blha_ew_scheme = "alpha_qed"
SM.mZ => 9.118800000000E+01
SM.mW => 8.041900200000E+01
SM.mH => 1.250000000000E+02
SM.GF => 1.166390000000E-05
SM.wZ => 0.000000000000E+00
SM.wtop => 0.000000000000E+00
SM.wW => 0.000000000000E+00
SM.wH => 0.000000000000E+00
SM.ms => 0.000000000000E+00
SM.mc => 0.000000000000E+00
SM.mb => 0.000000000000E+00
SM.mtop => 1.732000000000E+02
SM.me => 0.000000000000E+00
SM.mmu => 0.000000000000E+00
SM.mtau => 1.777000000000E+00
SM.alphas => 1.180000000000E-01
?alphas_is_fixed = false
?alphas_from_mz = true
?alphas_from_lambda_qcd = false
alphas_nf = 5
alphas_order = 2
[user variable] jet = PDG(2, -2, 1, -1, 3, -3, 4, -4, 5, -5, 21)
$exclude_gauge_splittings = "t"
$method = "openloops"
seed = 8131
sqrts = 1.000000000000E+03
jet_algorithm = 2
jet_r = 5.000000000000E-01
-?use_vamp_equivalences = false
$integration_method = "vamp2"
$rng_method = "rng_stream"
| End of included 'nlo_settings.sin'
alpha_power = 2
alphas_power = 1
| Process library 'nlo_eejjj_lib': recorded process 'nlo_eejjj_p1'
| Integrate: current process library needs compilation
| Process library 'nlo_eejjj_lib': compiling ...
| Process library 'nlo_eejjj_lib': writing makefile
| Process library 'nlo_eejjj_lib': removing old files
| Process library 'nlo_eejjj_lib': writing driver
| Process library 'nlo_eejjj_lib': creating source code
| Process library 'nlo_eejjj_lib': compiling sources
| Process library 'nlo_eejjj_lib': linking
| Process library 'nlo_eejjj_lib': loading
| Process library 'nlo_eejjj_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 8131
| Initializing integration for process nlo_eejjj_p1:
| Beam structure: [any particles]
| Beam data (collision):
| e- (mass = 0.0000000E+00 GeV)
| e+ (mass = 0.0000000E+00 GeV)
| sqrts = 1.000000000000E+03 GeV
| Phase space: generating configuration ...
Warning: Intermediate decay of zero-width particle Z may be possible.
Warning: Intermediate decay of zero-width particle H may be possible.
| Phase space: ... success.
| Phase space: writing configuration file 'nlo_eejjj_p1.i1.phs'
| Phase space: generating configuration ...
| Phase space: ... success.
| Phase space: writing configuration file 'nlo_eejjj_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: [...]
| 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]: 'nlo_eejjj_p1'
| Library name = 'nlo_eejjj_lib'
| Process index = 1
| Process components:
| 1: 'nlo_eejjj_p1_i1': e-, e+ => u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl, u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl, u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl [openloops]
| 2: 'nlo_eejjj_p1_i2': e-, e+ => d:dbar:u:ubar:s:sbar:c:cbar:b:bbar:gl, d:dbar:u:ubar:s:sbar:c:cbar:b:bbar:gl, d:dbar:u:ubar:s:sbar:c:cbar:b:bbar:gl, d:dbar:u:ubar:s:sbar:c:cbar:b:bbar:gl [openloops], [real]
| 3: 'nlo_eejjj_p1_i3': e-, e+ => u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl, u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl, u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl [openloops], [virtual]
| 4: 'nlo_eejjj_p1_i4': e-, e+ => u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl, u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl, u:ubar:d:dbar:s:sbar:c:cbar:b:bbar: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: Using 2 equivalences between channels.
| 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: Using 2 equivalences between channels.
| 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: Using 2 equivalences between channels.
| Phase space: wood
| Applying user-defined cuts.
| Using user-defined general scale.
| Starting integration for process 'nlo_eejjj_p1' part 'born'
| Integrate: iterations = 1:100:"gw"
| Integrator: 1 chains, 2 channels, 5 dimensions
+| Integrator: Using VAMP2 channel equivalences
| 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 'nlo_eejjj_p1.m1.vg2'.
| VAMP2: set chain: use chained weights.
1 100 4.0193681E+02 1.37E+02 34.00 3.40* 7.11
|-----------------------------------------------------------------------------|
1 100 4.0193681E+02 1.37E+02 34.00 3.40 7.11
|=============================================================================|
| Starting integration for process 'nlo_eejjj_p1' part 'real'
| Integrate: iterations = 1:100:"gw"
| Integrator: 1 chains, 2 channels, 8 dimensions
+| Integrator: Using VAMP2 channel equivalences
| 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 'nlo_eejjj_p1.m2.vg2'.
| VAMP2: set chain: use chained weights.
1 100 1.0017265E+02 3.44E+01 34.33 3.43* 6.20
|-----------------------------------------------------------------------------|
1 100 1.0017265E+02 3.44E+01 34.33 3.43 6.20
|=============================================================================|
| Starting integration for process 'nlo_eejjj_p1' part 'virtual'
| Integrate: iterations = 1:100:"gw"
| Integrator: 1 chains, 2 channels, 5 dimensions
+| Integrator: Using VAMP2 channel equivalences
| 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 'nlo_eejjj_p1.m3.vg2'.
| VAMP2: set chain: use chained weights.
1 100 -3.1346969E+01 1.48E+01 47.08 4.71* 4.27
|-----------------------------------------------------------------------------|
1 100 -3.1346969E+01 1.48E+01 47.08 4.71 4.27
|=============================================================================|
| Integrate: sum of all components
|=============================================================================|
| It Calls Integral[fb] Error[fb] Err[%] Acc Eff[%] Chi2 N[It] |
|=============================================================================|
1 0 4.7076249E+02 1.42E+02 30.10 0.00* 6.48
| NLO Correction: [O(alpha_s+1)/O(alpha_s)]
| ( 17.1235 +- 10.98137 ) %
|=============================================================================|
| There were no errors and 2 warning(s).
| WHIZARD run finished.
|=============================================================================|
Index: trunk/share/tests/ext_tests_nlo/ref-output/nlo_ee4j.ref
===================================================================
--- trunk/share/tests/ext_tests_nlo/ref-output/nlo_ee4j.ref (revision 8482)
+++ trunk/share/tests/ext_tests_nlo/ref-output/nlo_ee4j.ref (revision 8483)
@@ -1,169 +1,171 @@
?openmp_logging = false
?vis_history = false
?integration_timer = false
openmp_num_threads = 1
?debug_decay = false
?debug_process = false
?debug_verbose = false
?write_raw = false
| Switching to model 'SM', scheme 'GF_MW_MZ'
$blha_ew_scheme = "alpha_qed"
SM.mZ => 9.118800000000E+01
SM.mW => 8.041900200000E+01
SM.mH => 1.250000000000E+02
SM.GF => 1.166390000000E-05
SM.wZ => 0.000000000000E+00
SM.wtop => 0.000000000000E+00
SM.wW => 0.000000000000E+00
SM.wH => 0.000000000000E+00
SM.ms => 0.000000000000E+00
SM.mc => 0.000000000000E+00
SM.mb => 0.000000000000E+00
SM.mtop => 1.732000000000E+02
SM.me => 0.000000000000E+00
SM.mmu => 0.000000000000E+00
SM.mtau => 1.777000000000E+00
SM.alphas => 1.180000000000E-01
?alphas_is_fixed = false
?alphas_from_mz = true
?alphas_from_lambda_qcd = false
alphas_nf = 5
alphas_order = 2
[user variable] jet = PDG(2, -2, 1, -1, 3, -3, 4, -4, 5, -5, 21)
$exclude_gauge_splittings = "t"
$method = "openloops"
seed = 8131
sqrts = 1.000000000000E+03
jet_algorithm = 2
jet_r = 5.000000000000E-01
-?use_vamp_equivalences = false
$integration_method = "vamp2"
$rng_method = "rng_stream"
| End of included 'nlo_settings.sin'
alpha_power = 2
alphas_power = 2
$restrictions = "!W+:W-"
| Process library 'nlo_ee4j_lib': recorded process 'nlo_ee4j_p1'
| Integrate: current process library needs compilation
| Process library 'nlo_ee4j_lib': compiling ...
| Process library 'nlo_ee4j_lib': writing makefile
| Process library 'nlo_ee4j_lib': removing old files
| Process library 'nlo_ee4j_lib': writing driver
| Process library 'nlo_ee4j_lib': creating source code
| Process library 'nlo_ee4j_lib': compiling sources
| Process library 'nlo_ee4j_lib': linking
| Process library 'nlo_ee4j_lib': loading
| Process library 'nlo_ee4j_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 8131
| Initializing integration for process nlo_ee4j_p1:
| Beam structure: [any particles]
| Beam data (collision):
| e- (mass = 0.0000000E+00 GeV)
| e+ (mass = 0.0000000E+00 GeV)
| sqrts = 1.000000000000E+03 GeV
| Phase space: generating configuration ...
Warning: Intermediate decay of zero-width particle Z may be possible.
Warning: Intermediate decay of zero-width particle H may be possible.
Warning: Intermediate decay of zero-width particle W- may be possible.
Warning: Intermediate decay of zero-width particle W+ may be possible.
| Phase space: ... success.
| Phase space: writing configuration file 'nlo_ee4j_p1.i1.phs'
| Phase space: generating configuration ...
| Phase space: ... success.
| Phase space: writing configuration file 'nlo_ee4j_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: [...]
| 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]: 'nlo_ee4j_p1'
| Library name = 'nlo_ee4j_lib'
| Process index = 1
| Process components:
| 1: 'nlo_ee4j_p1_i1': e-, e+ => u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl, u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl, u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl, u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl [openloops]
| 2: 'nlo_ee4j_p1_i2': e-, e+ => d:dbar:u:ubar:s:sbar:c:cbar:b:bbar:gl, d:dbar:u:ubar:s:sbar:c:cbar:b:bbar:gl, d:dbar:u:ubar:s:sbar:c:cbar:b:bbar:gl, d:dbar:u:ubar:s:sbar:c:cbar:b:bbar:gl, d:dbar:u:ubar:s:sbar:c:cbar:b:bbar:gl [openloops], [real]
| 3: 'nlo_ee4j_p1_i3': e-, e+ => u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl, u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl, u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl, u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl [openloops], [virtual]
| 4: 'nlo_ee4j_p1_i4': e-, e+ => u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl, u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl, u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl, u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl [inactive], [subtraction]
| ------------------------------------------------------------------------
| Phase space: 48 channels, 8 dimensions
| Phase space: found 48 channels, collected in 5 groves.
-| Phase space: no equivalences between channels used.
+| Phase space: Using 320 equivalences between channels.
| Phase space: wood
| Phase space: 48 channels, 11 dimensions
| Phase space: found 48 channels, collected in 5 groves.
-| Phase space: no equivalences between channels used.
+| Phase space: Using 320 equivalences between channels.
| Phase space: wood
| Phase space: 48 channels, 8 dimensions
| Phase space: found 48 channels, collected in 5 groves.
-| Phase space: no equivalences between channels used.
+| Phase space: Using 320 equivalences between channels.
| Phase space: wood
| Applying user-defined cuts.
| Using user-defined general scale.
| Starting integration for process 'nlo_ee4j_p1' part 'born'
| Integrate: iterations = 1:480:"gw"
| Integrator: 5 chains, 48 channels, 8 dimensions
+| Integrator: Using VAMP2 channel equivalences
| Integrator: 480 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 'nlo_ee4j_p1.m1.vg2'.
| VAMP2: set chain: use chained weights.
1 494 8.8893730E+01 4.52E+01 50.81 11.29* 12.59
|-----------------------------------------------------------------------------|
1 494 8.8893730E+01 4.52E+01 50.81 11.29 12.59
|=============================================================================|
| Starting integration for process 'nlo_ee4j_p1' part 'real'
| Integrate: iterations = 1:480:"gw"
| Integrator: 5 chains, 48 channels, 11 dimensions
+| Integrator: Using VAMP2 channel equivalences
| Integrator: 480 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 'nlo_ee4j_p1.m2.vg2'.
| VAMP2: set chain: use chained weights.
1 494 4.2862344E+01 1.13E+01 26.34 5.85* 13.34
|-----------------------------------------------------------------------------|
1 494 4.2862344E+01 1.13E+01 26.34 5.85 13.34
|=============================================================================|
| Starting integration for process 'nlo_ee4j_p1' part 'virtual'
| Integrate: iterations = 1:480:"gw"
| Integrator: 5 chains, 48 channels, 8 dimensions
+| Integrator: Using VAMP2 channel equivalences
| Integrator: 480 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 'nlo_ee4j_p1.m3.vg2'.
| VAMP2: set chain: use chained weights.
1 488 -2.3587867E+01 9.36E+00 39.69 8.77* 10.74
|-----------------------------------------------------------------------------|
1 488 -2.3587867E+01 9.36E+00 39.69 8.77 10.74
|=============================================================================|
| Integrate: sum of all components
|=============================================================================|
| It Calls Integral[fb] Error[fb] Err[%] Acc Eff[%] Chi2 N[It] |
|=============================================================================|
1 0 1.0816821E+02 4.75E+01 43.91 0.00* 10.53
| NLO Correction: [O(alpha_s+1)/O(alpha_s)]
| ( 21.6826 +- 19.83813 ) %
|=============================================================================|
| There were no errors and 4 warning(s).
| WHIZARD run finished.
|=============================================================================|
Index: trunk/share/tests/ext_tests_nlo/ref-output/nlo_ee5j.ref
===================================================================
--- trunk/share/tests/ext_tests_nlo/ref-output/nlo_ee5j.ref (revision 8482)
+++ trunk/share/tests/ext_tests_nlo/ref-output/nlo_ee5j.ref (revision 8483)
@@ -1,169 +1,171 @@
?openmp_logging = false
?vis_history = false
?integration_timer = false
openmp_num_threads = 1
?debug_decay = false
?debug_process = false
?debug_verbose = false
?write_raw = false
| Switching to model 'SM', scheme 'GF_MW_MZ'
$blha_ew_scheme = "alpha_qed"
SM.mZ => 9.118800000000E+01
SM.mW => 8.041900200000E+01
SM.mH => 1.250000000000E+02
SM.GF => 1.166390000000E-05
SM.wZ => 0.000000000000E+00
SM.wtop => 0.000000000000E+00
SM.wW => 0.000000000000E+00
SM.wH => 0.000000000000E+00
SM.ms => 0.000000000000E+00
SM.mc => 0.000000000000E+00
SM.mb => 0.000000000000E+00
SM.mtop => 1.732000000000E+02
SM.me => 0.000000000000E+00
SM.mmu => 0.000000000000E+00
SM.mtau => 1.777000000000E+00
SM.alphas => 1.180000000000E-01
?alphas_is_fixed = false
?alphas_from_mz = true
?alphas_from_lambda_qcd = false
alphas_nf = 5
alphas_order = 2
[user variable] jet = PDG(2, -2, 1, -1, 3, -3, 4, -4, 5, -5, 21)
$exclude_gauge_splittings = "t"
$method = "openloops"
seed = 8131
sqrts = 1.000000000000E+03
jet_algorithm = 2
jet_r = 5.000000000000E-01
-?use_vamp_equivalences = false
$integration_method = "vamp2"
$rng_method = "rng_stream"
| End of included 'nlo_settings.sin'
alpha_power = 2
alphas_power = 3
$restrictions = "!W+:W-"
| Process library 'nlo_ee5j_lib': recorded process 'nlo_ee5j_p1'
| Integrate: current process library needs compilation
| Process library 'nlo_ee5j_lib': compiling ...
| Process library 'nlo_ee5j_lib': writing makefile
| Process library 'nlo_ee5j_lib': removing old files
| Process library 'nlo_ee5j_lib': writing driver
| Process library 'nlo_ee5j_lib': creating source code
| Process library 'nlo_ee5j_lib': compiling sources
| Process library 'nlo_ee5j_lib': linking
| Process library 'nlo_ee5j_lib': loading
| Process library 'nlo_ee5j_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 8131
| Initializing integration for process nlo_ee5j_p1:
| Beam structure: [any particles]
| Beam data (collision):
| e- (mass = 0.0000000E+00 GeV)
| e+ (mass = 0.0000000E+00 GeV)
| sqrts = 1.000000000000E+03 GeV
| Phase space: generating configuration ...
Warning: Intermediate decay of zero-width particle Z may be possible.
Warning: Intermediate decay of zero-width particle H may be possible.
Warning: Intermediate decay of zero-width particle W- may be possible.
Warning: Intermediate decay of zero-width particle W+ may be possible.
| Phase space: ... success.
| Phase space: writing configuration file 'nlo_ee5j_p1.i1.phs'
| Phase space: generating configuration ...
| Phase space: ... success.
| Phase space: writing configuration file 'nlo_ee5j_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: [...]
| 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]: 'nlo_ee5j_p1'
| Library name = 'nlo_ee5j_lib'
| Process index = 1
| Process components:
| 1: 'nlo_ee5j_p1_i1': e-, e+ => u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl, u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl, u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl, u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl, u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl [openloops]
| 2: 'nlo_ee5j_p1_i2': e-, e+ => d:dbar:u:ubar:s:sbar:c:cbar:b:bbar:gl, d:dbar:u:ubar:s:sbar:c:cbar:b:bbar:gl, d:dbar:u:ubar:s:sbar:c:cbar:b:bbar:gl, d:dbar:u:ubar:s:sbar:c:cbar:b:bbar:gl, d:dbar:u:ubar:s:sbar:c:cbar:b:bbar:gl, d:dbar:u:ubar:s:sbar:c:cbar:b:bbar:gl [openloops], [real]
| 3: 'nlo_ee5j_p1_i3': e-, e+ => u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl, u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl, u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl, u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl, u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl [openloops], [virtual]
| 4: 'nlo_ee5j_p1_i4': e-, e+ => u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl, u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl, u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl, u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl, u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl [inactive], [subtraction]
| ------------------------------------------------------------------------
| Phase space: 104 channels, 11 dimensions
| Phase space: found 104 channels, collected in 3 groves.
-| Phase space: no equivalences between channels used.
+| Phase space: Using 672 equivalences between channels.
| Phase space: wood
| Phase space: 104 channels, 14 dimensions
| Phase space: found 104 channels, collected in 3 groves.
-| Phase space: no equivalences between channels used.
+| Phase space: Using 672 equivalences between channels.
| Phase space: wood
| Phase space: 104 channels, 11 dimensions
| Phase space: found 104 channels, collected in 3 groves.
-| Phase space: no equivalences between channels used.
+| Phase space: Using 672 equivalences between channels.
| Phase space: wood
| Applying user-defined cuts.
| Using user-defined general scale.
| Starting integration for process 'nlo_ee5j_p1' part 'born'
| Integrate: iterations = 1:1040:"gw"
| Integrator: 3 chains, 104 channels, 11 dimensions
+| Integrator: Using VAMP2 channel equivalences
| Integrator: 1040 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 'nlo_ee5j_p1.m1.vg2'.
| VAMP2: set chain: use chained weights.
1 1040 1.8756860E+01 9.19E+00 49.00 15.80* 10.03
|-----------------------------------------------------------------------------|
1 1040 1.8756860E+01 9.19E+00 49.00 15.80 10.03
|=============================================================================|
| Starting integration for process 'nlo_ee5j_p1' part 'real'
| Integrate: iterations = 1:1040:"gw"
| Integrator: 3 chains, 104 channels, 14 dimensions
+| Integrator: Using VAMP2 channel equivalences
| Integrator: 1040 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 'nlo_ee5j_p1.m2.vg2'.
| VAMP2: set chain: use chained weights.
1 1040 1.4196379E+01 4.65E+00 32.75 10.56* 11.70
|-----------------------------------------------------------------------------|
1 1040 1.4196379E+01 4.65E+00 32.75 10.56 11.70
|=============================================================================|
| Starting integration for process 'nlo_ee5j_p1' part 'virtual'
| Integrate: iterations = 1:1040:"gw"
| Integrator: 3 chains, 104 channels, 11 dimensions
+| Integrator: Using VAMP2 channel equivalences
| Integrator: 1040 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 'nlo_ee5j_p1.m3.vg2'.
| VAMP2: set chain: use chained weights.
1 1040 -4.8314113E+01 4.40E+01 90.98 29.34* 10.14
|-----------------------------------------------------------------------------|
1 1040 -4.8314113E+01 4.40E+01 90.98 29.34 10.14
|=============================================================================|
| Integrate: sum of all components
|=============================================================================|
| It Calls Integral[fb] Error[fb] Err[%] Acc Eff[%] Chi2 N[It] |
|=============================================================================|
1 0 -1.5360874E+01 4.51E+01 293.90 0.00* -4.98
| NLO Correction: [O(alpha_s+1)/O(alpha_s)]
| (******** +- 251.94021 ) %
|=============================================================================|
| There were no errors and 4 warning(s).
| WHIZARD run finished.
|=============================================================================|
Index: trunk/share/tests/ext_tests_nlo/ref-output/nlo_eettz.ref
===================================================================
--- trunk/share/tests/ext_tests_nlo/ref-output/nlo_eettz.ref (revision 8482)
+++ trunk/share/tests/ext_tests_nlo/ref-output/nlo_eettz.ref (revision 8483)
@@ -1,164 +1,166 @@
?openmp_logging = false
?vis_history = false
?integration_timer = false
openmp_num_threads = 1
?debug_decay = false
?debug_process = false
?debug_verbose = false
?write_raw = false
| Switching to model 'SM', scheme 'GF_MW_MZ'
$blha_ew_scheme = "alpha_qed"
SM.mZ => 9.118800000000E+01
SM.mW => 8.041900200000E+01
SM.mH => 1.250000000000E+02
SM.GF => 1.166390000000E-05
SM.wZ => 0.000000000000E+00
SM.wtop => 0.000000000000E+00
SM.wW => 0.000000000000E+00
SM.wH => 0.000000000000E+00
SM.ms => 0.000000000000E+00
SM.mc => 0.000000000000E+00
SM.mb => 0.000000000000E+00
SM.mtop => 1.732000000000E+02
SM.me => 0.000000000000E+00
SM.mmu => 0.000000000000E+00
SM.mtau => 1.777000000000E+00
SM.alphas => 1.180000000000E-01
?alphas_is_fixed = false
?alphas_from_mz = true
?alphas_from_lambda_qcd = false
alphas_nf = 5
alphas_order = 2
[user variable] jet = PDG(2, -2, 1, -1, 3, -3, 4, -4, 5, -5, 21)
$exclude_gauge_splittings = "t"
$method = "openloops"
seed = 8131
sqrts = 1.000000000000E+03
jet_algorithm = 2
jet_r = 5.000000000000E-01
-?use_vamp_equivalences = false
$integration_method = "vamp2"
$rng_method = "rng_stream"
| End of included 'nlo_settings.sin'
alpha_power = 3
alphas_power = 0
| Process library 'nlo_eettz_lib': recorded process 'nlo_eettz_p1'
| Integrate: current process library needs compilation
| Process library 'nlo_eettz_lib': compiling ...
| Process library 'nlo_eettz_lib': writing makefile
| Process library 'nlo_eettz_lib': removing old files
| Process library 'nlo_eettz_lib': writing driver
| Process library 'nlo_eettz_lib': creating source code
| Process library 'nlo_eettz_lib': compiling sources
| Process library 'nlo_eettz_lib': linking
| Process library 'nlo_eettz_lib': loading
| Process library 'nlo_eettz_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 8131
| Initializing integration for process nlo_eettz_p1:
| Beam structure: [any particles]
| Beam data (collision):
| e- (mass = 0.0000000E+00 GeV)
| e+ (mass = 0.0000000E+00 GeV)
| sqrts = 1.000000000000E+03 GeV
| Phase space: generating configuration ...
| Phase space: ... success.
| Phase space: writing configuration file 'nlo_eettz_p1.i1.phs'
| Phase space: generating configuration ...
| Phase space: ... success.
| Phase space: writing configuration file 'nlo_eettz_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: [...]
| 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]: 'nlo_eettz_p1'
| Library name = 'nlo_eettz_lib'
| Process index = 1
| Process components:
| 1: 'nlo_eettz_p1_i1': e-, e+ => t, tbar, Z [openloops]
| 2: 'nlo_eettz_p1_i2': e-, e+ => t, tbar, Z, gl [openloops], [real]
| 3: 'nlo_eettz_p1_i3': e-, e+ => t, tbar, Z [openloops], [virtual]
| 4: 'nlo_eettz_p1_i4': e-, e+ => t, tbar, Z [inactive], [subtraction]
| ------------------------------------------------------------------------
| Phase space: 7 channels, 5 dimensions
| Phase space: found 7 channels, collected in 3 groves.
-| Phase space: no equivalences between channels used.
+| Phase space: Using 11 equivalences between channels.
| Phase space: wood
| Phase space: 7 channels, 8 dimensions
| Phase space: found 7 channels, collected in 3 groves.
-| Phase space: no equivalences between channels used.
+| Phase space: Using 11 equivalences between channels.
| Phase space: wood
| Phase space: 7 channels, 5 dimensions
| Phase space: found 7 channels, collected in 3 groves.
-| Phase space: no equivalences between channels used.
+| Phase space: Using 11 equivalences between channels.
| Phase space: wood
Warning: No cuts have been defined.
| Using user-defined general scale.
| Starting integration for process 'nlo_eettz_p1' part 'born'
| Integrate: iterations = 1:100:"gw"
| Integrator: 3 chains, 7 channels, 5 dimensions
+| Integrator: Using VAMP2 channel equivalences
| 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 'nlo_eettz_p1.m1.vg2'.
| VAMP2: set chain: use chained weights.
1 99 4.9357132E+00 5.64E-01 11.42 1.14* 30.10
|-----------------------------------------------------------------------------|
1 99 4.9357132E+00 5.64E-01 11.42 1.14 30.10
|=============================================================================|
| Starting integration for process 'nlo_eettz_p1' part 'real'
| Integrate: iterations = 1:100:"gw"
| Integrator: 3 chains, 7 channels, 8 dimensions
+| Integrator: Using VAMP2 channel equivalences
| 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 'nlo_eettz_p1.m2.vg2'.
| VAMP2: set chain: use chained weights.
1 100 -1.0739389E+00 1.17E-01 10.89 1.09* 33.33
|-----------------------------------------------------------------------------|
1 100 -1.0739389E+00 1.17E-01 10.89 1.09 33.33
|=============================================================================|
| Starting integration for process 'nlo_eettz_p1' part 'virtual'
| Integrate: iterations = 1:100:"gw"
| Integrator: 3 chains, 7 channels, 5 dimensions
+| Integrator: Using VAMP2 channel equivalences
| 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 'nlo_eettz_p1.m3.vg2'.
| VAMP2: set chain: use chained weights.
1 100 1.2315981E+00 1.19E-01 9.66 0.97* 31.96
|-----------------------------------------------------------------------------|
1 100 1.2315981E+00 1.19E-01 9.66 0.97 31.96
|=============================================================================|
| Integrate: sum of all components
|=============================================================================|
| It Calls Integral[fb] Error[fb] Err[%] Acc Eff[%] Chi2 N[It] |
|=============================================================================|
1 0 5.0933723E+00 5.88E-01 11.54 0.00* 25.15
| NLO Correction: [O(alpha_s+1)/O(alpha_s)]
| ( 3.1943 +- 3.40114 ) %
|=============================================================================|
| There were no errors and 1 warning(s).
| WHIZARD run finished.
|=============================================================================|
Index: trunk/share/tests/ext_tests_nlo/ref-output/nlo_eetthjj.ref
===================================================================
--- trunk/share/tests/ext_tests_nlo/ref-output/nlo_eetthjj.ref (revision 8482)
+++ trunk/share/tests/ext_tests_nlo/ref-output/nlo_eetthjj.ref (revision 8483)
@@ -1,166 +1,168 @@
?openmp_logging = false
?vis_history = false
?integration_timer = false
openmp_num_threads = 1
?debug_decay = false
?debug_process = false
?debug_verbose = false
?write_raw = false
| Switching to model 'SM', scheme 'GF_MW_MZ'
$blha_ew_scheme = "alpha_qed"
SM.mZ => 9.118800000000E+01
SM.mW => 8.041900200000E+01
SM.mH => 1.250000000000E+02
SM.GF => 1.166390000000E-05
SM.wZ => 0.000000000000E+00
SM.wtop => 0.000000000000E+00
SM.wW => 0.000000000000E+00
SM.wH => 0.000000000000E+00
SM.ms => 0.000000000000E+00
SM.mc => 0.000000000000E+00
SM.mb => 0.000000000000E+00
SM.mtop => 1.732000000000E+02
SM.me => 0.000000000000E+00
SM.mmu => 0.000000000000E+00
SM.mtau => 1.777000000000E+00
SM.alphas => 1.180000000000E-01
?alphas_is_fixed = false
?alphas_from_mz = true
?alphas_from_lambda_qcd = false
alphas_nf = 5
alphas_order = 2
[user variable] jet = PDG(2, -2, 1, -1, 3, -3, 4, -4, 5, -5, 21)
$exclude_gauge_splittings = "t"
$method = "openloops"
seed = 8131
sqrts = 1.000000000000E+03
jet_algorithm = 2
jet_r = 5.000000000000E-01
-?use_vamp_equivalences = false
$integration_method = "vamp2"
$rng_method = "rng_stream"
| End of included 'nlo_settings.sin'
alpha_power = 3
alphas_power = 2
| Process library 'nlo_eetthjj_lib': recorded process 'nlo_eetthjj_p1'
| Integrate: current process library needs compilation
| Process library 'nlo_eetthjj_lib': compiling ...
| Process library 'nlo_eetthjj_lib': writing makefile
| Process library 'nlo_eetthjj_lib': removing old files
| Process library 'nlo_eetthjj_lib': writing driver
| Process library 'nlo_eetthjj_lib': creating source code
| Process library 'nlo_eetthjj_lib': compiling sources
| Process library 'nlo_eetthjj_lib': linking
| Process library 'nlo_eetthjj_lib': loading
| Process library 'nlo_eetthjj_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 8131
| Initializing integration for process nlo_eetthjj_p1:
| Beam structure: [any particles]
| Beam data (collision):
| e- (mass = 0.0000000E+00 GeV)
| e+ (mass = 0.0000000E+00 GeV)
| sqrts = 1.000000000000E+03 GeV
| Phase space: generating configuration ...
Warning: Intermediate decay of zero-width particle Z may be possible.
Warning: Intermediate decay of zero-width particle H may be possible.
| Phase space: ... success.
| Phase space: writing configuration file 'nlo_eetthjj_p1.i1.phs'
| Phase space: generating configuration ...
| Phase space: ... success.
| Phase space: writing configuration file 'nlo_eetthjj_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: [...]
| 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]: 'nlo_eetthjj_p1'
| Library name = 'nlo_eetthjj_lib'
| Process index = 1
| Process components:
| 1: 'nlo_eetthjj_p1_i1': e-, e+ => t, tbar, H, u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl, u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl [openloops]
| 2: 'nlo_eetthjj_p1_i2': e-, e+ => t, tbar, H, d:dbar:u:ubar:s:sbar:c:cbar:b:bbar:gl, d:dbar:u:ubar:s:sbar:c:cbar:b:bbar:gl, d:dbar:u:ubar:s:sbar:c:cbar:b:bbar:gl [openloops], [real]
| 3: 'nlo_eetthjj_p1_i3': e-, e+ => t, tbar, H, u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl, u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl [openloops], [virtual]
| 4: 'nlo_eetthjj_p1_i4': e-, e+ => t, tbar, H, u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl, u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl [inactive], [subtraction]
| ------------------------------------------------------------------------
| Phase space: 38 channels, 11 dimensions
| Phase space: found 38 channels, collected in 2 groves.
-| Phase space: no equivalences between channels used.
+| Phase space: Using 46 equivalences between channels.
| Phase space: wood
| Phase space: 38 channels, 14 dimensions
| Phase space: found 38 channels, collected in 2 groves.
-| Phase space: no equivalences between channels used.
+| Phase space: Using 46 equivalences between channels.
| Phase space: wood
| Phase space: 38 channels, 11 dimensions
| Phase space: found 38 channels, collected in 2 groves.
-| Phase space: no equivalences between channels used.
+| Phase space: Using 46 equivalences between channels.
| Phase space: wood
| Applying user-defined cuts.
| Using user-defined general scale.
| Starting integration for process 'nlo_eetthjj_p1' part 'born'
| Integrate: iterations = 1:380:"gw"
| Integrator: 2 chains, 38 channels, 11 dimensions
+| Integrator: Using VAMP2 channel equivalences
| Integrator: 380 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 'nlo_eetthjj_p1.m1.vg2'.
| VAMP2: set chain: use chained weights.
1 380 3.7100749E-02 1.38E-02 37.19 7.25* 12.21
|-----------------------------------------------------------------------------|
1 380 3.7100749E-02 1.38E-02 37.19 7.25 12.21
|=============================================================================|
| Starting integration for process 'nlo_eetthjj_p1' part 'real'
| Integrate: iterations = 1:380:"gw"
| Integrator: 2 chains, 38 channels, 14 dimensions
+| Integrator: Using VAMP2 channel equivalences
| Integrator: 380 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 'nlo_eetthjj_p1.m2.vg2'.
| VAMP2: set chain: use chained weights.
1 380 -1.9179941E-02 3.91E-02 203.68 39.70* 10.17
|-----------------------------------------------------------------------------|
1 380 -1.9179941E-02 3.91E-02 203.68 39.70 10.17
|=============================================================================|
| Starting integration for process 'nlo_eetthjj_p1' part 'virtual'
| Integrate: iterations = 1:380:"gw"
| Integrator: 2 chains, 38 channels, 11 dimensions
+| Integrator: Using VAMP2 channel equivalences
| Integrator: 380 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 'nlo_eetthjj_p1.m3.vg2'.
| VAMP2: set chain: use chained weights.
1 380 1.2177497E-03 1.19E-03 97.87 19.08* 11.70
|-----------------------------------------------------------------------------|
1 380 1.2177497E-03 1.19E-03 97.87 19.08 11.70
|=============================================================================|
| Integrate: sum of all components
|=============================================================================|
| It Calls Integral[fb] Error[fb] Err[%] Acc Eff[%] Chi2 N[It] |
|=============================================================================|
1 0 1.9138558E-02 4.14E-02 216.57 0.00* 6.09
| NLO Correction: [O(alpha_s+1)/O(alpha_s)]
| (-48.4146 +- 106.87174 ) %
|=============================================================================|
| There were no errors and 2 warning(s).
| WHIZARD run finished.
|=============================================================================|
Index: trunk/share/tests/ext_tests_nlo/ref-output/nlo_pptttt.ref
===================================================================
--- trunk/share/tests/ext_tests_nlo/ref-output/nlo_pptttt.ref (revision 8482)
+++ trunk/share/tests/ext_tests_nlo/ref-output/nlo_pptttt.ref (revision 8483)
@@ -1,199 +1,201 @@
?openmp_logging = false
?vis_history = false
?integration_timer = false
openmp_num_threads = 1
?debug_decay = false
?debug_process = false
?debug_verbose = false
?write_raw = false
| Switching to model 'SM', scheme 'GF_MW_MZ'
$blha_ew_scheme = "alpha_qed"
SM.mZ => 9.118800000000E+01
SM.mW => 8.041900200000E+01
SM.mH => 1.250000000000E+02
SM.GF => 1.166390000000E-05
SM.wZ => 0.000000000000E+00
SM.wtop => 0.000000000000E+00
SM.wW => 0.000000000000E+00
SM.wH => 0.000000000000E+00
SM.ms => 0.000000000000E+00
SM.mc => 0.000000000000E+00
SM.mb => 0.000000000000E+00
SM.mtop => 1.732000000000E+02
SM.me => 0.000000000000E+00
SM.mmu => 0.000000000000E+00
SM.mtau => 1.777000000000E+00
SM.alphas => 1.180000000000E-01
?alphas_is_fixed = false
?alphas_from_mz = true
?alphas_from_lambda_qcd = false
alphas_nf = 5
alphas_order = 2
[user variable] jet = PDG(2, -2, 1, -1, 3, -3, 4, -4, 5, -5, 21)
$exclude_gauge_splittings = "t"
$method = "openloops"
seed = 8131
sqrts = 1.000000000000E+03
jet_algorithm = 2
jet_r = 5.000000000000E-01
-?use_vamp_equivalences = false
$integration_method = "vamp2"
$rng_method = "rng_stream"
| End of included 'nlo_settings.sin'
[user variable] pr = PDG(2, -2, 1, -1, 3, -3, 4, -4, 5, -5, 21)
$exclude_gauge_splittings = "t"
$lhapdf_file = "MSTW2008nlo68cl"
sqrts = 1.300000000000E+04
alpha_power = 0
alphas_power = 4
?alphas_from_mz = false
?alphas_from_lhapdf = true
?combined_nlo_integration = false
-?use_vamp_equivalences = false
| Process library 'nlo_pptttt_lib': recorded process 'nlo_pptttt_p1'
| Integrate: current process library needs compilation
| Process library 'nlo_pptttt_lib': compiling ...
| Process library 'nlo_pptttt_lib': writing makefile
| Process library 'nlo_pptttt_lib': removing old files
| Process library 'nlo_pptttt_lib': writing driver
| Process library 'nlo_pptttt_lib': creating source code
| Process library 'nlo_pptttt_lib': compiling sources
| Process library 'nlo_pptttt_lib': linking
| Process library 'nlo_pptttt_lib': loading
| Process library 'nlo_pptttt_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 8131
| Initializing integration for process nlo_pptttt_p1:
| Beam structure: p, p => lhapdf
| Beam data (collision):
| p (mass = 0.0000000E+00 GeV)
| p (mass = 0.0000000E+00 GeV)
| sqrts = 1.300000000000E+04 GeV
| Phase space: generating configuration ...
| Phase space: ... failed. Increasing phs_off_shell ...
| Phase space: ... success.
| Phase space: writing configuration file 'nlo_pptttt_p1.i1.phs'
| Phase space: generating configuration ...
| Phase space: ... failed. Increasing phs_off_shell ...
| Phase space: ... success.
| Phase space: writing configuration file 'nlo_pptttt_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: [...]
| 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: [...]
| One-Loop-Provider: Using OpenLoops
| Loading library: [...]
| One-Loop-Provider: Using OpenLoops
| Loading library: [...]
| ------------------------------------------------------------------------
| Process [scattering]: 'nlo_pptttt_p1'
| Library name = 'nlo_pptttt_lib'
| Process index = 1
| Process components:
| 1: 'nlo_pptttt_p1_i1': u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl, u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl => t, tbar, t, tbar [openloops]
| 2: 'nlo_pptttt_p1_i2': dbar:d:ubar:u:sbar:s:cbar:c:bbar:b:gl, dbar:d:ubar:u:sbar:s:cbar:c:bbar:b:gl => t, tbar, t, tbar, d:dbar:u:ubar:s:sbar:c:cbar:b:bbar:gl [openloops], [real]
| 3: 'nlo_pptttt_p1_i3': u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl, u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl => t, tbar, t, tbar [openloops], [virtual]
| 4: 'nlo_pptttt_p1_i4': u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl, u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl => t, tbar, t, tbar [inactive], [subtraction]
| 5: 'nlo_pptttt_p1_i5': u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl, u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl => t, tbar, t, tbar [openloops], [dglap]
| ------------------------------------------------------------------------
| Phase space: 128 channels, 8 dimensions
| Phase space: found 128 channels, collected in 4 groves.
-| Phase space: no equivalences between channels used.
+| Phase space: Using 672 equivalences between channels.
| Phase space: wood
| Phase space: 128 channels, 11 dimensions
| Phase space: found 128 channels, collected in 4 groves.
-| Phase space: no equivalences between channels used.
+| Phase space: Using 672 equivalences between channels.
| Phase space: wood
| Phase space: 128 channels, 8 dimensions
| Phase space: found 128 channels, collected in 4 groves.
-| Phase space: no equivalences between channels used.
+| Phase space: Using 672 equivalences between channels.
| Phase space: wood
| Phase space: 128 channels, 9 dimensions
| Phase space: found 128 channels, collected in 4 groves.
-| Phase space: no equivalences between channels used.
+| Phase space: Using 672 equivalences between channels.
| Phase space: wood
| Beam structure: lhapdf, none => none, lhapdf
| Beam structure: 1 channels, 2 dimensions
Warning: No cuts have been defined.
| Using user-defined general scale.
| Starting integration for process 'nlo_pptttt_p1' part 'born'
| Integrate: iterations = 1:2000:"gw"
| Integrator: 4 chains, 128 channels, 10 dimensions
+| Integrator: Using VAMP2 channel equivalences
| Integrator: 2000 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 'nlo_pptttt_p1.m1.vg2'.
| VAMP2: set chain: use chained weights.
1 1984 7.3169590E+00 3.56E+00 48.70 21.69* 6.96
|-----------------------------------------------------------------------------|
1 1984 7.3169590E+00 3.56E+00 48.70 21.69 6.96
|=============================================================================|
| Starting integration for process 'nlo_pptttt_p1' part 'real'
| Integrate: iterations = 1:2000:"gw"
| Integrator: 4 chains, 128 channels, 13 dimensions
+| Integrator: Using VAMP2 channel equivalences
| Integrator: 2000 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 'nlo_pptttt_p1.m2.vg2'.
| VAMP2: set chain: use chained weights.
1 1992 1.2530138E-01 4.52E-01 360.86 161.06* 6.57
|-----------------------------------------------------------------------------|
1 1992 1.2530138E-01 4.52E-01 360.86 161.06 6.57
|=============================================================================|
| Starting integration for process 'nlo_pptttt_p1' part 'virtual'
| Integrate: iterations = 1:2000:"gw"
| Integrator: 4 chains, 128 channels, 10 dimensions
+| Integrator: Using VAMP2 channel equivalences
| Integrator: 2000 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 'nlo_pptttt_p1.m3.vg2'.
| VAMP2: set chain: use chained weights.
1 2000 5.4971119E+00 1.46E+00 26.47 11.84* 6.76
|-----------------------------------------------------------------------------|
1 2000 5.4971119E+00 1.46E+00 26.47 11.84 6.76
|=============================================================================|
| Starting integration for process 'nlo_pptttt_p1' part 'dglap'
| Integrate: iterations = 1:2000:"gw"
| Integrator: 4 chains, 128 channels, 11 dimensions
+| Integrator: Using VAMP2 channel equivalences
| Integrator: 2000 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 'nlo_pptttt_p1.m4.vg2'.
| VAMP2: set chain: use chained weights.
1 1976 1.9642699E+00 1.07E+00 54.45 24.21* 6.77
|-----------------------------------------------------------------------------|
1 1976 1.9642699E+00 1.07E+00 54.45 24.21 6.77
|=============================================================================|
| Integrate: sum of all components
|=============================================================================|
| It Calls Integral[fb] Error[fb] Err[%] Acc Eff[%] Chi2 N[It] |
|=============================================================================|
1 0 1.4903642E+01 4.02E+00 26.98 0.00* 6.85
| NLO Correction: [O(alpha_s+1)/O(alpha_s)]
| (103.6863 +- 56.54290 ) %
|=============================================================================|
| There were no errors and 1 warning(s).
| WHIZARD run finished.
|=============================================================================|
Index: trunk/share/tests/ext_tests_nlo/ref-output/nlo_eettjjj.ref
===================================================================
--- trunk/share/tests/ext_tests_nlo/ref-output/nlo_eettjjj.ref (revision 8482)
+++ trunk/share/tests/ext_tests_nlo/ref-output/nlo_eettjjj.ref (revision 8483)
@@ -1,166 +1,168 @@
?openmp_logging = false
?vis_history = false
?integration_timer = false
openmp_num_threads = 1
?debug_decay = false
?debug_process = false
?debug_verbose = false
?write_raw = false
| Switching to model 'SM', scheme 'GF_MW_MZ'
$blha_ew_scheme = "alpha_qed"
SM.mZ => 9.118800000000E+01
SM.mW => 8.041900200000E+01
SM.mH => 1.250000000000E+02
SM.GF => 1.166390000000E-05
SM.wZ => 0.000000000000E+00
SM.wtop => 0.000000000000E+00
SM.wW => 0.000000000000E+00
SM.wH => 0.000000000000E+00
SM.ms => 0.000000000000E+00
SM.mc => 0.000000000000E+00
SM.mb => 0.000000000000E+00
SM.mtop => 1.732000000000E+02
SM.me => 0.000000000000E+00
SM.mmu => 0.000000000000E+00
SM.mtau => 1.777000000000E+00
SM.alphas => 1.180000000000E-01
?alphas_is_fixed = false
?alphas_from_mz = true
?alphas_from_lambda_qcd = false
alphas_nf = 5
alphas_order = 2
[user variable] jet = PDG(2, -2, 1, -1, 3, -3, 4, -4, 5, -5, 21)
$exclude_gauge_splittings = "t"
$method = "openloops"
seed = 8131
sqrts = 1.000000000000E+03
jet_algorithm = 2
jet_r = 5.000000000000E-01
-?use_vamp_equivalences = false
$integration_method = "vamp2"
$rng_method = "rng_stream"
| End of included 'nlo_settings.sin'
alpha_power = 2
alphas_power = 3
| Process library 'nlo_eettjjj_lib': recorded process 'nlo_eettjjj_p1'
| Integrate: current process library needs compilation
| Process library 'nlo_eettjjj_lib': compiling ...
| Process library 'nlo_eettjjj_lib': writing makefile
| Process library 'nlo_eettjjj_lib': removing old files
| Process library 'nlo_eettjjj_lib': writing driver
| Process library 'nlo_eettjjj_lib': creating source code
| Process library 'nlo_eettjjj_lib': compiling sources
| Process library 'nlo_eettjjj_lib': linking
| Process library 'nlo_eettjjj_lib': loading
| Process library 'nlo_eettjjj_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 8131
| Initializing integration for process nlo_eettjjj_p1:
| Beam structure: [any particles]
| Beam data (collision):
| e- (mass = 0.0000000E+00 GeV)
| e+ (mass = 0.0000000E+00 GeV)
| sqrts = 1.000000000000E+03 GeV
| Phase space: generating configuration ...
Warning: Intermediate decay of zero-width particle Z may be possible.
Warning: Intermediate decay of zero-width particle H may be possible.
| Phase space: ... success.
| Phase space: writing configuration file 'nlo_eettjjj_p1.i1.phs'
| Phase space: generating configuration ...
| Phase space: ... success.
| Phase space: writing configuration file 'nlo_eettjjj_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: [...]
| 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]: 'nlo_eettjjj_p1'
| Library name = 'nlo_eettjjj_lib'
| Process index = 1
| Process components:
| 1: 'nlo_eettjjj_p1_i1': e-, e+ => t, tbar, u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl, u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl, u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl [openloops]
| 2: 'nlo_eettjjj_p1_i2': e-, e+ => t, tbar, d:dbar:u:ubar:s:sbar:c:cbar:b:bbar:gl, d:dbar:u:ubar:s:sbar:c:cbar:b:bbar:gl, d:dbar:u:ubar:s:sbar:c:cbar:b:bbar:gl, d:dbar:u:ubar:s:sbar:c:cbar:b:bbar:gl [openloops], [real]
| 3: 'nlo_eettjjj_p1_i3': e-, e+ => t, tbar, u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl, u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl, u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl [openloops], [virtual]
| 4: 'nlo_eettjjj_p1_i4': e-, e+ => t, tbar, u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl, u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl, u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl [inactive], [subtraction]
| ------------------------------------------------------------------------
| Phase space: 78 channels, 11 dimensions
| Phase space: found 78 channels, collected in 5 groves.
-| Phase space: no equivalences between channels used.
+| Phase space: Using 94 equivalences between channels.
| Phase space: wood
| Phase space: 78 channels, 14 dimensions
| Phase space: found 78 channels, collected in 5 groves.
-| Phase space: no equivalences between channels used.
+| Phase space: Using 94 equivalences between channels.
| Phase space: wood
| Phase space: 78 channels, 11 dimensions
| Phase space: found 78 channels, collected in 5 groves.
-| Phase space: no equivalences between channels used.
+| Phase space: Using 94 equivalences between channels.
| Phase space: wood
| Applying user-defined cuts.
| Using user-defined general scale.
| Starting integration for process 'nlo_eettjjj_p1' part 'born'
| Integrate: iterations = 1:780:"gw"
| Integrator: 5 chains, 78 channels, 11 dimensions
+| Integrator: Using VAMP2 channel equivalences
| Integrator: 780 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 'nlo_eettjjj_p1.m1.vg2'.
| VAMP2: set chain: use chained weights.
1 812 2.4856807E+00 1.74E+00 69.90 19.92* 10.65
|-----------------------------------------------------------------------------|
1 812 2.4856807E+00 1.74E+00 69.90 19.92 10.65
|=============================================================================|
| Starting integration for process 'nlo_eettjjj_p1' part 'real'
| Integrate: iterations = 1:780:"gw"
| Integrator: 5 chains, 78 channels, 14 dimensions
+| Integrator: Using VAMP2 channel equivalences
| Integrator: 780 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 'nlo_eettjjj_p1.m2.vg2'.
| VAMP2: set chain: use chained weights.
1 836 1.7244363E-01 1.91E-01 110.52 31.95* 10.09
|-----------------------------------------------------------------------------|
1 836 1.7244363E-01 1.91E-01 110.52 31.95 10.09
|=============================================================================|
| Starting integration for process 'nlo_eettjjj_p1' part 'virtual'
| Integrate: iterations = 1:780:"gw"
| Integrator: 5 chains, 78 channels, 11 dimensions
+| Integrator: Using VAMP2 channel equivalences
| Integrator: 780 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 'nlo_eettjjj_p1.m3.vg2'.
| VAMP2: set chain: use chained weights.
1 812 3.7292135E-02 3.13E-02 84.06 23.95* 12.14
|-----------------------------------------------------------------------------|
1 812 3.7292135E-02 3.13E-02 84.06 23.95 12.14
|=============================================================================|
| Integrate: sum of all components
|=============================================================================|
| It Calls Integral[fb] Error[fb] Err[%] Acc Eff[%] Chi2 N[It] |
|=============================================================================|
1 0 2.6954165E+00 1.75E+00 64.86 0.00* 10.63
| NLO Correction: [O(alpha_s+1)/O(alpha_s)]
| ( 8.4378 +- 9.75505 ) %
|=============================================================================|
| There were no errors and 2 warning(s).
| WHIZARD run finished.
|=============================================================================|
Index: trunk/share/tests/ext_tests_nlo/ref-output/nlo_ppzw.ref
===================================================================
--- trunk/share/tests/ext_tests_nlo/ref-output/nlo_ppzw.ref (revision 8482)
+++ trunk/share/tests/ext_tests_nlo/ref-output/nlo_ppzw.ref (revision 8483)
@@ -1,197 +1,200 @@
?openmp_logging = false
?vis_history = false
?integration_timer = false
openmp_num_threads = 1
?debug_decay = false
?debug_process = false
?debug_verbose = false
?write_raw = false
| Switching to model 'SM', scheme 'GF_MW_MZ'
$blha_ew_scheme = "alpha_qed"
SM.mZ => 9.118800000000E+01
SM.mW => 8.041900200000E+01
SM.mH => 1.250000000000E+02
SM.GF => 1.166390000000E-05
SM.wZ => 0.000000000000E+00
SM.wtop => 0.000000000000E+00
SM.wW => 0.000000000000E+00
SM.wH => 0.000000000000E+00
SM.ms => 0.000000000000E+00
SM.mc => 0.000000000000E+00
SM.mb => 0.000000000000E+00
SM.mtop => 1.732000000000E+02
SM.me => 0.000000000000E+00
SM.mmu => 0.000000000000E+00
SM.mtau => 1.777000000000E+00
SM.alphas => 1.180000000000E-01
?alphas_is_fixed = false
?alphas_from_mz = true
?alphas_from_lambda_qcd = false
alphas_nf = 5
alphas_order = 2
[user variable] jet = PDG(2, -2, 1, -1, 3, -3, 4, -4, 5, -5, 21)
$exclude_gauge_splittings = "t"
$method = "openloops"
seed = 8131
sqrts = 1.000000000000E+03
jet_algorithm = 2
jet_r = 5.000000000000E-01
-?use_vamp_equivalences = false
$integration_method = "vamp2"
$rng_method = "rng_stream"
| End of included 'nlo_settings.sin'
[user variable] pr = PDG(2, -2, 1, -1, 3, -3, 4, -4, 5, -5, 21)
$exclude_gauge_splittings = "t"
[user variable] Wpm = PDG(24, -24)
$lhapdf_file = "MSTW2008nlo68cl"
sqrts = 1.300000000000E+04
alpha_power = 2
alphas_power = 0
?alphas_from_mz = false
?alphas_from_lhapdf = true
?combined_nlo_integration = false
| Process library 'nlo_ppzw_lib': recorded process 'nlo_ppzw_p1'
| Integrate: current process library needs compilation
| Process library 'nlo_ppzw_lib': compiling ...
| Process library 'nlo_ppzw_lib': writing makefile
| Process library 'nlo_ppzw_lib': removing old files
| Process library 'nlo_ppzw_lib': writing driver
| Process library 'nlo_ppzw_lib': creating source code
| Process library 'nlo_ppzw_lib': compiling sources
| Process library 'nlo_ppzw_lib': linking
| Process library 'nlo_ppzw_lib': loading
| Process library 'nlo_ppzw_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 8131
| Initializing integration for process nlo_ppzw_p1:
| Beam structure: p, p => lhapdf
| Beam data (collision):
| p (mass = 0.0000000E+00 GeV)
| p (mass = 0.0000000E+00 GeV)
| sqrts = 1.300000000000E+04 GeV
| Phase space: generating configuration ...
| Phase space: ... success.
| Phase space: writing configuration file 'nlo_ppzw_p1.i1.phs'
| Phase space: generating configuration ...
| Phase space: ... success.
| Phase space: writing configuration file 'nlo_ppzw_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: [...]
| 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: [...]
| One-Loop-Provider: Using OpenLoops
| Loading library: [...]
| One-Loop-Provider: Using OpenLoops
| Loading library: [...]
| ------------------------------------------------------------------------
| Process [scattering]: 'nlo_ppzw_p1'
| Library name = 'nlo_ppzw_lib'
| Process index = 1
| Process components:
| 1: 'nlo_ppzw_p1_i1': u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl, u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl => Z, W+:W- [openloops]
| 2: 'nlo_ppzw_p1_i2': dbar:d:ubar:u:sbar:s:cbar:c:bbar:b:gl, dbar:d:ubar:u:sbar:s:cbar:c:bbar:b:gl => Z, W+:W-, d:dbar:u:ubar:s:sbar:c:cbar:b:bbar:gl [openloops], [real]
| 3: 'nlo_ppzw_p1_i3': u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl, u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl => Z, W+:W- [openloops], [virtual]
| 4: 'nlo_ppzw_p1_i4': u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl, u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl => Z, W+:W- [inactive], [subtraction]
| 5: 'nlo_ppzw_p1_i5': u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl, u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl => Z, W+:W- [openloops], [dglap]
| ------------------------------------------------------------------------
| Phase space: 5 channels, 2 dimensions
| Phase space: found 5 channels, collected in 3 groves.
-| Phase space: no equivalences between channels used.
+| Phase space: Using 5 equivalences between channels.
| Phase space: wood
| Phase space: 5 channels, 5 dimensions
| Phase space: found 5 channels, collected in 3 groves.
-| Phase space: no equivalences between channels used.
+| Phase space: Using 5 equivalences between channels.
| Phase space: wood
| Phase space: 5 channels, 2 dimensions
| Phase space: found 5 channels, collected in 3 groves.
-| Phase space: no equivalences between channels used.
+| Phase space: Using 5 equivalences between channels.
| Phase space: wood
| Phase space: 5 channels, 3 dimensions
| Phase space: found 5 channels, collected in 3 groves.
-| Phase space: no equivalences between channels used.
+| Phase space: Using 5 equivalences between channels.
| Phase space: wood
| Beam structure: lhapdf, none => none, lhapdf
| Beam structure: 1 channels, 2 dimensions
Warning: No cuts have been defined.
| Using user-defined general scale.
| Starting integration for process 'nlo_ppzw_p1' part 'born'
| Integrate: iterations = 1:500:"gw"
| Integrator: 3 chains, 5 channels, 4 dimensions
+| Integrator: Using VAMP2 channel equivalences
| Integrator: 500 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 'nlo_ppzw_p1.m1.vg2'.
| VAMP2: set chain: use chained weights.
1 448 2.2318426E+04 9.44E+03 42.30 8.95* 1.61
|-----------------------------------------------------------------------------|
1 448 2.2318426E+04 9.44E+03 42.30 8.95 1.61
|=============================================================================|
| Starting integration for process 'nlo_ppzw_p1' part 'real'
| Integrate: iterations = 1:500:"gw"
| Integrator: 3 chains, 5 channels, 7 dimensions
+| Integrator: Using VAMP2 channel equivalences
| Integrator: 500 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 'nlo_ppzw_p1.m2.vg2'.
| VAMP2: set chain: use chained weights.
1 500 7.4808395E+03 5.59E+03 74.76 16.72* 1.58
|-----------------------------------------------------------------------------|
1 500 7.4808395E+03 5.59E+03 74.76 16.72 1.58
|=============================================================================|
| Starting integration for process 'nlo_ppzw_p1' part 'virtual'
| Integrate: iterations = 1:500:"gw"
| Integrator: 3 chains, 5 channels, 4 dimensions
+| Integrator: Using VAMP2 channel equivalences
| Integrator: 500 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 'nlo_ppzw_p1.m3.vg2'.
| VAMP2: set chain: use chained weights.
1 478 7.1479170E+03 2.34E+03 32.73 7.16* 2.24
|-----------------------------------------------------------------------------|
1 478 7.1479170E+03 2.34E+03 32.73 7.16 2.24
|=============================================================================|
| Starting integration for process 'nlo_ppzw_p1' part 'dglap'
| Integrate: iterations = 1:500:"gw"
| Integrator: 3 chains, 5 channels, 5 dimensions
+| Integrator: Using VAMP2 channel equivalences
| Integrator: 500 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 'nlo_ppzw_p1.m4.vg2'.
| VAMP2: set chain: use chained weights.
1 416 9.3555985E+02 6.77E+02 72.34 14.75* 2.14
|-----------------------------------------------------------------------------|
1 416 9.3555985E+02 6.77E+02 72.34 14.75 2.14
|=============================================================================|
| Integrate: sum of all components
|=============================================================================|
| It Calls Integral[fb] Error[fb] Err[%] Acc Eff[%] Chi2 N[It] |
|=============================================================================|
1 0 3.7882742E+04 1.12E+04 29.67 0.00* 1.70
| NLO Correction: [O(alpha_s+1)/O(alpha_s)]
| ( 69.7375 +- 40.21210 ) %
|=============================================================================|
| There were no errors and 1 warning(s).
| WHIZARD run finished.
|=============================================================================|
Index: trunk/share/tests/ext_tests_nlo/ref-output/nlo_ee4t.ref
===================================================================
--- trunk/share/tests/ext_tests_nlo/ref-output/nlo_ee4t.ref (revision 8482)
+++ trunk/share/tests/ext_tests_nlo/ref-output/nlo_ee4t.ref (revision 8483)
@@ -1,166 +1,168 @@
?openmp_logging = false
?vis_history = false
?integration_timer = false
openmp_num_threads = 1
?debug_decay = false
?debug_process = false
?debug_verbose = false
?write_raw = false
| Switching to model 'SM', scheme 'GF_MW_MZ'
$blha_ew_scheme = "alpha_qed"
SM.mZ => 9.118800000000E+01
SM.mW => 8.041900200000E+01
SM.mH => 1.250000000000E+02
SM.GF => 1.166390000000E-05
SM.wZ => 0.000000000000E+00
SM.wtop => 0.000000000000E+00
SM.wW => 0.000000000000E+00
SM.wH => 0.000000000000E+00
SM.ms => 0.000000000000E+00
SM.mc => 0.000000000000E+00
SM.mb => 0.000000000000E+00
SM.mtop => 1.732000000000E+02
SM.me => 0.000000000000E+00
SM.mmu => 0.000000000000E+00
SM.mtau => 1.777000000000E+00
SM.alphas => 1.180000000000E-01
?alphas_is_fixed = false
?alphas_from_mz = true
?alphas_from_lambda_qcd = false
alphas_nf = 5
alphas_order = 2
[user variable] jet = PDG(2, -2, 1, -1, 3, -3, 4, -4, 5, -5, 21)
$exclude_gauge_splittings = "t"
$method = "openloops"
seed = 8131
sqrts = 1.000000000000E+03
jet_algorithm = 2
jet_r = 5.000000000000E-01
-?use_vamp_equivalences = false
$integration_method = "vamp2"
$rng_method = "rng_stream"
| End of included 'nlo_settings.sin'
alpha_power = 2
alphas_power = 2
| Process library 'nlo_ee4t_lib': recorded process 'nlo_ee4t_p1'
| Integrate: current process library needs compilation
| Process library 'nlo_ee4t_lib': compiling ...
| Process library 'nlo_ee4t_lib': writing makefile
| Process library 'nlo_ee4t_lib': removing old files
| Process library 'nlo_ee4t_lib': writing driver
| Process library 'nlo_ee4t_lib': creating source code
| Process library 'nlo_ee4t_lib': compiling sources
| Process library 'nlo_ee4t_lib': linking
| Process library 'nlo_ee4t_lib': loading
| Process library 'nlo_ee4t_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 8131
| Initializing integration for process nlo_ee4t_p1:
| Beam structure: [any particles]
| Beam data (collision):
| e- (mass = 0.0000000E+00 GeV)
| e+ (mass = 0.0000000E+00 GeV)
| sqrts = 1.000000000000E+03 GeV
| Phase space: generating configuration ...
| Phase space: ... failed. Increasing phs_off_shell ...
| Phase space: ... success.
| Phase space: writing configuration file 'nlo_ee4t_p1.i1.phs'
| Phase space: generating configuration ...
| Phase space: ... failed. Increasing phs_off_shell ...
| Phase space: ... success.
| Phase space: writing configuration file 'nlo_ee4t_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: [...]
| 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]: 'nlo_ee4t_p1'
| Library name = 'nlo_ee4t_lib'
| Process index = 1
| Process components:
| 1: 'nlo_ee4t_p1_i1': e-, e+ => t, tbar, t, tbar [openloops]
| 2: 'nlo_ee4t_p1_i2': e-, e+ => t, tbar, t, tbar, gl [openloops], [real]
| 3: 'nlo_ee4t_p1_i3': e-, e+ => t, tbar, t, tbar [openloops], [virtual]
| 4: 'nlo_ee4t_p1_i4': e-, e+ => t, tbar, t, tbar [inactive], [subtraction]
| ------------------------------------------------------------------------
| Phase space: 16 channels, 8 dimensions
| Phase space: found 16 channels, collected in 2 groves.
-| Phase space: no equivalences between channels used.
+| Phase space: Using 96 equivalences between channels.
| Phase space: wood
| Phase space: 16 channels, 11 dimensions
| Phase space: found 16 channels, collected in 2 groves.
-| Phase space: no equivalences between channels used.
+| Phase space: Using 96 equivalences between channels.
| Phase space: wood
| Phase space: 16 channels, 8 dimensions
| Phase space: found 16 channels, collected in 2 groves.
-| Phase space: no equivalences between channels used.
+| Phase space: Using 96 equivalences between channels.
| Phase space: wood
Warning: No cuts have been defined.
| Using user-defined general scale.
| Starting integration for process 'nlo_ee4t_p1' part 'born'
| Integrate: iterations = 1:160:"gw"
| Integrator: 2 chains, 16 channels, 8 dimensions
+| Integrator: Using VAMP2 channel equivalences
| Integrator: 160 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 'nlo_ee4t_p1.m1.vg2'.
| VAMP2: set chain: use chained weights.
1 160 6.3704751E-04 7.16E-05 11.24 1.42* 28.70
|-----------------------------------------------------------------------------|
1 160 6.3704751E-04 7.16E-05 11.24 1.42 28.70
|=============================================================================|
| Starting integration for process 'nlo_ee4t_p1' part 'real'
| Integrate: iterations = 1:160:"gw"
| Integrator: 2 chains, 16 channels, 11 dimensions
+| Integrator: Using VAMP2 channel equivalences
| Integrator: 160 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 'nlo_ee4t_p1.m2.vg2'.
| VAMP2: set chain: use chained weights.
1 160 -2.0914858E-04 2.29E-05 10.94 1.38* 29.07
|-----------------------------------------------------------------------------|
1 160 -2.0914858E-04 2.29E-05 10.94 1.38 29.07
|=============================================================================|
| Starting integration for process 'nlo_ee4t_p1' part 'virtual'
| Integrate: iterations = 1:160:"gw"
| Integrator: 2 chains, 16 channels, 8 dimensions
+| Integrator: Using VAMP2 channel equivalences
| Integrator: 160 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 'nlo_ee4t_p1.m3.vg2'.
| VAMP2: set chain: use chained weights.
1 160 7.0389404E-04 7.85E-05 11.15 1.41* 28.03
|-----------------------------------------------------------------------------|
1 160 7.0389404E-04 7.85E-05 11.15 1.41 28.03
|=============================================================================|
| Integrate: sum of all components
|=============================================================================|
| It Calls Integral[fb] Error[fb] Err[%] Acc Eff[%] Chi2 N[It] |
|=============================================================================|
1 0 1.1317930E-03 1.09E-04 9.60 0.00* 23.92
| NLO Correction: [O(alpha_s+1)/O(alpha_s)]
| ( 77.6623 +- 15.52148 ) %
|=============================================================================|
| There were no errors and 1 warning(s).
| WHIZARD run finished.
|=============================================================================|
Index: trunk/share/tests/ext_tests_nlo/ref-output/nlo_eett.ref
===================================================================
--- trunk/share/tests/ext_tests_nlo/ref-output/nlo_eett.ref (revision 8482)
+++ trunk/share/tests/ext_tests_nlo/ref-output/nlo_eett.ref (revision 8483)
@@ -1,164 +1,166 @@
?openmp_logging = false
?vis_history = false
?integration_timer = false
openmp_num_threads = 1
?debug_decay = false
?debug_process = false
?debug_verbose = false
?write_raw = false
| Switching to model 'SM', scheme 'GF_MW_MZ'
$blha_ew_scheme = "alpha_qed"
SM.mZ => 9.118800000000E+01
SM.mW => 8.041900200000E+01
SM.mH => 1.250000000000E+02
SM.GF => 1.166390000000E-05
SM.wZ => 0.000000000000E+00
SM.wtop => 0.000000000000E+00
SM.wW => 0.000000000000E+00
SM.wH => 0.000000000000E+00
SM.ms => 0.000000000000E+00
SM.mc => 0.000000000000E+00
SM.mb => 0.000000000000E+00
SM.mtop => 1.732000000000E+02
SM.me => 0.000000000000E+00
SM.mmu => 0.000000000000E+00
SM.mtau => 1.777000000000E+00
SM.alphas => 1.180000000000E-01
?alphas_is_fixed = false
?alphas_from_mz = true
?alphas_from_lambda_qcd = false
alphas_nf = 5
alphas_order = 2
[user variable] jet = PDG(2, -2, 1, -1, 3, -3, 4, -4, 5, -5, 21)
$exclude_gauge_splittings = "t"
$method = "openloops"
seed = 8131
sqrts = 1.000000000000E+03
jet_algorithm = 2
jet_r = 5.000000000000E-01
-?use_vamp_equivalences = false
$integration_method = "vamp2"
$rng_method = "rng_stream"
| End of included 'nlo_settings.sin'
alpha_power = 2
alphas_power = 0
| Process library 'nlo_eett_lib': recorded process 'nlo_eett_p1'
| Integrate: current process library needs compilation
| Process library 'nlo_eett_lib': compiling ...
| Process library 'nlo_eett_lib': writing makefile
| Process library 'nlo_eett_lib': removing old files
| Process library 'nlo_eett_lib': writing driver
| Process library 'nlo_eett_lib': creating source code
| Process library 'nlo_eett_lib': compiling sources
| Process library 'nlo_eett_lib': linking
| Process library 'nlo_eett_lib': loading
| Process library 'nlo_eett_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 8131
| Initializing integration for process nlo_eett_p1:
| Beam structure: [any particles]
| Beam data (collision):
| e- (mass = 0.0000000E+00 GeV)
| e+ (mass = 0.0000000E+00 GeV)
| sqrts = 1.000000000000E+03 GeV
| Phase space: generating configuration ...
| Phase space: ... success.
| Phase space: writing configuration file 'nlo_eett_p1.i1.phs'
| Phase space: generating configuration ...
| Phase space: ... success.
| Phase space: writing configuration file 'nlo_eett_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: [...]
| 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]: 'nlo_eett_p1'
| Library name = 'nlo_eett_lib'
| Process index = 1
| Process components:
| 1: 'nlo_eett_p1_i1': e-, e+ => t, tbar [openloops]
| 2: 'nlo_eett_p1_i2': e-, e+ => t, tbar, gl [openloops], [real]
| 3: 'nlo_eett_p1_i3': e-, e+ => t, tbar [openloops], [virtual]
| 4: 'nlo_eett_p1_i4': e-, e+ => t, tbar [inactive], [subtraction]
| ------------------------------------------------------------------------
| Phase space: 1 channels, 2 dimensions
| Phase space: found 1 channel, collected in 1 grove.
-| Phase space: no equivalences between channels used.
+| Phase space: Using 1 equivalence between channels.
| Phase space: wood
| Phase space: 1 channels, 5 dimensions
| Phase space: found 1 channel, collected in 1 grove.
-| Phase space: no equivalences between channels used.
+| Phase space: Using 1 equivalence between channels.
| Phase space: wood
| Phase space: 1 channels, 2 dimensions
| Phase space: found 1 channel, collected in 1 grove.
-| Phase space: no equivalences between channels used.
+| Phase space: Using 1 equivalence between channels.
| Phase space: wood
Warning: No cuts have been defined.
| Using user-defined general scale.
| Starting integration for process 'nlo_eett_p1' part 'born'
| Integrate: iterations = 1:100:"gw"
| Integrator: 1 chains, 1 channels, 2 dimensions
+| Integrator: Using VAMP2 channel equivalences
| 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 'nlo_eett_p1.m1.vg2'.
| VAMP2: set chain: use chained weights.
1 98 1.6780255E+02 1.83E+00 1.09 0.11* 41.44
|-----------------------------------------------------------------------------|
1 98 1.6780255E+02 1.83E+00 1.09 0.11 41.44
|=============================================================================|
| Starting integration for process 'nlo_eett_p1' part 'real'
| Integrate: iterations = 1:100:"gw"
| Integrator: 1 chains, 1 channels, 5 dimensions
+| Integrator: Using VAMP2 channel equivalences
| 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 'nlo_eett_p1.m2.vg2'.
| VAMP2: set chain: use chained weights.
1 96 -4.2905273E+01 2.30E+00 5.37 0.53* 30.26
|-----------------------------------------------------------------------------|
1 96 -4.2905273E+01 2.30E+00 5.37 0.53 30.26
|=============================================================================|
| Starting integration for process 'nlo_eett_p1' part 'virtual'
| Integrate: iterations = 1:100:"gw"
| Integrator: 1 chains, 1 channels, 2 dimensions
+| Integrator: Using VAMP2 channel equivalences
| 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 'nlo_eett_p1.m3.vg2'.
| VAMP2: set chain: use chained weights.
1 98 4.8853813E+01 6.76E-01 1.38 0.14* 35.70
|-----------------------------------------------------------------------------|
1 98 4.8853813E+01 6.76E-01 1.38 0.14 35.70
|=============================================================================|
| Integrate: sum of all components
|=============================================================================|
| It Calls Integral[fb] Error[fb] Err[%] Acc Eff[%] Chi2 N[It] |
|=============================================================================|
1 0 1.7375109E+02 3.02E+00 1.74 0.00* 32.07
| NLO Correction: [O(alpha_s+1)/O(alpha_s)]
| ( 3.5450 +- 1.43164 ) %
|=============================================================================|
| There were no errors and 1 warning(s).
| WHIZARD run finished.
|=============================================================================|
Index: trunk/share/tests/ext_tests_nlo/ref-output/nlo_ppzz.ref
===================================================================
--- trunk/share/tests/ext_tests_nlo/ref-output/nlo_ppzz.ref (revision 8482)
+++ trunk/share/tests/ext_tests_nlo/ref-output/nlo_ppzz.ref (revision 8483)
@@ -1,196 +1,199 @@
?openmp_logging = false
?vis_history = false
?integration_timer = false
openmp_num_threads = 1
?debug_decay = false
?debug_process = false
?debug_verbose = false
?write_raw = false
| Switching to model 'SM', scheme 'GF_MW_MZ'
$blha_ew_scheme = "alpha_qed"
SM.mZ => 9.118800000000E+01
SM.mW => 8.041900200000E+01
SM.mH => 1.250000000000E+02
SM.GF => 1.166390000000E-05
SM.wZ => 0.000000000000E+00
SM.wtop => 0.000000000000E+00
SM.wW => 0.000000000000E+00
SM.wH => 0.000000000000E+00
SM.ms => 0.000000000000E+00
SM.mc => 0.000000000000E+00
SM.mb => 0.000000000000E+00
SM.mtop => 1.732000000000E+02
SM.me => 0.000000000000E+00
SM.mmu => 0.000000000000E+00
SM.mtau => 1.777000000000E+00
SM.alphas => 1.180000000000E-01
?alphas_is_fixed = false
?alphas_from_mz = true
?alphas_from_lambda_qcd = false
alphas_nf = 5
alphas_order = 2
[user variable] jet = PDG(2, -2, 1, -1, 3, -3, 4, -4, 5, -5, 21)
$exclude_gauge_splittings = "t"
$method = "openloops"
seed = 8131
sqrts = 1.000000000000E+03
jet_algorithm = 2
jet_r = 5.000000000000E-01
-?use_vamp_equivalences = false
$integration_method = "vamp2"
$rng_method = "rng_stream"
| End of included 'nlo_settings.sin'
[user variable] pr = PDG(2, -2, 1, -1, 3, -3, 4, -4, 5, -5, 21)
$exclude_gauge_splittings = "t"
$lhapdf_file = "MSTW2008nlo68cl"
sqrts = 1.300000000000E+04
alpha_power = 2
alphas_power = 0
?alphas_from_mz = false
?alphas_from_lhapdf = true
?combined_nlo_integration = false
| Process library 'nlo_ppzz_lib': recorded process 'nlo_ppzz_p1'
| Integrate: current process library needs compilation
| Process library 'nlo_ppzz_lib': compiling ...
| Process library 'nlo_ppzz_lib': writing makefile
| Process library 'nlo_ppzz_lib': removing old files
| Process library 'nlo_ppzz_lib': writing driver
| Process library 'nlo_ppzz_lib': creating source code
| Process library 'nlo_ppzz_lib': compiling sources
| Process library 'nlo_ppzz_lib': linking
| Process library 'nlo_ppzz_lib': loading
| Process library 'nlo_ppzz_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 8131
| Initializing integration for process nlo_ppzz_p1:
| Beam structure: p, p => lhapdf
| Beam data (collision):
| p (mass = 0.0000000E+00 GeV)
| p (mass = 0.0000000E+00 GeV)
| sqrts = 1.300000000000E+04 GeV
| Phase space: generating configuration ...
| Phase space: ... success.
| Phase space: writing configuration file 'nlo_ppzz_p1.i1.phs'
| Phase space: generating configuration ...
| Phase space: ... success.
| Phase space: writing configuration file 'nlo_ppzz_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: [...]
| 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: [...]
| One-Loop-Provider: Using OpenLoops
| Loading library: [...]
| One-Loop-Provider: Using OpenLoops
| Loading library: [...]
| ------------------------------------------------------------------------
| Process [scattering]: 'nlo_ppzz_p1'
| Library name = 'nlo_ppzz_lib'
| Process index = 1
| Process components:
| 1: 'nlo_ppzz_p1_i1': u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl, u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl => Z, Z [openloops]
| 2: 'nlo_ppzz_p1_i2': dbar:d:ubar:u:sbar:s:cbar:c:bbar:b:gl, dbar:d:ubar:u:sbar:s:cbar:c:bbar:b:gl => Z, Z, d:dbar:u:ubar:s:sbar:c:cbar:b:bbar:gl [openloops], [real]
| 3: 'nlo_ppzz_p1_i3': u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl, u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl => Z, Z [openloops], [virtual]
| 4: 'nlo_ppzz_p1_i4': u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl, u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl => Z, Z [inactive], [subtraction]
| 5: 'nlo_ppzz_p1_i5': u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl, u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl => Z, Z [openloops], [dglap]
| ------------------------------------------------------------------------
| Phase space: 5 channels, 2 dimensions
| Phase space: found 5 channels, collected in 2 groves.
-| Phase space: no equivalences between channels used.
+| Phase space: Using 18 equivalences between channels.
| Phase space: wood
| Phase space: 5 channels, 5 dimensions
| Phase space: found 5 channels, collected in 2 groves.
-| Phase space: no equivalences between channels used.
+| Phase space: Using 18 equivalences between channels.
| Phase space: wood
| Phase space: 5 channels, 2 dimensions
| Phase space: found 5 channels, collected in 2 groves.
-| Phase space: no equivalences between channels used.
+| Phase space: Using 18 equivalences between channels.
| Phase space: wood
| Phase space: 5 channels, 3 dimensions
| Phase space: found 5 channels, collected in 2 groves.
-| Phase space: no equivalences between channels used.
+| Phase space: Using 18 equivalences between channels.
| Phase space: wood
| Beam structure: lhapdf, none => none, lhapdf
| Beam structure: 1 channels, 2 dimensions
Warning: No cuts have been defined.
| Using user-defined general scale.
| Starting integration for process 'nlo_ppzz_p1' part 'born'
| Integrate: iterations = 1:500:"gw"
| Integrator: 2 chains, 5 channels, 4 dimensions
+| Integrator: Using VAMP2 channel equivalences
| Integrator: 500 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 'nlo_ppzz_p1.m1.vg2'.
| VAMP2: set chain: use chained weights.
1 480 5.2493104E+03 2.54E+03 48.41 10.61* 1.46
|-----------------------------------------------------------------------------|
1 480 5.2493104E+03 2.54E+03 48.41 10.61 1.46
|=============================================================================|
| Starting integration for process 'nlo_ppzz_p1' part 'real'
| Integrate: iterations = 1:500:"gw"
| Integrator: 2 chains, 5 channels, 7 dimensions
+| Integrator: Using VAMP2 channel equivalences
| Integrator: 500 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 'nlo_ppzz_p1.m2.vg2'.
| VAMP2: set chain: use chained weights.
1 501 -6.0423038E+02 4.35E+02 72.02 16.12* 1.57
|-----------------------------------------------------------------------------|
1 501 -6.0423038E+02 4.35E+02 72.02 16.12 1.57
|=============================================================================|
| Starting integration for process 'nlo_ppzz_p1' part 'virtual'
| Integrate: iterations = 1:500:"gw"
| Integrator: 2 chains, 5 channels, 4 dimensions
+| Integrator: Using VAMP2 channel equivalences
| Integrator: 500 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 'nlo_ppzz_p1.m3.vg2'.
| VAMP2: set chain: use chained weights.
1 477 1.5233944E+03 5.05E+02 33.15 7.24* 1.88
|-----------------------------------------------------------------------------|
1 477 1.5233944E+03 5.05E+02 33.15 7.24 1.88
|=============================================================================|
| Starting integration for process 'nlo_ppzz_p1' part 'dglap'
| Integrate: iterations = 1:500:"gw"
| Integrator: 2 chains, 5 channels, 5 dimensions
+| Integrator: Using VAMP2 channel equivalences
| Integrator: 500 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 'nlo_ppzz_p1.m4.vg2'.
| VAMP2: set chain: use chained weights.
1 384 4.2945688E+02 2.21E+02 51.39 10.07* 1.98
|-----------------------------------------------------------------------------|
1 384 4.2945688E+02 2.21E+02 51.39 10.07 1.98
|=============================================================================|
| Integrate: sum of all components
|=============================================================================|
| It Calls Integral[fb] Error[fb] Err[%] Acc Eff[%] Chi2 N[It] |
|=============================================================================|
1 0 6.5979313E+03 2.64E+03 39.96 0.00* 1.43
| NLO Correction: [O(alpha_s+1)/O(alpha_s)]
| ( 25.6914 +- 18.26611 ) %
|=============================================================================|
| There were no errors and 1 warning(s).
| WHIZARD run finished.
|=============================================================================|
Index: trunk/share/tests/ext_tests_nlo/ref-output/nlo_eetthz.ref
===================================================================
--- trunk/share/tests/ext_tests_nlo/ref-output/nlo_eetthz.ref (revision 8482)
+++ trunk/share/tests/ext_tests_nlo/ref-output/nlo_eetthz.ref (revision 8483)
@@ -1,164 +1,166 @@
?openmp_logging = false
?vis_history = false
?integration_timer = false
openmp_num_threads = 1
?debug_decay = false
?debug_process = false
?debug_verbose = false
?write_raw = false
| Switching to model 'SM', scheme 'GF_MW_MZ'
$blha_ew_scheme = "alpha_qed"
SM.mZ => 9.118800000000E+01
SM.mW => 8.041900200000E+01
SM.mH => 1.250000000000E+02
SM.GF => 1.166390000000E-05
SM.wZ => 0.000000000000E+00
SM.wtop => 0.000000000000E+00
SM.wW => 0.000000000000E+00
SM.wH => 0.000000000000E+00
SM.ms => 0.000000000000E+00
SM.mc => 0.000000000000E+00
SM.mb => 0.000000000000E+00
SM.mtop => 1.732000000000E+02
SM.me => 0.000000000000E+00
SM.mmu => 0.000000000000E+00
SM.mtau => 1.777000000000E+00
SM.alphas => 1.180000000000E-01
?alphas_is_fixed = false
?alphas_from_mz = true
?alphas_from_lambda_qcd = false
alphas_nf = 5
alphas_order = 2
[user variable] jet = PDG(2, -2, 1, -1, 3, -3, 4, -4, 5, -5, 21)
$exclude_gauge_splittings = "t"
$method = "openloops"
seed = 8131
sqrts = 1.000000000000E+03
jet_algorithm = 2
jet_r = 5.000000000000E-01
-?use_vamp_equivalences = false
$integration_method = "vamp2"
$rng_method = "rng_stream"
| End of included 'nlo_settings.sin'
alpha_power = 4
alphas_power = 0
| Process library 'nlo_eetthz_lib': recorded process 'nlo_eetthz_p1'
| Integrate: current process library needs compilation
| Process library 'nlo_eetthz_lib': compiling ...
| Process library 'nlo_eetthz_lib': writing makefile
| Process library 'nlo_eetthz_lib': removing old files
| Process library 'nlo_eetthz_lib': writing driver
| Process library 'nlo_eetthz_lib': creating source code
| Process library 'nlo_eetthz_lib': compiling sources
| Process library 'nlo_eetthz_lib': linking
| Process library 'nlo_eetthz_lib': loading
| Process library 'nlo_eetthz_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 8131
| Initializing integration for process nlo_eetthz_p1:
| Beam structure: [any particles]
| Beam data (collision):
| e- (mass = 0.0000000E+00 GeV)
| e+ (mass = 0.0000000E+00 GeV)
| sqrts = 1.000000000000E+03 GeV
| Phase space: generating configuration ...
| Phase space: ... success.
| Phase space: writing configuration file 'nlo_eetthz_p1.i1.phs'
| Phase space: generating configuration ...
| Phase space: ... success.
| Phase space: writing configuration file 'nlo_eetthz_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: [...]
| 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]: 'nlo_eetthz_p1'
| Library name = 'nlo_eetthz_lib'
| Process index = 1
| Process components:
| 1: 'nlo_eetthz_p1_i1': e-, e+ => t, tbar, H, Z [openloops]
| 2: 'nlo_eetthz_p1_i2': e-, e+ => t, tbar, H, Z, gl [openloops], [real]
| 3: 'nlo_eetthz_p1_i3': e-, e+ => t, tbar, H, Z [openloops], [virtual]
| 4: 'nlo_eetthz_p1_i4': e-, e+ => t, tbar, H, Z [inactive], [subtraction]
| ------------------------------------------------------------------------
| Phase space: 6 channels, 8 dimensions
| Phase space: found 6 channels, collected in 1 grove.
-| Phase space: no equivalences between channels used.
+| Phase space: Using 12 equivalences between channels.
| Phase space: wood
| Phase space: 6 channels, 11 dimensions
| Phase space: found 6 channels, collected in 1 grove.
-| Phase space: no equivalences between channels used.
+| Phase space: Using 12 equivalences between channels.
| Phase space: wood
| Phase space: 6 channels, 8 dimensions
| Phase space: found 6 channels, collected in 1 grove.
-| Phase space: no equivalences between channels used.
+| Phase space: Using 12 equivalences between channels.
| Phase space: wood
Warning: No cuts have been defined.
| Using user-defined general scale.
| Starting integration for process 'nlo_eetthz_p1' part 'born'
| Integrate: iterations = 1:100:"gw"
| Integrator: 1 chains, 6 channels, 8 dimensions
+| Integrator: Using VAMP2 channel equivalences
| 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 'nlo_eetthz_p1.m1.vg2'.
| VAMP2: set chain: use chained weights.
1 102 2.7683185E-02 8.29E-03 29.94 3.02* 10.86
|-----------------------------------------------------------------------------|
1 102 2.7683185E-02 8.29E-03 29.94 3.02 10.86
|=============================================================================|
| Starting integration for process 'nlo_eetthz_p1' part 'real'
| Integrate: iterations = 1:100:"gw"
| Integrator: 1 chains, 6 channels, 11 dimensions
+| Integrator: Using VAMP2 channel equivalences
| 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 'nlo_eetthz_p1.m2.vg2'.
| VAMP2: set chain: use chained weights.
1 102 -7.9626362E-03 2.24E-03 28.07 2.84* 11.01
|-----------------------------------------------------------------------------|
1 102 -7.9626362E-03 2.24E-03 28.07 2.84 11.01
|=============================================================================|
| Starting integration for process 'nlo_eetthz_p1' part 'virtual'
| Integrate: iterations = 1:100:"gw"
| Integrator: 1 chains, 6 channels, 8 dimensions
+| Integrator: Using VAMP2 channel equivalences
| 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 'nlo_eetthz_p1.m3.vg2'.
| VAMP2: set chain: use chained weights.
1 102 1.2424068E-02 2.92E-03 23.48 2.37* 12.29
|-----------------------------------------------------------------------------|
1 102 1.2424068E-02 2.92E-03 23.48 2.37 12.29
|=============================================================================|
| Integrate: sum of all components
|=============================================================================|
| It Calls Integral[fb] Error[fb] Err[%] Acc Eff[%] Chi2 N[It] |
|=============================================================================|
1 0 3.2144617E-02 9.07E-03 28.21 0.00* 9.03
| NLO Correction: [O(alpha_s+1)/O(alpha_s)]
| ( 16.1160 +- 14.12548 ) %
|=============================================================================|
| There were no errors and 1 warning(s).
| WHIZARD run finished.
|=============================================================================|
Index: trunk/share/tests/ext_tests_nlo/ref-output/nlo_eettzj.ref
===================================================================
--- trunk/share/tests/ext_tests_nlo/ref-output/nlo_eettzj.ref (revision 8482)
+++ trunk/share/tests/ext_tests_nlo/ref-output/nlo_eettzj.ref (revision 8483)
@@ -1,163 +1,165 @@
?openmp_logging = false
?vis_history = false
?integration_timer = false
openmp_num_threads = 1
?debug_decay = false
?debug_process = false
?debug_verbose = false
?write_raw = false
| Switching to model 'SM', scheme 'GF_MW_MZ'
$blha_ew_scheme = "alpha_qed"
SM.mZ => 9.118800000000E+01
SM.mW => 8.041900200000E+01
SM.mH => 1.250000000000E+02
SM.GF => 1.166390000000E-05
SM.wZ => 0.000000000000E+00
SM.wtop => 0.000000000000E+00
SM.wW => 0.000000000000E+00
SM.wH => 0.000000000000E+00
SM.ms => 0.000000000000E+00
SM.mc => 0.000000000000E+00
SM.mb => 0.000000000000E+00
SM.mtop => 1.732000000000E+02
SM.me => 0.000000000000E+00
SM.mmu => 0.000000000000E+00
SM.mtau => 1.777000000000E+00
SM.alphas => 1.180000000000E-01
?alphas_is_fixed = false
?alphas_from_mz = true
?alphas_from_lambda_qcd = false
alphas_nf = 5
alphas_order = 2
[user variable] jet = PDG(2, -2, 1, -1, 3, -3, 4, -4, 5, -5, 21)
$exclude_gauge_splittings = "t"
$method = "openloops"
seed = 8131
sqrts = 1.000000000000E+03
jet_algorithm = 2
jet_r = 5.000000000000E-01
-?use_vamp_equivalences = false
$integration_method = "vamp2"
$rng_method = "rng_stream"
| End of included 'nlo_settings.sin'
alpha_power = 3
alphas_power = 1
| Process library 'nlo_eettzj_lib': recorded process 'nlo_eettzj_p1'
| Integrate: current process library needs compilation
| Process library 'nlo_eettzj_lib': compiling ...
| Process library 'nlo_eettzj_lib': writing makefile
| Process library 'nlo_eettzj_lib': removing old files
| Process library 'nlo_eettzj_lib': writing driver
| Process library 'nlo_eettzj_lib': creating source code
| Process library 'nlo_eettzj_lib': compiling sources
| Process library 'nlo_eettzj_lib': linking
| Process library 'nlo_eettzj_lib': loading
| Process library 'nlo_eettzj_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 8131
| Initializing integration for process nlo_eettzj_p1:
| Beam structure: [any particles]
| Beam data (collision):
| e- (mass = 0.0000000E+00 GeV)
| e+ (mass = 0.0000000E+00 GeV)
| sqrts = 1.000000000000E+03 GeV
| Phase space: generating configuration ...
| Phase space: ... success.
| Phase space: writing configuration file 'nlo_eettzj_p1.i1.phs'
| Phase space: generating configuration ...
| Phase space: ... success.
| Phase space: writing configuration file 'nlo_eettzj_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: [...]
| 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]: 'nlo_eettzj_p1'
| Library name = 'nlo_eettzj_lib'
| Process index = 1
| Process components:
| 1: 'nlo_eettzj_p1_i1': e-, e+ => t, tbar, Z, u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl [openloops]
| 2: 'nlo_eettzj_p1_i2': e-, e+ => t, tbar, Z, d:dbar:u:ubar:s:sbar:c:cbar:b:bbar:gl, d:dbar:u:ubar:s:sbar:c:cbar:b:bbar:gl [openloops], [real]
| 3: 'nlo_eettzj_p1_i3': e-, e+ => t, tbar, Z, u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl [openloops], [virtual]
| 4: 'nlo_eettzj_p1_i4': e-, e+ => t, tbar, Z, u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl [inactive], [subtraction]
| ------------------------------------------------------------------------
| Phase space: 14 channels, 8 dimensions
| Phase space: found 14 channels, collected in 3 groves.
-| Phase space: no equivalences between channels used.
+| Phase space: Using 22 equivalences between channels.
| Phase space: wood
| Phase space: 14 channels, 11 dimensions
| Phase space: found 14 channels, collected in 3 groves.
-| Phase space: no equivalences between channels used.
+| Phase space: Using 22 equivalences between channels.
| Phase space: wood
| Phase space: 14 channels, 8 dimensions
| Phase space: found 14 channels, collected in 3 groves.
-| Phase space: no equivalences between channels used.
+| Phase space: Using 22 equivalences between channels.
| Phase space: wood
| Applying user-defined cuts.
| Using user-defined general scale.
| Starting integration for process 'nlo_eettzj_p1' part 'born'
| Integrate: iterations = 1:140:"gw"
| Integrator: 3 chains, 14 channels, 8 dimensions
+| Integrator: Using VAMP2 channel equivalences
| Integrator: 140 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 'nlo_eettzj_p1.m1.vg2'.
| VAMP2: set chain: use chained weights.
1 140 3.2668638E-01 6.72E-02 20.56 2.43* 16.87
|-----------------------------------------------------------------------------|
1 140 3.2668638E-01 6.72E-02 20.56 2.43 16.87
|=============================================================================|
| Starting integration for process 'nlo_eettzj_p1' part 'real'
| Integrate: iterations = 1:140:"gw"
| Integrator: 3 chains, 14 channels, 11 dimensions
+| Integrator: Using VAMP2 channel equivalences
| Integrator: 140 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 'nlo_eettzj_p1.m2.vg2'.
| VAMP2: set chain: use chained weights.
1 140 5.0632195E-02 8.19E-02 161.77 19.14* 13.65
|-----------------------------------------------------------------------------|
1 140 5.0632195E-02 8.19E-02 161.77 19.14 13.65
|=============================================================================|
| Starting integration for process 'nlo_eettzj_p1' part 'virtual'
| Integrate: iterations = 1:140:"gw"
| Integrator: 3 chains, 14 channels, 8 dimensions
+| Integrator: Using VAMP2 channel equivalences
| Integrator: 140 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 'nlo_eettzj_p1.m3.vg2'.
| VAMP2: set chain: use chained weights.
1 148 8.2763934E-02 1.97E-02 23.80 2.90* 18.23
|-----------------------------------------------------------------------------|
1 148 8.2763934E-02 1.97E-02 23.80 2.90 18.23
|=============================================================================|
| Integrate: sum of all components
|=============================================================================|
| It Calls Integral[fb] Error[fb] Err[%] Acc Eff[%] Chi2 N[It] |
|=============================================================================|
1 0 4.6008251E-01 1.08E-01 23.42 0.00* 16.66
| NLO Correction: [O(alpha_s+1)/O(alpha_s)]
| ( 40.8331 +- 27.11890 ) %
|=============================================================================|
| WHIZARD run finished.
|=============================================================================|
Index: trunk/share/tests/ext_tests_nlo/ref-output/nlo_ppw.ref
===================================================================
--- trunk/share/tests/ext_tests_nlo/ref-output/nlo_ppw.ref (revision 8482)
+++ trunk/share/tests/ext_tests_nlo/ref-output/nlo_ppw.ref (revision 8483)
@@ -1,213 +1,216 @@
?openmp_logging = false
?vis_history = false
?integration_timer = false
openmp_num_threads = 1
?debug_decay = false
?debug_process = false
?debug_verbose = false
?write_raw = false
| Switching to model 'SM', scheme 'GF_MW_MZ'
$blha_ew_scheme = "alpha_qed"
SM.mZ => 9.118800000000E+01
SM.mW => 8.041900200000E+01
SM.mH => 1.250000000000E+02
SM.GF => 1.166390000000E-05
SM.wZ => 0.000000000000E+00
SM.wtop => 0.000000000000E+00
SM.wW => 0.000000000000E+00
SM.wH => 0.000000000000E+00
SM.ms => 0.000000000000E+00
SM.mc => 0.000000000000E+00
SM.mb => 0.000000000000E+00
SM.mtop => 1.732000000000E+02
SM.me => 0.000000000000E+00
SM.mmu => 0.000000000000E+00
SM.mtau => 1.777000000000E+00
SM.alphas => 1.180000000000E-01
?alphas_is_fixed = false
?alphas_from_mz = true
?alphas_from_lambda_qcd = false
alphas_nf = 5
alphas_order = 2
[user variable] jet = PDG(2, -2, 1, -1, 3, -3, 4, -4, 5, -5, 21)
$exclude_gauge_splittings = "t"
$method = "openloops"
seed = 8131
sqrts = 1.000000000000E+03
jet_algorithm = 2
jet_r = 5.000000000000E-01
-?use_vamp_equivalences = false
$integration_method = "vamp2"
$rng_method = "rng_stream"
| End of included 'nlo_settings.sin'
[user variable] pr = PDG(2, -2, 1, -1, 3, -3, 4, -4, 5, -5, 21)
[user variable] Wpm = PDG(24, -24)
$exclude_gauge_splittings = "t"
$lhapdf_file = "MSTW2008nlo68cl"
sqrts = 1.300000000000E+04
alpha_power = 1
alphas_power = 0
?alphas_from_mz = false
?alphas_from_lhapdf = true
?combined_nlo_integration = false
relative_error_goal = 4.000000000000E-03
| Process library 'nlo_ppw_lib': recorded process 'ppw'
| Integrate: current process library needs compilation
| Process library 'nlo_ppw_lib': compiling ...
| Process library 'nlo_ppw_lib': writing makefile
| Process library 'nlo_ppw_lib': removing old files
| Process library 'nlo_ppw_lib': writing driver
| Process library 'nlo_ppw_lib': creating source code
| Process library 'nlo_ppw_lib': compiling sources
| Process library 'nlo_ppw_lib': linking
| Process library 'nlo_ppw_lib': loading
| Process library 'nlo_ppw_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 8131
| Initializing integration for process ppw:
| Beam structure: p, p => lhapdf
| Beam data (collision):
| p (mass = 0.0000000E+00 GeV)
| p (mass = 0.0000000E+00 GeV)
| sqrts = 1.300000000000E+04 GeV
| Phase space: generating configuration ...
| Phase space: ... success.
| Phase space: writing configuration file 'ppw.i1.phs'
| Phase space: generating configuration ...
| Phase space: ... success.
| Phase space: writing configuration file 'ppw.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: [...]
| 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: [...]
| One-Loop-Provider: Using OpenLoops
| Loading library: [...]
| One-Loop-Provider: Using OpenLoops
| Loading library: [...]
| ------------------------------------------------------------------------
| Process [scattering]: 'ppw'
| Library name = 'nlo_ppw_lib'
| Process index = 1
| Process components:
| 1: 'ppw_i1': u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl, u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl => W+:W- [openloops]
| 2: 'ppw_i2': dbar:d:ubar:u:sbar:s:cbar:c:bbar:b:gl, dbar:d:ubar:u:sbar:s:cbar:c:bbar:b:gl => W+:W-, d:dbar:u:ubar:s:sbar:c:cbar:b:bbar:gl [openloops], [real]
| 3: 'ppw_i3': u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl, u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl => W+:W- [openloops], [virtual]
| 4: 'ppw_i4': u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl, u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl => W+:W- [inactive], [subtraction]
| 5: 'ppw_i5': u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl, u:ubar:d:dbar:s:sbar:c:cbar:b:bbar:gl => W+:W- [openloops], [dglap]
| ------------------------------------------------------------------------
| Phase space: 2 channels, 0 dimensions
| Phase space: found 2 channels, collected in 1 grove.
-| Phase space: no equivalences between channels used.
+| Phase space: Using 4 equivalences between channels.
| Phase space: wood
| Phase space: 2 channels, 3 dimensions
| Phase space: found 2 channels, collected in 1 grove.
-| Phase space: no equivalences between channels used.
+| Phase space: Using 4 equivalences between channels.
| Phase space: wood
| Phase space: 2 channels, 0 dimensions
| Phase space: found 2 channels, collected in 1 grove.
-| Phase space: no equivalences between channels used.
+| Phase space: Using 4 equivalences between channels.
| Phase space: wood
| Phase space: 2 channels, 1 dimensions
| Phase space: found 2 channels, collected in 1 grove.
-| Phase space: no equivalences between channels used.
+| Phase space: Using 4 equivalences between channels.
| Phase space: wood
| Beam structure: lhapdf, none => none, lhapdf
| Beam structure: 1 channels, 2 dimensions
| Applying user-defined cuts.
| Using user-defined general scale.
| Starting integration for process 'ppw' part 'born'
| Integrate: iterations = 5:100:"gw"
| Integrator: 1 chains, 2 channels, 2 dimensions
+| Integrator: Using VAMP2 channel equivalences
| 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 'ppw.m1.vg2'.
| VAMP2: set chain: use chained weights.
1 100 1.4010570E+08 3.16E+06 2.26 0.23* 73.87
- 2 100 1.3839065E+08 3.65E+06 2.64 0.26 66.92
- 3 100 1.3678909E+08 3.68E+06 2.69 0.27 69.98
- 4 100 1.4462663E+08 1.94E+06 1.34 0.13* 74.80
- 5 100 1.4143428E+08 3.10E+06 2.19 0.22 66.27
+ 2 100 1.3867375E+08 3.77E+06 2.72 0.27 65.66
+ 3 100 1.3624094E+08 3.65E+06 2.68 0.27* 71.22
+ 4 100 1.4269819E+08 2.23E+06 1.56 0.16* 73.44
+ 5 100 1.4059856E+08 2.98E+06 2.12 0.21 68.05
|-----------------------------------------------------------------------------|
- 5 500 1.4166162E+08 1.27E+06 0.90 0.20 66.27 1.28 5
+ 5 500 1.4043563E+08 1.34E+06 0.95 0.21 68.05 0.65 5
|=============================================================================|
| Starting integration for process 'ppw' part 'real'
| Integrate: iterations = 5:100:"gw"
| Integrator: 1 chains, 2 channels, 5 dimensions
+| Integrator: Using VAMP2 channel equivalences
| 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 'ppw.m2.vg2'.
| VAMP2: set chain: use chained weights.
1 100 9.8853129E+06 1.38E+06 13.94 1.39* 29.20
- 2 100 7.4695755E+06 1.32E+06 17.73 1.77 30.89
- 3 100 8.7052694E+06 1.69E+06 19.46 1.95 24.71
- 4 100 1.1111861E+07 1.67E+06 15.06 1.51* 21.28
- 5 100 1.0249393E+07 1.47E+06 14.31 1.43* 26.68
+ 2 100 8.1908586E+06 1.62E+06 19.80 1.98 24.25
+ 3 100 9.8297848E+06 1.75E+06 17.82 1.78* 28.99
+ 4 100 1.1887431E+07 1.25E+06 10.49 1.05* 35.68
+ 5 100 1.1259586E+07 1.06E+06 9.41 0.94* 33.06
|-----------------------------------------------------------------------------|
- 5 500 9.3646224E+06 6.64E+05 7.09 1.59 26.68 0.95 5
+ 5 500 1.0553927E+07 6.01E+05 5.69 1.27 33.06 1.03 5
|=============================================================================|
| Starting integration for process 'ppw' part 'virtual'
| Integrate: iterations = 5:100:"gw"
| Integrator: 1 chains, 2 channels, 2 dimensions
+| Integrator: Using VAMP2 channel equivalences
| 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 'ppw.m3.vg2'.
| VAMP2: set chain: use chained weights.
1 100 1.0997093E+07 2.83E+05 2.58 0.26* 72.55
- 2 100 1.1159774E+07 2.53E+05 2.26 0.23* 60.39
- 3 100 1.0791441E+07 2.40E+05 2.22 0.22* 75.62
- 4 100 1.1174326E+07 4.45E+05 3.98 0.40 38.22
- 5 100 1.0945643E+07 3.30E+05 3.01 0.30* 65.77
+ 2 100 1.1187478E+07 2.52E+05 2.25 0.22* 65.42
+ 3 100 1.0854754E+07 2.42E+05 2.23 0.22* 73.92
+ 4 100 1.1264058E+07 4.47E+05 3.97 0.40 39.72
+ 5 100 1.0976038E+07 3.33E+05 3.03 0.30* 68.17
|-----------------------------------------------------------------------------|
- 5 500 1.0986978E+07 1.29E+05 1.18 0.26 65.77 0.33 5
+ 5 500 1.1026135E+07 1.30E+05 1.18 0.26 68.17 0.31 5
|=============================================================================|
| Starting integration for process 'ppw' part 'dglap'
| Integrate: iterations = 5:100:"gw"
| Integrator: 1 chains, 2 channels, 3 dimensions
+| Integrator: Using VAMP2 channel equivalences
| 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 'ppw.m4.vg2'.
| VAMP2: set chain: use chained weights.
1 96 1.6843581E+07 5.54E+06 32.92 3.23* 14.38
- 2 96 2.4445493E+07 3.34E+06 13.66 1.34* 41.52
- 3 96 2.2455051E+07 3.11E+06 13.84 1.36 40.36
- 4 96 1.6276142E+07 2.87E+06 17.65 1.73 51.80
- 5 96 1.4714363E+07 3.58E+06 24.36 2.39 40.68
+ 2 96 2.3679359E+07 3.68E+06 15.54 1.52* 43.84
+ 3 96 2.2463303E+07 2.96E+06 13.17 1.29* 51.29
+ 4 96 1.6572925E+07 2.93E+06 17.68 1.73 43.91
+ 5 96 1.3825202E+07 3.29E+06 23.78 2.33 46.76
|-----------------------------------------------------------------------------|
- 5 480 1.9263663E+07 1.53E+06 7.97 1.75 40.68 1.59 5
+ 5 480 1.8788925E+07 1.53E+06 8.12 1.78 46.76 1.57 5
|=============================================================================|
| Integrate: sum of all components
|=============================================================================|
| It Calls Integral[fb] Error[fb] Err[%] Acc Eff[%] Chi2 N[It] |
|=============================================================================|
- 1 0 1.8127688E+08 2.10E+06 1.16 0.00* 57.93
+ 1 0 1.8080461E+08 2.12E+06 1.17 0.00* 61.36
| NLO Correction: [O(alpha_s+1)/O(alpha_s)]
-| ( 27.9647 +- 1.21012 ) %
+| ( 28.7455 +- 1.20299 ) %
|=============================================================================|
| WHIZARD run finished.
|=============================================================================|
Index: trunk/share/tests/ext_tests_nlo/nlo_ppttz.sin
===================================================================
--- trunk/share/tests/ext_tests_nlo/nlo_ppttz.sin (revision 8482)
+++ trunk/share/tests/ext_tests_nlo/nlo_ppttz.sin (revision 8483)
@@ -1,42 +1,41 @@
include("nlo_settings.sin")
alias pr = u:U:d:D:s:S:c:C:b:B:gl
$exclude_gauge_splittings = "t"
beams = p, p => lhapdf
$lhapdf_file = "MSTW2008nlo68cl"
sqrts = 13000 GeV
alpha_power = 1
alphas_power = 2
?alphas_from_mz = false
?alphas_from_lhapdf = true
scale = let subevt @clustered_jets = cluster [jet] in
let int njet = count [@clustered_jets] in
if njet == 0 then
(sqrt (eval Pt [extract index 1 [t]]**2 + eval M [extract index 1 [t]]**2)
+ sqrt (eval Pt [extract index 1 [T]]**2 + eval M [extract index 1 [T]]**2)
+ sqrt (eval Pt [extract index 1 [Z]]**2 + eval M [extract index 1 [Z]]**2)) / 2
elsif njet == 1 then
(sqrt (eval Pt [extract index 1 [t]]**2 + eval M [extract index 1 [t]]**2)
+ sqrt (eval Pt [extract index 1 [T]]**2 + eval M [extract index 1 [T]]**2)
+ sqrt (eval Pt [extract index 1 [Z]]**2 + eval M [extract index 1 [Z]]**2)
+ eval Pt [extract index 1 [@clustered_jets]]) / 2
else
sqrts
endif
?combined_nlo_integration = false
-?use_vamp_equivalences = false
!?nlo_use_real_partition = true
!real_partition_scale = 5 GeV
process nlo_ppttz_p1 = pr, pr => t, T, Z { nlo_calculation = full $restrictions="!W+:W-" }
!integrate (nlo_ppttz_p1) { iterations = 4:1000:"gw" }
mult_call_real = 2
relative_error_goal = 0.009
integrate (nlo_ppttz_p1) { iterations = 10:100000:"gw",5:60000 }
Index: trunk/share/tests/ext_tests_nlo/nlo_pptt.sin
===================================================================
--- trunk/share/tests/ext_tests_nlo/nlo_pptt.sin (revision 8482)
+++ trunk/share/tests/ext_tests_nlo/nlo_pptt.sin (revision 8483)
@@ -1,38 +1,37 @@
include("nlo_settings.sin")
alias pr = u:U:d:D:s:S:c:C:b:B:gl
$exclude_gauge_splittings = "t"
beams = p, p => lhapdf
$lhapdf_file = "MSTW2008nlo68cl"
sqrts = 13000 GeV
alpha_power = 0
alphas_power = 2
?alphas_from_mz = false
?alphas_from_lhapdf = true
scale = let subevt @clustered_jets = cluster [jet] in
let int njet = count [@clustered_jets] in
if njet == 0 then
(sqrt (eval Pt [extract index 1 [t]]**2 + eval M [extract index 1 [t]]**2)
+ sqrt (eval Pt [extract index 1 [T]]**2 + eval M [extract index 1 [T]]**2)) / 2
elsif njet == 1 then
(sqrt (eval Pt [extract index 1 [t]]**2 + eval M [extract index 1 [t]]**2)
+ sqrt (eval Pt [extract index 1 [T]]**2 + eval M [extract index 1 [T]]**2)
+ eval Pt [extract index 1 [@clustered_jets]]) / 2
else
sqrts
endif
?combined_nlo_integration = false
-?use_vamp_equivalences = false
!?nlo_use_real_partition = true
!real_partition_scale = 5 GeV
process nlo_pptt_p1 = pr, pr => t, T { nlo_calculation = full $restrictions="!W+:W-" }
!integrate (nlo_pptt_p1) { iterations = 4:1000:"gw" }
mult_call_real = 2
integrate (nlo_pptt_p1) { iterations = 10:100000:"gw",5:60000 }
Index: trunk/share/tests/ext_tests_nlo/nlo_settings.sin
===================================================================
--- trunk/share/tests/ext_tests_nlo/nlo_settings.sin (revision 8482)
+++ trunk/share/tests/ext_tests_nlo/nlo_settings.sin (revision 8483)
@@ -1,55 +1,54 @@
?logging = true
?openmp_logging = false
?vis_history = false
?integration_timer = false
openmp_num_threads = 1
sample_format = debug
?debug_decay = false
?debug_process = false
?debug_verbose = false
?write_raw = false
model = SM ("GF_MW_MZ")
$blha_ew_scheme = "alpha_qed"
mZ = 91.188
mW = 80.419002
mH = 125.0
GF = 1.16639E-5
wZ = 0.0
wtop = 0.0
wW = 0.0
wH = 0.0
ms = 0
mc = 0
mb = 0
mtop = 173.2
me = 0
mmu = 0
mtau = 1.777
alphas = 0.118
?alphas_is_fixed = false
?alphas_from_mz = true
?alphas_from_lambda_qcd = false
alphas_nf = 5
alphas_order = 2
alias jet = u:U:d:D:s:S:c:C:b:B:gl
$exclude_gauge_splittings = "t"
$method = "openloops"
seed = 8131
sqrts = 1 TeV
scale = sqrts
jet_algorithm = antikt_algorithm
jet_r = 0.5
-?use_vamp_equivalences = false
$integration_method = "vamp2"
$rng_method = "rng_stream"

File Metadata

Mime Type
application/octet-stream
Expires
Tue, May 7, 12:36 PM (1 d, 23 h)
Storage Engine
chunks
Storage Format
Chunks
Storage Handle
lgFvrUXQ7rh9
Default Alt Text
(5 MB)

Event Timeline