diff --git a/Changes-API.md b/Changes-API.md index 316ad8b..4f1d886 100644 --- a/Changes-API.md +++ b/Changes-API.md @@ -1,110 +1,112 @@ # Changelog for HEJ API This log lists only changes on the HEJ API. These are primarily code changes relevant for calling HEJ as an API. This file should only be read as an addition to [`Changes.md`](Changes.md), where the main features are documented. ## Version 2.1 ### 2.1.0 #### Changes to Event class * Restructured `Event` class - `Event` can now only be build from a (new) `Event::EventData` class - Removed default constructor for `Event` - `Event::EventData` replaces the old `UnclusteredEvent` struct. - - `UnclusteredEvent` is now deprecated, and will be removed in HEJ Version + - `UnclusteredEvent` is now **deprecated**, and will be removed in HEJ Version 2.3.0 - Removed `Event.unclustered()` function - Added new member function `Events.parameters()`, to directly access (underlying) `Parameters` - New member functions `begin_partons`, `end_partons` (`rbegin_partons`, `rend_partons`) with aliases `cbegin_partons`, `cend_partons` (`crbegin_partons`, `crend_partons`) for constant (reversed) iterators over outgoing partons. * New function `Event::EventData.reconstruct_intermediate()` to reconstruct bosons from decays, e.g. `positron + nu_e => Wp` * Added optional Colour charges to particles (`Particle.colour`) - Colour connection in the HEJ limit can be generated via `Event.generate_colours` (automatically done in the resummation) - Colour configuration of input events can be checked with `Event.is_leading_colour` * Added function `Event.valid_hej_state` to check if event _could have_ been - produced by `HEJ` according to the `max ext soft pt fraction` cut on the jets + produced by `HEJ` according to the `soft pt regulator` cut on the jets #### New and updated functions * Renamed `EventType::nonHEJ` to `EventType::non_resummable` and `is_HEJ()` to `is_resummable()` such that run card is consistent with internal workings * Made `MatrixElement.tree_kin(...)` and `MatrixElement.tree_param(...)` public * New `EventReweighter` member function `treatment` to query the treatment with respect to resummation for the various event types. * Added auxiliary functions to obtain a `std::string` from `EventDescription` (`to_string` for human readable, and `to_simple_string` for easy parsable string) * New `get_analyses` function to read in multiple `HEJ::Analysis` at once, similar to `get_analysis` * New `get_ew_parameters` function to extract electroweak parameters from YAML configuration. #### New classes * New class `Unweighter` to do unweighting * New class `CrossSectionAccumulator` to keep track of Cross Section of the different subprocess * New template struct `Parameters` similar to old `Weights` - `Weights` are now an alias for `Parameters`. Calling `Weights` did not change - `Weights.hh` was replaced by `Parameters.hh`. The old `Weights.hh` header will be removed in HEJ Version 2.2.0 * Function to multiplication and division of `EventParameters.weight` by double - This can be combined with `Parameters`, e.g. `Parameters*Weights`, see also `Events.parameters()` - Moved `EventParameters` to `Parameters.hh` header * new class `EWConstants` replaces previously hard coded `vev` - `EWConstants` have to be set in the general `Config` and the `MatrixElementConfig` #### Input/Output * New abstract `EventReader` class, as base for reading events from files - Moved LHE file reader to `HEJ::LesHouchesReader` * New (optional) function `finish()` in abstract class `EventWriter`. `finish()` is called _after_ all events are written. * Support reading (`HDF5Reader`) and writing (`HDF5Writer`) `hdf5` files * New `BufferedEventReader` class that allows to put events back into the reader. * New `SherpaLHEReader` to read Sherpa LHE files with correct weights * `get_analysis` now requires `YAML::Node` and `LHEF::HEPRUP` as arguments * Replaced `HepMCInterface` and `HepMCWriter` by `HepMCInterfaceX` and `HepMCWriterX` respectively, with `X` being the major version of HepMC (2 or 3) - Renamed `HepMCInterfaceX::init_kinematics` to `HepMCInterfaceX::init_event` and protected it, use `HepMCInterfaceX::operator()` instead - Removed redundant `HepMCInterfaceX::add_variation` function #### Linking * Export cmake target `HEJ::HEJ` to link directly against `libHEJ` * Preprocessor flags (`HEJ_BUILD_WITH_XYZ`) for enabled/disabled dependencies are now written to `ConfigFlags.hh` * Provide links to version specific object files, e.g. `libHEJ.so -> libHEJ.so.2.1 (soname) -> libHEJ.so.2.1.0` * Removed `LHAPDF` from public interface #### Miscellaneous * Capitalisation of `Config.hh` now matches class `Config` (was `config.hh`) +* Renamed `Config::max_ext_soft_pt_fraction` to `Config::soft_pt_regulator`. + `Config::max_ext_soft_pt_fraction` is now **deprecated** * Replaced redundant member `EventReweighterConfig::jet_param` with getter function `EventReweighter.jet_param()` (`JetParameters` are already in `PhaseSpacePointConfig`) * Avoid storing reference to the Random Number Generator inside classes - Constructors of `EventReweighter` now expect `std::shared_ptr` (was reference) - Moved reference to `HEJ::RNG` from constructor of `JetSplitter` to `JetSplitter.split` ## Version 2.0 ### 2.0.4 * Fixed wrong path of `HEJ_INCLUDE_DIR` in `hej-config.cmake` ### 2.0.0 * First release diff --git a/Changes.md b/Changes.md index 8312713..b0dbbf0 100644 --- a/Changes.md +++ b/Changes.md @@ -1,140 +1,142 @@ # Changelog This is the log for changes to the HEJ program. Further changes to the HEJ API are documented in [`Changes-API.md`](Changes-API.md). If you are using HEJ as a library, please also read the changes there. ## Version 2.1 This release adds support for two new processes: * W boson with jets. * Jets with a charged lepton-antilepton pair via a virtual Z boson or photon. In addition, the complete set of first subleading processes (unordered gluon, central and extremal quark-antiquark pair) is implemented for pure jets and W + jets, see [arXiv:TODO](https://arxiv.org/abs/TODO). Unordered gluon emission is also supported for Higgs boson + jets and Z boson/photon + jets. This release include many changes to the code, which affect users of HEJ as a library (see [`Changes-API.md`](Changes-API.md)). ### 2.1.0 #### New Processes * Resummation for W bosons with jets - New subleading processes `extremal qqx` & `central qqx` for a quark and anti-quark in the final state, e.g. `g g => u d_bar Wm g` (the other subleading processes also work with W's) - `HEJFOG` can generate multiple jets together with a (off-shell) W bosons decaying into lepton & neutrino * Resummation for jets with a charged lepton-antilepton pair via a virtual Z boson or photon. Includes the `unordered` subleading process. * Resummation can now be performed on all subleading processes within pure jets also. This includes `unordered`, `extremal qqbar` and `central qqbar` processes. #### More Physics implementation * Partons now have a Colour charge - Colours are read from and written to LHE files - For reweighted events the colours are created according to leading colour in the FKL limit -* Use relative fraction for soft transverse momentum in extremal jets (`max ext - soft pt fraction`). This supersedes `min extparton pt`, which is now - deprecated and will be removed in future versions. +* Use relative fraction for soft transverse momentum in tagging jets (`soft pt + regulator`). This supersedes `min extparton pt`, which is now **deprecated** + and will be removed in future versions. + - `soft pt regulator` is a direct replacement for the now **deprecated** `max + ext soft pt fraction` #### Updates to Runcard * Allow multiplication and division of multiple scale functions e.g. `H_T/2*m_j1j2` * Grouped `event treatment` for subleading channels together in runcard - Rename `non-HEJ` processes to `non-resummable` * Read electro-weak constants from input - new mandatory setting `vev` to change vacuum expectation value - new mandatory settings `particle properties` to specify mass & width of bosons - `HEJFOG`: decays are now specified in `decays` setting (previously under `particle properties`) * Allow loading multiple analyses with `analyses`. The old `analysis` (with "i") - is marked deprecated. + is marked **deprecated**. * Optional setting to specify maximal number of Fixed Order events (`max events`, default is all) * Allow changing the regulator lambda in input (`regulator parameter`, only for advanced users) #### Changes to Input/Output * Added support to read & write `hdf5` event files suggested in [arXiv:1905.05120](https://arxiv.org/abs/1905.05120) (needs [HighFive](https://github.com/BlueBrain/HighFive)) * Support input with average weight equal to the cross section (`IDWTUP=1 or 4`) * Support unmodified Les Houches Event Files written by Sherpa with `cross section = sum(weights)/sum(trials)` * Analyses now get general run information (`LHEF::HEPRUP`) in the constructor. **This might break previously written, external analyses!** - external analyses should now be created with `make_analysis(YAML::Node const & config, LHEF::HEPRUP const & heprup)` * Support `rivet` version 3 with both `HepMC` version 2 and 3 - Multiple weights with `rivet 3` will only create one `.yoda` file (instead of one per weight/scale) * Added option to unweight only resummation events (`unweight: {type: resummation}`) * Added option for partially unweighting resummation events, similar to the fixed-order generator. * Improved unweighting algorithm. * Follow HepMC convention for particle Status codes: incoming = 11, decaying = 2, outgoing = 1 (unchanged) #### Miscellaneous * Print cross sections at end of run * Added example analysis & scale to `examples/`. Everything in `examples/` will be build when the flag `-DBUILD_EXAMPLES=TRUE` is set in `cmake`. * Dropped support for HepMC 3.0.0, either HepMC version 2 or >3.1 is required - It is now possible to write out both HepMC 2 and HepMC 3 events at the same time * Require LHADPF version 6. Dropped support for all other versions. * Use `git-lfs` for raw data in test (`make test` now requires `git-lfs`) * Currents are now generated with [`FORM`](https://github.com/vermaseren/form) - `FORM` is included as a `git submodule`, use `git submodule update --init` to download `FORM` * Create [Sphinx](http://sphinx-doc.org/) and [Doxygen](http://doxygen.org/) documentation by `make sphinx` or `make doxygen` in your `build/` folder ## Version 2.0 First release of HEJ 2. Complete code rewrite compared to HEJ 1. Improved matching to Fixed Order ([arXiv:1805.04446](https://arxiv.org/abs/1805.04446)). Implemented processes: Higgs boson with jets (FKL and unordered gluon emission, with finite quark mass loop, [arXiv:1812.08072](https://arxiv.org/abs/1812.08072)), and pure jets (only FKL). See [arXiv:1902.08430](https://arxiv.org/abs/1902.08430) ### 2.0.6 * Fixed compiling rivet when YODA headers are _outside_ of rivet directory ### 2.0.5 * Fixed event classification for input not ordered in rapidity ### 2.0.4 * Fixed wrong path of `HEJ_INCLUDE_DIR` in `hej-config.cmake` ### 2.0.3 * Fixed parsing of (numerical factor) * (base scale) in configuration * Don't change scale names, but sanitise Rivet output file names instead ### 2.0.2 * Changed scale names to `"_over_"` and `"_times_"` for proper file names (was `"/"` and `"*"` before) ### 2.0.1 * Fixed name of fixed-order generator in error message. ### 2.0.0 * First release diff --git a/config.yml b/config.yml index c0f009b..755b212 100644 --- a/config.yml +++ b/config.yml @@ -1,126 +1,129 @@ ## Number of attempted resummation phase space points for each input event trials: 10 -## Maximum soft transverse momentum fraction in any tagging jets, i.e. +## Maximum soft transverse momentum fraction in any tagging jets, e.g. ## extremal or qqx jet soft pt regulator: 0.1 resummation jets: # resummation jet properties min pt: 30 # minimum jet transverse momentum algorithm: antikt # jet clustering algorithm R: 0.4 # jet R parameter fixed order jets: # properties of input jets min pt: 20 # by default, algorithm and R are like for resummation jets ## Treatment of he various event classes ## the supported settings are: reweight, keep, discard ## non-resummable events cannot be reweighted event treatment: FKL: reweight unordered: keep extremal qqx: keep central qqx: keep non-resummable: keep ## Central scale choice or choices # ## multiple scales are allowed, e.g. # scales: [125, max jet pperp, H_T/2, 2*jet invariant mass, m_j1j2] scales: 91.188 ## Factors by which the central scales should be multiplied ## renormalisation and factorisation scales are varied independently # # scale factors: [0.5, 0.7071, 1, 1.41421, 2] ## Maximum ratio between renormalisation and factorisation scale # # max scale ratio: 2.0001 ## Import scale setting functions # # import scales: # lib_my_scales.so: [scale0,scale1] ## Unweighting setting ## remove to obtain weighted events # unweight: # # type of unweighting (one of 'weighted', 'resummation', 'partial') # type: partial # trials: 10000 # max deviation: 0 ## Event output files # # the supported formats are # - Les Houches (suffix .lhe) # - HepMC2 (suffix .hepmc2) # - HepMC3 (suffix .hepmc3 or .hepmc) # - HDF5 (suffix .hdf5) # ## An output file's format is deduced either automatically from the suffix ## or from an explicit specification, e.g. ## - Les Houches: outfile # event output: - HEJ.lhe # - HEJ_events.hepmc ## Analyses # # analyses: ## Rivet analysis # - rivet: MC_XS # rivet analysis name # output: HEJ # name of the yoda files, ".yoda" and scale suffix will be added ## Custom analysis # - plugin: /path/to/libmyanalysis.so # my analysis parameter: some value ## Selection of random number generator and seed ## The choices are ## - mixmax (seed is an integer) ## - ranlux64 (seed is a filename containing parameters) random generator: name: mixmax # seed: 1 ## Whether or not to include higher order logs log correction: false ## Vacuum expectation value vev: 246.2196508 ## Properties of the weak gauge bosons particle properties: Higgs: mass: 125 width: 0.004165 W: mass: 80.385 width: 2.085 Z: mass: 91.187 width: 2.495 ## Parameters for Higgs-gluon couplings ## This requires compilation with QCDloop # # Higgs coupling: # use impact factors: false # mt: 174 # include bottom: true # mb: 4.7 ## ---------------------------------------------------------------------- ## ## The following settings are only intended for advanced users. ## ## Please DO NOT SET them unless you know exactly what you are doing! ## ## ---------------------------------------------------------------------- ## # ## Minimum transverse momentum of extremal partons -## deprecated: use "max ext soft pt fraction" instead +## deprecated: use "soft pt regulator" instead # min extparton pt: 30 # +## deprecated: this cot directly replaced by "soft pt regulator" +# max ext soft pt fraction: 0.1 +# # max events: -1 # Maximal number of fixed order Events to process # regulator parameter: 0.2 # The regulator lambda for the subtraction terms diff --git a/doc/sphinx/HEJ.rst b/doc/sphinx/HEJ.rst index 445e4e7..53d2683 100644 --- a/doc/sphinx/HEJ.rst +++ b/doc/sphinx/HEJ.rst @@ -1,436 +1,443 @@ .. _`Running HEJ 2`: Running HEJ 2 ============= Quick start ----------- In order to run HEJ 2, you need a configuration file and a file containing fixed-order events. A sample configuration is given by the :file:`config.yml` file distributed together with HEJ 2. Events in the Les Houches Event File format can be generated with standard Monte Carlo generators like `MadGraph5_aMC@NLO `_ or `Sherpa `_. If HEJ 2 was compiled with `HDF5 `_ support, it can also read and write event files in the format suggested in `arXiv:1905.05120 `_. HEJ 2 assumes that the cross section is given by the sum of the event weights. Depending on the fixed-order generator it may be necessary to adjust the weights in the Les Houches Event File accordingly. The processes supported by HEJ 2 are - Pure multijet production - Production of a Higgs boson with jets - Production of a W boson with jets - Production of jets with a charged lepton-antilepton pair, via a virtual Z boson or photon where at least two jets are required in each case. For the time being, only leading-order input events are supported. After generating an event file :file:`events.lhe` adjust the parameters under the `fixed order jets`_ setting in :file:`config.yml` to the settings in the fixed-order generation. Resummation can then be added by running:: HEJ config.yml events.lhe Using the default settings, this will produce an output event file :file:`HEJ.lhe` with events including high-energy resummation. When using the `Docker image `_, HEJ can be run with .. code-block:: bash docker run -v $PWD:$PWD -w $PWD hejdock/hej HEJ config.yml events.lhe .. _`HEJ 2 settings`: Settings -------- HEJ 2 configuration files follow the `YAML `_ format. The following configuration parameters are supported: .. _`trials`: **trials** High-energy resummation is performed by generating a number of resummation phase space configurations corresponding to an input fixed-order event. This parameter specifies how many such configurations HEJ 2 should try to generate for each input event. Typical values vary between 10 and 100. -.. _`max ext soft pt fraction`: +.. _`soft pt regulator`: -**max ext soft pt fraction** +**soft pt regulator** Specifies the maximum fraction that soft radiation can contribute to the - transverse momentum of each the most forward and the most backward jet. This - setting is needed to regulate an otherwise uncancelled divergence. Values - between around 0.05 and 0.1 are recommended. + transverse momentum of each the tagging jets, i.e. any jet that affects the + event classification, like the most forward and most backward jet or the jets + of the central qqx pair. This setting is needed to regulate an otherwise + uncancelled divergence. Values between around 0.05 and 0.1 are recommended. .. _`fixed order jets`: **fixed order jets** This tag collects a number of settings specifying the jet definition in the event input. The settings should correspond to the ones used in the fixed-order Monte Carlo that generated the input events. .. _`fixed order jets: min pt`: **min pt** Minimum transverse momentum in GeV of fixed-order jets. .. _`fixed order jets: algorithm`: **algorithm** The algorithm used to define jets. Allowed settings are :code:`kt`, :code:`cambridge`, :code:`antikt`, :code:`cambridge for passive`. See the `FastJet `_ documentation for a description of these algorithms. .. _`fixed order jets: R`: **R** The R parameter used in the jet algorithm, roughly corresponding to the jet radius in the plane spanned by the rapidity and the azimuthal angle. .. _`resummation jets`: **resummation jets** This tag collects a number of settings specifying the jet definition in the observed, i.e. resummed events. These settings are optional, by default the same values as for the `fixed order jets`_ are assumed. .. _`resummation jets: min pt`: **min pt** Minimum transverse momentum in GeV of resummation jets. This should be between 25% and 50% larger than the minimum transverse momentum of fixed order jets set by `fixed order jets: min pt`_. .. _`resummation jets: algorithm`: **algorithm** The algorithm used to define jets. The HEJ 2 approach to resummation relies on properties of :code:`antikt` jets, so this value is strongly recommended. For a list of possible other values, see the `fixed order jets: algorithm`_ setting. .. _`resummation jets: R`: **R** The R parameter used in the jet algorithm. .. _`event treatment`: **event treatment** Specify how to treat different event types. The different event types contribute to different orders in the high-energy limit. The possible values are :code:`reweight` to enable resummation, :code:`keep` to keep the events as they are up to a possible change of renormalisation and factorisation scale, and :code:`discard` to discard these events. The following types are implemented for the different bosons: .. csv-table:: :header: , "FKL", "unordered", "extremal qqx", "central qqx" :widths: auto :align: center :stub-columns: 1 "pure jets", "Yes", "Yes", "Yes", "Yes" "Higgs + jets", "Yes", "Yes", "No", "No" "W + jets", "Yes", "Yes", "Yes", "Yes" "Z/γ + jets", "Yes", "Yes", "No", "No" Non-implemented process will always be classified as :code:`non-resummable`. The different types are: .. _`FKL`: **FKL** Specifies how to treat events respecting FKL rapidity ordering, where all but the two partons extremal in rapidity have to be gluons, e.g. :code:`u d => u g d`. These configurations are dominant in the high-energy limit. .. _`unordered`: **unordered** Specifies how to treat events with one gluon emission that does not respect FKL ordering, e.g. :code:`u d => g u d`. In the high-energy limit, such configurations are logarithmically suppressed compared to FKL configurations. .. _`extremal qqx`: **extremal qqx** Specifies how to treat events with a quark-antiquark pair as extremal partons in rapidity, e.g. :code:`g d => u u_bar d`. In the high-energy limit, such configurations are logarithmically suppressed compared to FKL configurations. .. _`central qqx`: **central qqx** Specifies how to treat events with a quark-antiquark pair central in rapidity, e.g. :code:`g g => g u u_bar g`. In the high-energy limit, such configurations are logarithmically suppressed compared to FKL configurations. .. _`non-resummable`: **non-resummable** Specifies how to treat events that do not fall into any of the above categories or that are not yet implemented. Only :code:`keep` or :code:`discard` are valid options, *not* :code:`reweight` for obvious reasons. .. _`scales`: **scales** Specifies the renormalisation and factorisation scales for the output events. This can either be a single entry or a list :code:`[scale1, scale2, ...]`. For the case of a list the first entry defines the central scale. Possible values are fixed numbers to set the scale in GeV or the following: - :code:`H_T`: The sum of the scalar transverse momenta of all final-state particles - :code:`max jet pperp`: The maximum transverse momentum of all jets - :code:`jet invariant mass`: Sum of the invariant masses of all jets - :code:`m_j1j2`: Invariant mass between the two hardest jets. Scales can be multiplied or divided by overall factors, e.g. :code:`H_T/2`. It is also possible to import scales from an external library, see :ref:`Custom scales` .. _`scale factors`: **scale factors** A list of numeric factors by which each of the `scales`_ should be multiplied. Renormalisation and factorisation scales are varied independently. For example, a list with entries :code:`[0.5, 2]` would give the four scale choices (0.5μ\ :sub:`r`, 0.5μ\ :sub:`f`); (0.5μ\ :sub:`r`, 2μ\ :sub:`f`); (2μ\ :sub:`r`, 0.5μ\ :sub:`f`); (2μ\ :sub:`r`, 2μ\ :sub:`f`) in this order. The ordering corresponds to the order of the final event weights. .. _`max scale ratio`: **max scale ratio** Specifies the maximum factor by which renormalisation and factorisation scales may difer. For a value of :code:`2` and the example given for the `scale factors`_ the scale choices (0.5μ\ :sub:`r`, 2μ\ :sub:`f`) and (2μ\ :sub:`r`, 0.5μ\ :sub:`f`) will be discarded. .. _`log correction`: **log correction** Whether to include corrections due to the evolution of the strong coupling constant in the virtual corrections. Allowed values are :code:`true` and :code:`false`. .. _`unweight`: **unweight** Settings for unweighting events. Unweighting can greatly reduce the number of resummation events, speeding up analyses and shrinking event file sizes. .. _`type`: **type** How to unweight events. The supported settings are - :code:`weighted`: Generate weighted events. Default, if nothing else specified. - :code:`resummation`: Unweight only resummation events. Each set of resummation events coming from *a single fixed order event* are unweighted separately according to the largest weight in the current chunk of events. - :code:`partial`: Unweight only resummation events with weights below a certain threshold. The weight threshold is determined automatically in a calibration run prior to the usual event generation. .. _`unweight: trials`: **trials** Maximum number of trial resummation events generated in the calibration run for partial unweighting. This option should only be set for partial unweighting. If possible, each trial is generated from a different input fixed-order event. If there are not sufficiently many input events, more than one trial event may be generated for each of them and the actual number of trial events may be smaller than requested. Increasing the number of trials generally leads to better unweighting calibration but increases the run time. Between 1000 and 10000 trials are usually sufficient. .. _`unweight: max deviation`: **max deviation** Controls the range of events to which unweighting is applied. This option should only be set for partial unweighting. A larger value means that a larger fraction of events are unweighted. Typical values are between -1 and 1. .. _`event output`: **event output** Specifies the name of a single event output file or a list of such files. The file format is either specified explicitly or derived from the suffix. For example, :code:`events.lhe` or, equivalently :code:`Les Houches: events.lhe` generates an output event file :code:`events.lhe` in the Les Houches format. The supported formats are - :code:`file.lhe` or :code:`Les Houches: file`: The Les Houches event file format. - :code:`file.hepmc2` or :code:`HepMC2: file`: HepMC format version 2. - :code:`file.hepmc3` or :code:`HepMC3: file`: HepMC format version 3. - :code:`file.hepmc` or :code:`HepMC: file`: The latest supported version of the HepMC format, currently version 3. - :code:`file.hdf5` or :code:`HDF5: file`: The HDF5-based format of `arXiv:1905.05120 `_. .. _`random generator`: **random generator** Sets parameters for random number generation. .. _`random generator: name`: **name** Which random number generator to use. Currently, :code:`mixmax` and :code:`ranlux64` are supported. Mixmax is recommended. See the `CLHEP documentation `_ for details on the generators. .. _`random generator: seed`: **seed** The seed for random generation. This should be a single number for :code:`mixmax` and the name of a state file for :code:`ranlux64`. .. _`analyses`: **analyses** Names and settings for one or more custom and Rivet event analyses. Entries containing the :code:`rivet` key are interpreted as Rivet analyses; the values corresponding to this key should be the analyses names. In addition, there is a mandatory :code:`output` key which determines the prefix for the yoda output file. For a custom analysis the :code:`plugin` sub-entry should be set to the analysis file path. All further entries are passed on to the analysis. See :ref:`Writing custom analyses` for details. .. _`vev`: **vev** Higgs vacuum expectation value in GeV. All electro-weak constants are derived from this together with the `particle properties`_. .. _`particle properties`: **particle properties** Specifies various properties of the different particles (Higgs, W or Z). All electro-weak constants are derived from these together with the :ref:`vacuum expectation value`. .. _`particle properties: particle`: **Higgs, W or Z** The particle (Higgs, |W+| or |W-|, Z) for which the following properties are defined. .. |W+| replace:: W\ :sup:`+` .. |W-| replace:: W\ :sup:`-` .. _`particle properties: particle: mass`: **mass** The mass of the particle in GeV. .. _`particle properties: particle: width`: **width** The total decay width of the particle in GeV. .. _`Higgs coupling`: **Higgs coupling** This collects a number of settings concerning the effective coupling of the Higgs boson to gluons. This is only relevant for the production process of a Higgs boson with jets and only supported if HEJ 2 was compiled with `QCDLoop `_ support. .. _`Higgs coupling: use impact factors`: **use impact factors** Whether to use impact factors for the coupling to the most forward and most backward partons. Impact factors imply the infinite top-quark mass limit. .. _`Higgs coupling: mt`: **mt** The value of the top-quark mass in GeV. If this is not specified, the limit of an infinite mass is taken. .. _`Higgs coupling: include bottom`: **include bottom** Whether to include the Higgs coupling to bottom quarks. .. _`Higgs coupling: mb`: **mb** The value of the bottom-quark mass in GeV. Only used for the Higgs coupling, external bottom-quarks are always assumed to be massless. Advanced Settings ~~~~~~~~~~~~~~~~~ All of the following settings are optional. Please **do not set** any of the following options, unless you know exactly what you are doing. The default behaviour gives the most reliable results for a wide range of observables. .. _`min extparton pt`: **min extparton pt** Specifies the minimum transverse momentum in GeV of the most forward and the most backward parton. Its value should be slightly below the minimum transverse momentum of jets specified by `resummation jets: min pt`_. This - setting got superseded by `max ext soft pt fraction`_ and will be removed in - future versions. + setting got superseded by `soft pt regulator`_ and will be removed in future + versions. + +.. _`max ext soft pt fraction`: + +**max ext soft pt fraction** + This is the same as `soft pt regulator`_ and will be removed in future + versions. .. _`max events`: **max events** Maximal number of (input) Fixed Order events. HEJ will stop after processing `max events` many events. Default considers all events. .. _`regulator parameter`: **regulator parameter** Slicing parameter to regularise the subtraction term, called :math:`\lambda` in `arxiv:1706.01002 `_. Default is 0.2 diff --git a/include/HEJ/Config.hh b/include/HEJ/Config.hh index e8f8557..af2fbbf 100644 --- a/include/HEJ/Config.hh +++ b/include/HEJ/Config.hh @@ -1,243 +1,243 @@ /** \file * \brief HEJ 2 configuration parameters * * \authors The HEJ collaboration (see AUTHORS for details) * \date 2019-2020 * \copyright GPLv2 or later */ #pragma once #include #include #include #include #include "fastjet/JetDefinition.hh" #include "yaml-cpp/yaml.h" #include "HEJ/Constants.hh" #include "HEJ/EWConstants.hh" #include "HEJ/Fraction.hh" #include "HEJ/HiggsCouplingSettings.hh" #include "HEJ/ScaleFunction.hh" #include "HEJ/event_types.hh" #include "HEJ/optional.hh" #include "HEJ/output_formats.hh" namespace HEJ { //! Jet parameters struct JetParameters{ fastjet::JetDefinition def; /**< Jet Definition */ double min_pt{}; /**< Minimum Jet Transverse Momentum */ }; //! Settings for scale variation struct ScaleConfig{ //! Base scale choices std::vector base; //! Factors for multiplicative scale variation std::vector factors; //! Maximum ratio between renormalisation and factorisation scale double max_ratio{}; }; //! Settings for random number generator struct RNGConfig { //! Random number generator name std::string name; //! Optional initial seed optional seed; }; //! Settings for partial unweighting struct PartialUnweightConfig { //! Number of trials for training size_t trials; //! Maximum distance in standard deviations from mean logarithmic weight double max_dev; }; /**! Possible treatments for fixed-order input events. * * The program will decide on how to treat an event based on * the value of this enumeration. */ enum class EventTreatment{ reweight, /**< Perform resummation */ keep, /**< Keep the event */ discard, /**< Discard the event */ }; //! Container to store the treatments for various event types using EventTreatMap = std::map; //! Possible setting for the event weight enum class WeightType{ weighted, //!< weighted events unweighted_resum, //!< unweighted only resummation part partially_unweighted //!< mixed weighted and unweighted }; /**! Input parameters. * * This struct handles stores all configuration parameters * needed in a HEJ 2 run. * * \internal To add a new option: * 1. Add a member to the Config struct. * 2. Inside "src/YAMLreader.cc": * - Add the option name to the "supported" Node in * get_supported_options. * - Initialise the new Config member in to_Config. * The functions set_from_yaml (for mandatory options) and * set_from_yaml_if_defined (non-mandatory) may be helpful. * 3. Add a new entry (with short description) to config.yaml * 4. Update the user documentation in "doc/Sphinx/" */ struct Config { //! %Parameters for scale variation ScaleConfig scales; //! Resummation jet properties JetParameters resummation_jets; //! Fixed-order jet properties JetParameters fixed_order_jets; //! Minimum transverse momentum for extremal partons //! \deprecated This will be removed in future versions. //! Use \ref soft_pt_regulator instead. double min_extparton_pt = 0.; //! \deprecated This is equivalent to\ref soft_pt_regulator //! and will be removed in future versions. optional> max_ext_soft_pt_fraction{}; //! @brief Maximum transverse momentum fraction from soft radiation in any - //! tagging jet (i.e. extremal or qqx jet) + //! tagging jet (e.g. extremal or qqx jet) Fraction soft_pt_regulator{}; //! The regulator lambda for the subtraction terms double regulator_lambda = CLAMBDA; //! Number of resummation configurations to generate per fixed-order event size_t trials{}; //! Maximal number of events optional max_events; //! Whether to include the logarithmic correction from \f$\alpha_s\f$ running bool log_correction{}; //! Event output files names and formats std::vector output; //! Parameters for random number generation RNGConfig rng; //! Map to decide what to do for different event types EventTreatMap treat; //! %Parameters for custom analysis //! @deprecated use analyses_parameters instead YAML::Node analysis_parameters; //! %Parameters for custom analyses std::vector analyses_parameters; //! Settings for effective Higgs-gluon coupling HiggsCouplingSettings Higgs_coupling; //! elector weak parameters EWConstants ew_parameters; //! Type of event weight e.g. (un)weighted WeightType weight_type; //! Settings for partial unweighting optional unweight_config; }; //! Configuration options for the PhaseSpacePoint class struct PhaseSpacePointConfig { //! Properties of resummation jets JetParameters jet_param; //! Minimum transverse momentum for extremal partons //! \deprecated This will be removed in future versions. //! Use \ref soft_pt_regulator instead. double min_extparton_pt = 0; //! \deprecated This is equivalent to\ref soft_pt_regulator //! and will be removed in future versions. optional> max_ext_soft_pt_fraction{}; //! @brief Maximum transverse momentum fraction from soft radiation in any - //! tagging jet (i.e. extremal or qqx jet) + //! tagging jet (e.g. extremal or qqx jet) Fraction soft_pt_regulator{}; }; //! Configuration options for the MatrixElement class struct MatrixElementConfig { MatrixElementConfig() = default; MatrixElementConfig( bool log_correction, HiggsCouplingSettings Higgs_coupling, EWConstants ew_parameters, double regulator_lambda = CLAMBDA ): log_correction{log_correction}, Higgs_coupling{std::move(Higgs_coupling)}, ew_parameters{std::move(ew_parameters)}, regulator_lambda{regulator_lambda} {} //! Whether to include the logarithmic correction from \f$\alpha_s\f$ running bool log_correction{}; //! Settings for effective Higgs-gluon coupling HiggsCouplingSettings Higgs_coupling; //! elector weak parameters EWConstants ew_parameters; //! The regulator lambda for the subtraction terms double regulator_lambda = CLAMBDA; }; //! Configuration options for the EventReweighter class struct EventReweighterConfig { //! Settings for phase space point generation PhaseSpacePointConfig psp_config; //! Settings for matrix element calculation MatrixElementConfig ME_config; //! Access properties of resummation jets JetParameters & jet_param() { return psp_config.jet_param;} //! Access properties of resummation jets (const version) JetParameters const & jet_param() const { return psp_config.jet_param;} //! Treatment of the various event types EventTreatMap treat; }; /**! Extract PhaseSpacePointConfig from Config * * \internal We do not provide a PhaseSpacePointConfig constructor from Config * so that PhaseSpacePointConfig remains an aggregate. * This faciliates writing client code (e.g. the HEJ fixed-order generator) * that creates a PhaseSpacePointConfig *without* a Config object. * * @see to_MatrixElementConfig, to_EventReweighterConfig */ inline PhaseSpacePointConfig to_PhaseSpacePointConfig(Config const & conf) { return { conf.resummation_jets, conf.min_extparton_pt, conf.max_ext_soft_pt_fraction, conf.soft_pt_regulator }; } /**! Extract MatrixElementConfig from Config * * @see to_PhaseSpacePointConfig, to_EventReweighterConfig */ inline MatrixElementConfig to_MatrixElementConfig(Config const & conf) { return {conf.log_correction, conf.Higgs_coupling, conf.ew_parameters, conf.regulator_lambda}; } /**! Extract EventReweighterConfig from Config * * @see to_PhaseSpacePointConfig, to_MatrixElementConfig */ inline EventReweighterConfig to_EventReweighterConfig(Config const & conf) { return { to_PhaseSpacePointConfig(conf), to_MatrixElementConfig(conf), conf.treat }; } } // namespace HEJ diff --git a/t/ME_data/config_Z_ME.yml b/t/ME_data/config_Z_ME.yml index 7299251..41dba21 100644 --- a/t/ME_data/config_Z_ME.yml +++ b/t/ME_data/config_Z_ME.yml @@ -1,39 +1,39 @@ trials: 1 -max ext soft pt fraction: 0.1 +soft pt regulator: 0.1 resummation jets: min pt: 30 algorithm: antikt R: 0.4 fixed order jets: min pt: 30 event treatment: FKL: reweight unordered: reweight extremal qqx: reweight central qqx: reweight non-resummable: discard scales: H_T/2 log correction: false vev: 246.219650794137 particle properties: Higgs: mass: 125 width: 0.004165 W: mass: 80.385 width: 2.085 Z: mass: 91.1876 width: 2.495 random generator: name: mixmax seed: 1 diff --git a/t/ME_data/config_mt.yml b/t/ME_data/config_mt.yml index 5e1be8d..0baabe0 100644 --- a/t/ME_data/config_mt.yml +++ b/t/ME_data/config_mt.yml @@ -1,44 +1,44 @@ trials: 1 -max ext soft pt fraction: 0.1 +soft pt regulator: 0.1 resummation jets: min pt: 30 algorithm: antikt R: 0.4 fixed order jets: min pt: 30 event treatment: FKL: reweight unordered: reweight extremal qqx: discard central qqx: discard non-resummable: discard scales: 125 log correction: false random generator: name: mixmax seed: 1 vev: 246.2196508 particle properties: Higgs: mass: 125 width: 0.004165 W: mass: 80.385 width: 2.085 Z: mass: 91.187 width: 2.495 Higgs coupling: use impact factors: false mt: 174 include bottom: false diff --git a/t/ME_data/config_mtinf.yml b/t/ME_data/config_mtinf.yml index 3f87d26..bf179bd 100644 --- a/t/ME_data/config_mtinf.yml +++ b/t/ME_data/config_mtinf.yml @@ -1,39 +1,39 @@ trials: 1 -max ext soft pt fraction: 0.1 +soft pt regulator: 0.1 resummation jets: min pt: 30 algorithm: antikt R: 0.4 fixed order jets: min pt: 30 event treatment: FKL: reweight unordered: reweight extremal qqx: discard central qqx: discard non-resummable: discard scales: 125 log correction: false vev: 246.2196508 particle properties: Higgs: mass: 125 width: 0.004165 W: mass: 80.385 width: 2.085 Z: mass: 91.187 width: 2.495 random generator: name: mixmax seed: 1 diff --git a/t/ME_data/config_mtmb.yml b/t/ME_data/config_mtmb.yml index 924f524..a395f7d 100644 --- a/t/ME_data/config_mtmb.yml +++ b/t/ME_data/config_mtmb.yml @@ -1,45 +1,45 @@ trials: 1 -max ext soft pt fraction: 0.1 +soft pt regulator: 0.1 resummation jets: min pt: 30 algorithm: antikt R: 0.4 fixed order jets: min pt: 30 event treatment: FKL: reweight unordered: reweight extremal qqx: discard central qqx: discard non-resummable: discard scales: 125 log correction: false random generator: name: mixmax seed: 1 vev: 246.2196508 particle properties: Higgs: mass: 125 width: 0.004165 W: mass: 80.385 width: 2.085 Z: mass: 91.187 width: 2.495 Higgs coupling: use impact factors: false mt: 174 include bottom: true mb: 4.7 diff --git a/t/ME_data/config_pure.yml b/t/ME_data/config_pure.yml index 7a46e16..e28fb6a 100644 --- a/t/ME_data/config_pure.yml +++ b/t/ME_data/config_pure.yml @@ -1,39 +1,39 @@ trials: 1 -max ext soft pt fraction: 0.1 +soft pt regulator: 0.1 resummation jets: min pt: 30 algorithm: antikt R: 0.4 fixed order jets: min pt: 30 event treatment: FKL: reweight unordered: reweight extremal qqx: reweight central qqx: discard non-resummable: discard scales: 125 log correction: false vev: 246.2196508 particle properties: Higgs: mass: 125 width: 0.004165 W: mass: 80.419 width: 2.0476 Z: mass: 91.187 width: 2.495 random generator: name: mixmax seed: 1 diff --git a/t/ME_data/config_w_ME.yml b/t/ME_data/config_w_ME.yml index d0da43a..a3216f7 100644 --- a/t/ME_data/config_w_ME.yml +++ b/t/ME_data/config_w_ME.yml @@ -1,39 +1,39 @@ trials: 1 -max ext soft pt fraction: 0.1 +soft pt regulator: 0.1 resummation jets: min pt: 30 algorithm: antikt R: 0.4 fixed order jets: min pt: 30 event treatment: FKL: reweight unordered: reweight extremal qqx: reweight central qqx: reweight non-resummable: discard scales: 125 log correction: false vev: 246.2196508 particle properties: Higgs: mass: 125 width: 0.004165 W: mass: 80.419 width: 2.0476 Z: mass: 91.187 width: 2.495 random generator: name: mixmax seed: 1 diff --git a/t/analysis_config.yml b/t/analysis_config.yml index 743e148..34e9bcc 100644 --- a/t/analysis_config.yml +++ b/t/analysis_config.yml @@ -1,43 +1,43 @@ trials: 10 -max ext soft pt fraction: 0.1 +soft pt regulator: 0.1 resummation jets: min pt: 35 algorithm: antikt R: 0.4 fixed order jets: min pt: 30 event treatment: FKL: reweight unordered: discard extremal qqx: reweight central qqx: discard non-resummable: keep log correction: false scales: 125 random generator: name: mixmax seed: 11 vev: 246.2196508 particle properties: Higgs: mass: 125 width: 0.004165 W: mass: 80.385 width: 2.085 Z: mass: 91.187 width: 2.495 max events: 100 analyses: diff --git a/t/analysis_config_single.yml.in b/t/analysis_config_single.yml.in index 50cc70e..1e4d0dc 100644 --- a/t/analysis_config_single.yml.in +++ b/t/analysis_config_single.yml.in @@ -1,45 +1,45 @@ trials: 10 -max ext soft pt fraction: 0.1 +soft pt regulator: 0.1 resummation jets: min pt: 35 algorithm: antikt R: 0.4 fixed order jets: min pt: 30 event treatment: FKL: reweight unordered: discard extremal qqx: reweight central qqx: discard non-resummable: keep log correction: false scales: 125 random generator: name: mixmax seed: 11 vev: 246.2196508 particle properties: Higgs: mass: 125 width: 0.004165 W: mass: 80.385 width: 2.085 Z: mass: 91.187 width: 2.495 analysis: plugin: @ANALYSIS_PATH@/lib@ANALYSIS_LIB@.so @ANALYSIS_PARAMETERS@ max events: 100 diff --git a/t/check_res.cc b/t/check_res.cc index 177d5e2..989af4c 100644 --- a/t/check_res.cc +++ b/t/check_res.cc @@ -1,166 +1,166 @@ /** * \authors The HEJ collaboration (see AUTHORS for details) * \date 2019-2020 * \copyright GPLv2 or later */ #include "hej_test.hh" #include #include #include #include #include #include #include #include #include "HEJ/Config.hh" #include "HEJ/CrossSectionAccumulator.hh" #include "HEJ/Event.hh" #include "HEJ/event_types.hh" #include "HEJ/EventReweighter.hh" #include "HEJ/EWConstants.hh" #include "HEJ/Fraction.hh" #include "HEJ/HiggsCouplingSettings.hh" #include "HEJ/Mixmax.hh" #include "HEJ/Parameters.hh" #include "HEJ/ScaleFunction.hh" #include "HEJ/stream.hh" #include "fastjet/JetDefinition.hh" #include "LHEF/LHEF.h" namespace HEJ { struct RNG; } namespace { const fastjet::JetDefinition JET_DEF{fastjet::kt_algorithm, 0.4}; const fastjet::JetDefinition BORN_JET_DEF{JET_DEF}; constexpr double BORN_JETPTMIN = 30; - const HEJ::Fraction MAX_EXT_SOFT_PT_FRACTION{0.1}; + const HEJ::Fraction SOFT_PT_REGULATOR{0.1}; constexpr double JETPTMIN = 35; constexpr bool LOG_CORR = false; constexpr std::size_t NUM_TRIES = 100; constexpr HEJ::ParticleProperties WPROP{80.385, 2.085}; constexpr HEJ::ParticleProperties ZPROP{91.187, 2.495}; constexpr HEJ::ParticleProperties HPROP{125, 0.004165}; constexpr double VEV = 246.2196508; using EventTreatment = HEJ::EventTreatment; using namespace HEJ::event_type; HEJ::EventTreatMap TREAT{ {no_2_jets, EventTreatment::discard}, {bad_final_state, EventTreatment::discard}, {non_resummable, EventTreatment::discard}, {unof, EventTreatment::discard}, {unob, EventTreatment::discard}, {qqxexb, EventTreatment::discard}, {qqxexf, EventTreatment::discard}, {qqxmid, EventTreatment::discard}, {FKL, EventTreatment::reweight} }; bool correct_colour(HEJ::Event const & ev){ if(!HEJ::event_type::is_resummable(ev.type())) return true; return ev.is_leading_colour(); } } // namespace int main(int argn, char** argv) { if(argn == 5 && std::string(argv[4]) == "unof"){ --argn; TREAT[unof] = EventTreatment::reweight; TREAT[unob] = EventTreatment::discard; TREAT[FKL] = EventTreatment::discard; } if(argn == 5 && std::string(argv[4]) == "unob"){ --argn; TREAT[unof] = EventTreatment::discard; TREAT[unob] = EventTreatment::reweight; TREAT[FKL] = EventTreatment::discard; } else if(argn == 5 && std::string(argv[4]) == "splitf"){ --argn; TREAT[qqxexb] = EventTreatment::discard; TREAT[qqxexf] = EventTreatment::reweight; TREAT[FKL] = EventTreatment::discard; } else if(argn == 5 && std::string(argv[4]) == "splitb"){ --argn; TREAT[qqxexb] = EventTreatment::reweight; TREAT[qqxexf] = EventTreatment::discard; TREAT[FKL] = EventTreatment::discard; } else if(argn == 5 && std::string(argv[4]) == "qqxmid"){ --argn; TREAT[qqxmid] = EventTreatment::reweight; TREAT[FKL] = EventTreatment::discard; } if(argn != 4){ std::cerr << "Usage: check_res eventfile xsection tolerance [uno]"; return EXIT_FAILURE; } const double xsec_ref = std::stod(argv[2]); const double tolerance = std::stod(argv[3]); HEJ::istream in{argv[1]}; LHEF::Reader reader{in}; HEJ::PhaseSpacePointConfig psp_conf; psp_conf.jet_param = HEJ::JetParameters{JET_DEF, JETPTMIN}; - psp_conf.max_ext_soft_pt_fraction = MAX_EXT_SOFT_PT_FRACTION; + psp_conf.soft_pt_regulator = SOFT_PT_REGULATOR; HEJ::MatrixElementConfig ME_conf; ME_conf.log_correction = LOG_CORR; ME_conf.Higgs_coupling = HEJ::HiggsCouplingSettings{}; ME_conf.ew_parameters.set_vevWZH(VEV, WPROP, ZPROP, HPROP); HEJ::EventReweighterConfig conf; conf.psp_config = std::move(psp_conf); conf.ME_config = std::move(ME_conf); conf.treat = TREAT; reader.readEvent(); const bool has_Higgs = std::find( begin(reader.hepeup.IDUP), end(reader.hepeup.IDUP), 25 ) != end(reader.hepeup.IDUP); const double mu = has_Higgs?125.:91.188; HEJ::ScaleGenerator scale_gen{ {{std::to_string(mu), HEJ::FixedScale{mu}}}, {}, 1. }; std::shared_ptr ran{std::make_shared()}; HEJ::EventReweighter hej{reader.heprup, std::move(scale_gen), conf, ran}; HEJ::CrossSectionAccumulator xs; do{ auto ev_data = HEJ::Event::EventData{reader.hepeup}; shuffle_particles(ev_data); ev_data.reconstruct_intermediate(); HEJ::Event ev{ ev_data.cluster( BORN_JET_DEF, BORN_JETPTMIN ) }; auto resummed_events = hej.reweight(ev, NUM_TRIES); for(auto const & res_ev: resummed_events) { ASSERT(correct_colour(res_ev)); ASSERT(std::isfinite(res_ev.central().weight)); // we fill the xs uncorrelated since we only want to test the uncertainty // of the resummation xs.fill(res_ev); } } while(reader.readEvent()); const double xsec = xs.total().value; const double xsec_err = std::sqrt(xs.total().error); const double significance = std::abs(xsec - xsec_ref) / std::sqrt( xsec_err*xsec_err + tolerance*tolerance ); std::cout << xsec_ref << " +/- " << tolerance << " ~ " << xsec << " +- " << xsec_err << " => " << significance << " sigma\n"; if(significance > 3.){ std::cerr << "Cross section is off by over 3 sigma!\n"; return EXIT_FAILURE; } return EXIT_SUCCESS; } diff --git a/t/jet_config.yml b/t/jet_config.yml index 0c4cd69..1c69f84 100644 --- a/t/jet_config.yml +++ b/t/jet_config.yml @@ -1,51 +1,51 @@ trials: 10 -max ext soft pt fraction: 0.1 +soft pt regulator: 0.1 resummation jets: min pt: 35 algorithm: antikt R: 0.4 fixed order jets: min pt: 30 event treatment: FKL: reweight unordered: keep extremal qqx: discard central qqx: keep non-resummable: keep log correction: false scales: [125, 91.188] scale factors: [0.5, 1, 2] max scale ratio: 2.0001 random generator: name: mixmax seed: 1024 vev: 246.2196508 particle properties: Higgs: mass: 125 width: 0.004165 W: mass: 80.385 width: 2.085 Z: mass: 91.187 width: 2.495 max events: 500 unweight: type: partial trials: 100 max deviation: -1 event output: - tst.lhe diff --git a/t/jet_config_with_import.yml.in b/t/jet_config_with_import.yml.in index 7cc8733..040b49e 100644 --- a/t/jet_config_with_import.yml.in +++ b/t/jet_config_with_import.yml.in @@ -1,44 +1,44 @@ trials: 10 -max ext soft pt fraction: 0.1 +soft pt regulator: 0.1 resummation jets: min pt: 35 algorithm: antikt R: 0.4 fixed order jets: min pt: 30 event treatment: FKL: reweight unordered: discard extremal qqx: discard central qqx: discard non-resummable: discard log correction: false scales: @SCALE_NAME@ event output: - tst.lhe random generator: name: ranlux64 vev: 246.2196508 particle properties: Higgs: mass: 125 width: 0.004165 W: mass: 80.385 width: 2.085 Z: mass: 91.187 width: 2.495 import scales: @SCALE_PATH@/lib@SCALE_LIB@.so: @SCALE_NAME@ diff --git a/t/test_jet_cuts.cc b/t/test_jet_cuts.cc index 6f2181c..0e51e3e 100644 --- a/t/test_jet_cuts.cc +++ b/t/test_jet_cuts.cc @@ -1,309 +1,309 @@ /** * \authors The HEJ collaboration (see AUTHORS for details) * \date 2019-2020 * \copyright GPLv2 or later */ #include "hej_test.hh" #include #include #include #include #include #include "HEJ/Event.hh" #include "HEJ/event_types.hh" #include "fastjet/JetDefinition.hh" namespace { const fastjet::JetDefinition JET_DEF{fastjet::JetAlgorithm::antikt_algorithm, 0.4}; const double MIN_JET_PT{30.}; - const double MAX_EXT_SOFT_PT_FRACTION{0.4}; + const double SOFT_PT_REGULATOR{0.4}; bool correct( bool const expected, std::array const & in, std::vector const & out, int const overwrite_boson ){ HEJ::Event ev{ parse_configuration( in,out,overwrite_boson ).cluster(JET_DEF, MIN_JET_PT)}; ASSERT(is_resummable(ev.type())); // only test jet configurations - if(ev.valid_hej_state(MAX_EXT_SOFT_PT_FRACTION) != expected){ + if(ev.valid_hej_state(SOFT_PT_REGULATOR) != expected){ std::cerr << "Expected " << (expected?"valid":"invalid") << " but found " - << (ev.valid_hej_state(MAX_EXT_SOFT_PT_FRACTION)?"valid":"invalid") + << (ev.valid_hej_state(SOFT_PT_REGULATOR)?"valid":"invalid") << " jets (" << overwrite_boson << ")\n" << ev; auto jet_idx{ ev.particle_jet_indices() }; std::cout << "Particle Jet indices: "; for(int const i: jet_idx) std::cout << i << " "; std::cout << std::endl; return false; } return true; } // valid jet configurations bool valid_jets(){ // FKL // extremal parton inside jet for(int i=-3; i>-13;--i){ std::array base_in{"g","g"}; std::vector base_out(7, "g"); if(!correct(true, base_in, base_out, i)) return false; } // replace one of the extremal with a boson if( !( correct(true,{"g","d"},{"g","g","g","g","g","d","h"}, -13) && correct(true,{"d","d"},{"d","g","g","g","g","d","h"}, -13) && correct(true,{"2","2"},{"1","g","g","g","g","2","Wp"},-14) )) return false; // uno if( !( correct(true,{"g","3"},{"h","g","g","g","g","3","g"}, -1) && correct(true,{"3","2"},{"Wp","g","3","g","g","g","1"}, -1) && correct(true,{"1","2"},{"Wm","g","2","g","g","g","2"}, -1) && correct(true,{"1","3"},{"1","g","g","g","g","3","g"}, -3) && correct(true,{"-1","3"},{"-1","g","g","g","g","3","g"},-5) && correct(true,{"3","-2"},{"g","3","g","g","g","g","-2"},-5) && correct(true,{"-3","3"},{"g","-3","g","g","g","g","3"},-6) && correct(true,{"-4","3"},{"-4","g","g","g","g","3","g"},-7) && correct(true,{"3","-5"},{"g","3","g","g","g","g","-5"},-7) && correct(true,{"g","3"},{"g","g","g","g","g","3","g"}, -8) && correct(true,{"3","g"},{"g","3","g","g","g","g","g"}, -8) && correct(true,{"2","3"},{"g","1","g","Wp","g","g","3"}, -9) && correct(true,{"2","3"},{"1","g","g","g","3","Wp","g"}, -9) && correct(true,{"2","3"},{"1","g","Wp","g","g","3","g"}, -10) && correct(true,{"3","g"},{"g","3","g","g","g","g","g"}, -11) && correct(true,{"1","3"},{"1","g","g","g","g","3","g"}, -12) && correct(true,{"3","2"},{"g","3","g","g","g","g","2"}, -12) && correct(true,{"3","g"},{"g","3","g","g","g","g","h"}, -13) && correct(true,{"2","3"},{"1","g","g","g","3","g","Wp"}, -13) && correct(true,{"2","3"},{"g","1","g","g","g","3","Wp"}, -14) )) return false; // extremal qqx if( !( correct(true,{"2","g"},{"1","Wp","g","g","g","1","-1"}, -3) && correct(true,{"2","g"},{"1","Wp","g","g","g","1","-1"}, -5) && correct(true,{"g","2"},{"1","-1","g","Wp","g","g","1"}, -5) && correct(true,{"2","g"},{"1","g","g","g","Wp","1","-1"}, -7) && correct(true,{"g","2"},{"1","-1","g","g","g","Wp","1"}, -7) && correct(true,{"2","g"},{"1","Wp","g","g","g","1","-1"}, -8) && correct(true,{"g","2"},{"1","-1","Wp","g","g","g","1"}, -8) && correct(true,{"g","2"},{"1","-1","g","Wp","g","g","1"}, -9) && correct(true,{"g","3"},{"-2","1","g","Wp","g","g","3"}, -9) && correct(true,{"2","g"},{"1","g","g","g","3","Wp","-3"}, -9) && correct(true,{"2","g"},{"1","g","Wp","g","g","-3","3"}, -10) && correct(true,{"2","g"},{"1","g","g","g","Wp","1","-1"}, -12) && correct(true,{"g","2"},{"1","-1","g","Wp","g","g","1"}, -12) && correct(true,{"2","g"},{"1","g","g","g","-3","3","Wp"}, -13) && correct(true,{"g","g"},{"-2","1","g","g","g","g","Wp"}, -14) // pure jets && correct(true,{"-3","g"},{"-3","g","g","g","g","-3","3"}, -3) && correct(true,{"-3","g"},{"-3","g","g","g","g","-3","3"}, -5) && correct(true,{"g","-3"},{"-3","3","g","g","g","g","-3"}, -5) && correct(true,{"g","-3"},{"-3","3","g","g","g","g","-3"}, -6) && correct(true,{"-3","g"},{"-3","g","g","g","g","-3","3"}, -7) && correct(true,{"g","-3"},{"-3","3","g","g","g","g","-3"}, -7) && correct(true,{"-3","g"},{"-3","g","g","g","g","-3","3"}, -8) && correct(true,{"g","-3"},{"-3","3","g","g","g","g","-3"}, -8) && correct(true,{"g","-3"},{"-3","3","g","g","g","g","-3"}, -11) && correct(true,{"-3","g"},{"-3","g","g","g","g","-3","3"}, -12) && correct(true,{"g","-3"},{"-3","3","g","g","g","g","-3"}, -12) )) return false; // central qqx if( !( correct(true,{"1","g"},{"2","g","-2","Wm","2","g","g"}, -3) && correct(true,{"1","g"},{"2","g","g","-2","2","Wm","g"}, -4) && correct(true,{"1","g"},{"2","g","g","Wm","-2","2","g"}, -5) && correct(true,{"1","g"},{"2","g","g","Wm","-2","2","g"}, -8) && correct(true,{"1","g"},{"2","Wm","g","-2","2","g","g"}, -9) && correct(true,{"1","g"},{"2","Wm","-2","2","g","g","g"}, -9) && correct(true,{"1","g"},{"2","g","g","-2","2","Wm","g"}, -10) && correct(true,{"1","g"},{"2","g","Wm","2","-2","g","g"}, -11) && correct(true,{"1","g"},{"2","g","g","-2","2","g","Wm"}, -12) && correct(true,{"1","g"},{"2","2","-2","g","g","g","Wm"}, -13) && correct(true,{"1","g"},{"2","2","-2","g","g","g","Wm"}, -14) // pure jets && correct(true,{"1","-1"},{"1","g","g","-1","1","g","-1"}, -4) && correct(true,{"1","-1"},{"1","g","g","-1","1","g","-1"}, -10) )) return false; return true; } // invalid jet configurations bool invalid_jets(){ // processes failing jet cuts // FKL if( !( true && correct(false,{"1","g"}, {"g","1","g","g","g","g","g"}, -1) // FKL not in own jet && correct(false,{"1","1"}, {"1","g","g","g","g","g","1"}, -1) && correct(false,{"g","g"}, {"g","g","g","g","g","g","g"}, -2) && correct(false,{"1","-3"},{"1","g","g","g","g","-3","g"}, -1) && correct(false,{"2","g"}, {"g","2","g","g","g","g","g"}, -2) // FKL below pt && correct(false,{"1","1"}, {"1","g","g","g","g","g","1"}, -13) && correct(false,{"g","3"},{"h","g","g","g","g","3","g"}, -13) && correct(false,{"g","1"},{"Wm","g","g","g","g","2","g"}, -13) && correct(false,{"3","1"},{"Wm","g","3","g","g","g","2"}, -13) // uno in same jet as FKL && correct(false,{"-1","1"},{"-1","g","g","g","g","1","g"}, -9) && correct(false,{"3","3"}, {"g","3","g","g","g","g","3"}, -9) && correct(false,{"-1","1"},{"g","-1","g","g","g","g","1"}, -10) && correct(false,{"-1","1"},{"-1","g","g","g","g","1","g"}, -13) && correct(false,{"-1","1"},{"g","-1","g","g","g","g","1"}, -13) // FKL not in jet & uno other side && correct(false,{"2","3"},{"Wp","1","g","g","g","3","g"}, -15) )) return false; // uno if( !( true // uno backward not in jet && correct(false,{"1","2"}, {"g","1","g","g","g","g","2"}, -1) // uno forward not in jet && correct(false,{"3","3"}, {"3","g","g","g","g","3","g"}, -2) // uno backward in same jet && correct(false,{"1","g"}, {"g","1","g","g","g","g","g"}, -3) // uno forward in same jet && correct(false,{"3","2"}, {"3","g","g","g","g","2","g"}, -4) // uno backward below pt && correct(false,{"3","g"}, {"g","3","g","g","g","g","g"}, -4) // uno forward below pt && correct(false,{"4","3"}, {"4","g","g","g","g","3","g"}, -10) && correct(false,{"2","3"}, {"1","g","g","g","3","g","Wp"}, -14) // uno forward not in jet && correct(false,{"5","3"}, {"5","g","g","g","g","3","g"}, -11) )) return false; // extremal qqx if( !( true // qqxf in same jet && correct(false,{"g","g"}, {"Wm","g","g","g","g","-1","2"}, -4) // qqxb below pt && correct(false,{"g","2"},{"1","-1","g","Wp","g","g","1"}, -4) // central qqx not in jet && correct(false,{"1","2"}, {"1","g","-2","2","Wp","g","1"}, -5) // central qqx in same jet && correct(false,{"1","2"}, {"1","-2","2","g","Wp","g","1"}, -6) // central qqx in same jet && correct(false,{"1","2"}, {"1","Wm","g","g","2","-1","2"}, -6) // qqxf below pt && correct(false,{"2","g"},{"1","g","Wp","g","g","1","-1"}, -6) // central qqx in same jet && correct(false,{"1","2"}, {"1","-1","1","g","g","Wp","1"}, -7) // central qqx in same jet && correct(false,{"1","2"}, {"1","Wp","g","3","-3","g","1"}, -7) // central qqx in same jet && correct(false,{"g","3"}, {"g","Wp","-2","1","g","g","3"}, -8) // central qqx in same jet && correct(false,{"g","-2"},{"Wm","g","g","2","-1","g","-2"}, -8) // qqxf below pt && correct(false,{"2","g"},{"1","g","g","g","Wp","1","-1"}, -10) // qqxf outside jet && correct(false,{"2","g"},{"1","g","g","g","Wp","1","-1"}, -11) // extremal qqx in same jet as FKL && correct(false,{"-1","g"},{"-1","g","Wm","g","g","2","-1"},-9) && correct(false,{"g","1"}, {"2","-1","g","g","g","Wm","1"}, -10) // extraml qqx below pt && correct(false,{"-1","g"},{"-1","Wm","g","g","g","-1","2"},-13) && correct(false,{"g","g"}, {"g","g","g","g","-1","Wm","2"}, -14) && correct(false,{"g","g"}, {"-1","2","g","g","g","g","Wm"}, -15) // pure jets && correct(false,{"2","g"}, {"2","g","g","g","g","2","-2"}, -1) && correct(false,{"g","2"}, {"2","-2","g","g","g","g","2"}, -1) && correct(false,{"g","-2"},{"4","-4","g","g","g","g","-2"}, -2) // qqx backward not in jet && correct(false,{"g","g"}, {"g","g","g","g","g","-2","2"}, -2) // qqx backward in same jet && correct(false,{"g","2"}, {"-4","4","g","g","g","g","2"}, -3) && correct(false,{"-3","g"},{"-3","g","g","g","g","-3","3"}, -4) && correct(false,{"g","-3"},{"-3","3","g","g","g","g","-3"}, -4) && correct(false,{"-3","g"},{"-3","g","g","g","g","-3","3"}, -6) && correct(false,{"g","-3"},{"-3","3","g","g","g","g","-3"}, -9) && correct(false,{"-3","g"},{"-3","g","g","g","g","-3","3"}, -9) && correct(false,{"g","-3"},{"-3","3","g","g","g","g","-3"}, -10) && correct(false,{"-3","g"},{"-3","g","g","g","g","-3","3"}, -10) && correct(false,{"-3","g"},{"-3","g","g","g","g","-3","3"}, -11) && correct(false,{"-3","g"},{"-3","g","g","g","g","-3","3"}, -13) && correct(false,{"g","-3"},{"-3","3","g","g","g","g","-3"}, -13) && correct(false,{"-3","g"},{"-3","g","g","g","g","-3","3"}, -14) && correct(false,{"g","-3"},{"-3","3","g","g","g","g","-3"}, -14) && correct(false,{"-3","g"},{"-3","g","g","g","g","-3","3"}, -15) && correct(false,{"g","-3"},{"-3","3","g","g","g","g","-3"}, -15) )) return false; // central qqx if( !( true && correct(false,{"1","g"}, {"2","Wm","-2","2","g","g","g"}, -3) && correct(false,{"1","g"}, {"2","g","Wm","-2","2","g","g"}, -3) && correct(false,{"1","g"}, {"2","-2","2","g","Wm","g","g"}, -4) && correct(false,{"-1","g"},{"-1","g","g","Wp","1","-2","g"}, -4) && correct(false,{"-1","g"},{"-1","1","-2","g","g","Wp","g"}, -5) && correct(false,{"-1","g"},{"-1","g","1","-2","g","Wp","g"}, -5) && correct(false,{"-1","g"},{"-1","g","g","1","-2","Wp","g"}, -5) && correct(false,{"1","g"}, {"2","g","g","Wm","2","-2","g"}, -6) && correct(false,{"1","g"}, {"2","g","Wm","-2","2","g","g"}, -6) && correct(false,{"g","4"}, {"g","g","-4","4","g","Wp","3"}, -6) && correct(false,{"1","g"}, {"2","g","Wm","g","-2","2","g"}, -7) && correct(false,{"g","4"}, {"g","g","-4","4","g","Wp","3"}, -7) && correct(false,{"g","4"}, {"g","Wp","g","-4","4","g","3"}, -7) && correct(false,{"1","g"}, {"2","-2","2","Wm","g","g","g"}, -8) && correct(false,{"g","4"}, {"g","-4","4","g","Wp","g","3"}, -8) && correct(false,{"g","g"}, {"g","g","g","g","-2","1","Wp"}, -9) && correct(false,{"1","g"}, {"2","-2","2","g","Wm","g","g"}, -9) && correct(false,{"1","g"}, {"2","g","-2","2","g","Wm","g"}, -9) && correct(false,{"1","g"}, {"2","g","g","Wm","-2","2","g"}, -10) && correct(false,{"g","g"}, {"g","1","-2","Wp","g","g","g"}, -10) && correct(false,{"g","1"}, {"g","g","Wp","g","-2","1","1"}, -11) && correct(false,{"1","g"}, {"2","g","Wm","g","-2","2","g"}, -11) && correct(false,{"1","g"}, {"2","Wm","g","-2","2","g","g"}, -12) && correct(false,{"3","2"}, {"3","g","-1","2","Wm","g","2"}, -12) && correct(false,{"3","-2"},{"3","-1","2","g","g","Wm","-2"}, -13) && correct(false,{"3","-2"},{"3","-1","2","g","g","Wm","-2"}, -14) && correct(false,{"3","-2"},{"3","g","g","-1","2","Wm","-2"}, -14) && correct(false,{"1","g"}, {"Wm","2","2","-2","g","g","g"}, -15) && correct(false,{"3","-2"},{"3","-1","2","g","g","-2","Wm"}, -15) // pure jets && correct(false,{"-1","g"},{"-1","1","-1","g","g","g","g"}, -1) && correct(false,{"4","-3"},{"4","g","g","1","-1","g","-3"}, -2) && correct(false,{"1","-1"},{"1","g","-1","1","g","g","-1"}, -3) && correct(false,{"1","-1"},{"1","g","g","-1","1","g","-1"}, -3) && correct(false,{"1","-1"},{"1","g","g","g","-1","1","-1"}, -3) && correct(false,{"1","-1"},{"1","g","g","g","-1","1","-1"}, -4) && correct(false,{"1","-1"},{"1","-1","1","g","g","g","-1"}, -4) && correct(false,{"1","-1"},{"1","-1","1","g","g","g","-1"}, -5) && correct(false,{"1","-1"},{"1","g","-1","1","g","g","-1"}, -5) && correct(false,{"1","-1"},{"1","g","g","-1","1","g","-1"}, -5) && correct(false,{"1","-1"},{"1","g","g","-1","1","g","-1"}, -6) && correct(false,{"1","-1"},{"1","g","-1","1","g","g","-1"}, -7) && correct(false,{"1","-1"},{"1","g","g","g","-1","1","-1"}, -7) && correct(false,{"1","-1"},{"1","-1","1","g","g","g","-1"}, -8) && correct(false,{"1","-1"},{"1","g","g","g","-1","1","-1"}, -8) && correct(false,{"1","-1"},{"1","-1","1","g","g","g","-1"}, -9) && correct(false,{"1","-1"},{"1","g","-1","1","g","g","-1"}, -9) && correct(false,{"1","-1"},{"1","g","g","g","-1","1","-1"}, -10) && correct(false,{"1","-1"},{"1","g","g","g","-1","1","-1"}, -11) && correct(false,{"1","-1"},{"1","g","g","-1","1","g","-1"}, -12) && correct(false,{"1","-1"},{"1","g","g","g","-1","1","-1"}, -12) )) return false; return true; } } // namespace int main() { if(!valid_jets()) return EXIT_FAILURE; if(!invalid_jets()) return EXIT_FAILURE; return EXIT_SUCCESS; } diff --git a/t/test_psp.cc b/t/test_psp.cc index 14d9f23..47ae65f 100644 --- a/t/test_psp.cc +++ b/t/test_psp.cc @@ -1,74 +1,74 @@ /** * \authors The HEJ collaboration (see AUTHORS for details) * \date 2019-2020 * \copyright GPLv2 or later */ #include "hej_test.hh" #include #include #include "HEJ/stream.hh" #include "HEJ/Config.hh" #include "HEJ/event_types.hh" #include "HEJ/Event.hh" #include "HEJ/PhaseSpacePoint.hh" #include "HEJ/Ranlux64.hh" #include "LHEF/LHEF.h" #include "fastjet/JetDefinition.hh" namespace { constexpr int MAX_TRIALS = 100; - const HEJ::Fraction MAX_EXT_SOFT_PT_FRACTION{0.1}; + const HEJ::Fraction SOFT_PT_REGULATOR{0.1}; const fastjet::JetDefinition JET_DEF{fastjet::kt_algorithm, 0.4}; constexpr double MIN_JET_PT = 50; } int main(int argn, char** argv) { if(argn != 2){ std::cerr << "Usage: " << argv[0] << " eventfile"; return EXIT_FAILURE; } HEJ::istream in{argv[1]}; LHEF::Reader reader{in}; LHEF::Writer writer{std::cerr}; writer.heprup = reader.heprup; HEJ::PhaseSpacePointConfig conf; conf.jet_param = HEJ::JetParameters{JET_DEF, MIN_JET_PT}; - conf.max_ext_soft_pt_fraction = MAX_EXT_SOFT_PT_FRACTION; + conf.soft_pt_regulator = SOFT_PT_REGULATOR; HEJ::Ranlux64 ran{}; while(reader.readEvent()){ HEJ::Event::EventData ev_data{ reader.hepeup }; shuffle_particles(ev_data); const HEJ::Event ev{ ev_data( JET_DEF, MIN_JET_PT ) }; for(int trial = 0; trial < MAX_TRIALS; ++trial){ HEJ::PhaseSpacePoint psp{ev, conf, ran}; if(psp.weight() != 0){ HEJ::Event::EventData tmp_ev; tmp_ev.incoming = psp.incoming(); tmp_ev.outgoing = psp.outgoing(); tmp_ev.parameters.central = {0,0,0}; shuffle_particles(tmp_ev); HEJ::Event out_ev{ tmp_ev(JET_DEF, MIN_JET_PT) }; if(out_ev.type() != ev.type()){ using HEJ::event_type::name; std::cerr << "Wrong class of phase space point:\n" "original event of class " << name(ev.type()) << ":\n"; writer.hepeup = reader.hepeup; writer.writeEvent(); std::cerr << "Phase space point of class " << name(out_ev.type()) << ":\n"; writer.hepeup = to_HEPEUP(out_ev, &writer.heprup); writer.writeEvent(); return EXIT_FAILURE; } } } } return EXIT_SUCCESS; }