nnpdf-data 0.0.1__py3-none-any.whl → 0.0.2__py3-none-any.whl

nnpdf_data/commondata/SLAC_NC_NOTFIXED_P/metadata.yaml

@@ -1,13 +1,14 @@
 setname: SLAC_NC_NOTFIXED_P
 version: 2
-version_comment: Port of old commondata
+version_comment: Port of old commondata. Data are in agreement with Fig. 2 of the reference and corresponds to a re-analysis of the SLAC data of E49a, E49b, E61, E87, E89a, E89b, E139, E140. Source not available.
 nnpdf_metadata:
   nnpdf31_process: DIS NC
   experiment: null
 arXiv:
-  url: https://arxiv.org/abs/Phys. Lett. B282 (1992) 475
-iNSPIRE:
   url: ''
+  journal: Phys. Lett. B282 (1992) 475
+iNSPIRE:
+  url: https://inspirehep.net/literature/319089
 hepdata:
   url: ''
   version: -1
@@ -17,12 +18,12 @@ implemented_observables:
     description: Deep Inelastic Scattering
     label: SLAC $p$
     units: ''
-  process_type: DIS_F2P
+  process_type: DIS_NC
   tables: []
   npoints: []
   ndata: 211
   plotting:
-    kinematics_override: dis_sqrt_scale
+    kinematics_override: identity
     theory_reference: Bertone:2013vaa
     dataset_label: SLAC $p$
     y_label: $10^{i}F_2(x,Q^2)$
@@ -30,25 +31,25 @@ implemented_observables:
     data_reference: Whitlow:1991uw
     y_scale: symlog
     line_by:
-    - k1
-    plot_x: k2
+    - x
+    plot_x: Q2
   kinematic_coverage:
-  - k1
-  - k2
-  - k3
+  - x
+  - Q2
+  - y
   kinematics:
     variables:
-      k1:
-        description: Variable k1
-        label: k1
+      x:
+        description: Bjorken x
+        label: '$x$'
         units: ''
-      k2:
-        description: Variable k2
-        label: k2
+      Q2:
+        description:  Momentum transfer
+        label: '$Q^2$'
         units: ''
-      k3:
-        description: Variable k3
-        label: k3
+      y:
+        description: Inelasticity
+        label: '$y$'
         units: ''
     file: kinematics_EM-F2.yaml
   theory:

nnpdf_data/commondata/update_all.py

@@ -0,0 +1,35 @@
+from ruamel.yaml import YAML
+from glob import glob
+from pathlib import Path
+
+yaml = YAML()
+yaml.preserve_quotes = True
+yaml.width = 4096
+
+changed_datasets = []
+
+for metadata_file in glob("*/metadata.yaml"):
+    with open(metadata_file, "r") as f:
+        metadata = yaml.load(f)
+
+    for observable in metadata["implemented_observables"]:
+        variants = observable.get("variants", {})
+        legacy = variants.get("legacy", {})
+        if "theory" in legacy:
+            legacy_data = dict(legacy)
+            legacy_theory = {"theory": legacy_data.pop("theory")}
+
+            # Not all will have both legacy data and theory, in those cases skip
+            if not legacy_data:
+                continue
+            variants["legacy_data"] = legacy_data
+            variants["legacy_theory"] = legacy_theory
+
+            changed_datasets.append(
+                f"{Path(metadata_file).parent.name}_{observable['observable_name']}"
+            )
+
+    with open(metadata_file, "w") as f:
+        yaml.dump(metadata, f)
+
+print("\n".join(changed_datasets))

nnpdf_data/commondataparser.py

@@ -37,22 +37,20 @@ by modifying the CommonMetaData using one of the loaded Variants one can change
 """
 
 import dataclasses
-from functools import cached_property, lru_cache
+from functools import cache, cached_property
 import logging
 from pathlib import Path
-from typing import Any, Dict, Optional
+from typing import Any, Optional
 
 import numpy as np
 import pandas as pd
 from validobj import ValidationError, parse_input
 from validobj.custom import Parser
 
-# We cannot use ruamel directly due to the ambiguity ruamel.yaml / ruamel_yaml
-# of some versions which are pinned in some of the conda packages we use...
-from . import new_to_legacy_map, path_commondata
 from .coredata import KIN_NAMES, CommonData
 from .process_options import ValidProcess
 from .utils import parse_yaml_inp, quick_yaml_load
+from .validphys_compatibility import new_to_legacy_map, path_commondata
 
 try:
     from validphys.plotoptions.plottingoptions import PlottingOptions, labeler_functions
@@ -107,6 +105,10 @@ KINLABEL_LATEX = {
     "SHP_ASY": ("$\\eta$", "$p_T (GeV)$", "$\\sqrt{s} (GeV)$"),
     "JET_POL": ("$\\eta$", "$p_T^2 (GeV^2)$", "$\\sqrt{s} (GeV)$"),
     "DIJET_POL": ("$\\m_{1,2} (GeV)", "$\\eta_1$", "$\\eta_2$"),
+    "DY_Z_Y": ("$y_Z$", "$\\M^2 (GeV^2)$", "$\\sqrt{s} (GeV)$"),
+    "SINGLETOP": ("$y$", "$m_t^2 (GeV^2)$", "$\\sqrt{s} (GeV)$"),
+    "DY_MLL": ("$M_{ll} (GeV)$", "$M_{ll}^2 (GeV^2)$", "$\\sqrt{s} (GeV)$"),
+    "DY_W_ETA": ("$abs_\\eta$", "$M_W^2 (GeV^2)$", "$\\sqrt{s} (GeV)$"),
 }
 
 PROCESS_DESCRIPTION_LABEL = {
@@ -134,6 +136,8 @@ PROCESS_DESCRIPTION_LABEL = {
     "JET_POL": "Inclusive Jet longitudinal double-spin asymmetry",
     "DIJET_POL": "Dijets longitudinal double-spin asymmetry",
     "SHP_ASY": "double spin asymmetry in single hadron production",
+    "DY_MLL": "Drell-Yan Mass Distribution of Lepton Pairs",
+    "DY_W_ETA": "Drell-Yan W boson rapidity distribution",
 }
 
 
@@ -226,9 +230,9 @@ class TheoryMeta:
 
     Example
     -------
-    >>> from validphys.commondataparser import TheoryMeta
+    >>> from nnpdf_data.commondataparser import TheoryMeta
     ... from validobj import parse_input
-    ... from nnpdf_data.utils import yaml
+    ... from ruamel.yaml import YAML
     ... theory_raw = '''
     ... FK_tables:
     ...   - - fk1
@@ -236,7 +240,7 @@ class TheoryMeta:
     ...     - fk3
     ... operation: ratio
     ... '''
-    ... theory = yaml.safe_load(theory_raw)
+    ... theory = YAML(typ='safe').load(theory_raw)
     ... parse_input(theory, TheoryMeta)
     TheoryMeta(FK_tables=[['fk1'], ['fk2', 'fk3']], operation='RATIO', shifts = None, conversion_factor=1.0, comment=None, normalization=None))
     """
@@ -307,7 +311,7 @@ class Variant:
     experiment: Optional[str] = None
 
 
-ValidVariants = Dict[str, Variant]
+ValidVariants = dict[str, Variant]
 
 
 ### Kinematic data
@@ -349,7 +353,7 @@ class ValidKinematics:
     """
 
     file: ValidPath
-    variables: Dict[str, ValidVariable]
+    variables: dict[str, ValidVariable]
 
     def get_label(self, var):
         """For the given variable, return the label as label (unit)
@@ -439,10 +443,8 @@ class ObservableMetaData:
                 raise ValidationError(f"Missing `data_central` field for {self.name}")
 
             if not self.data_uncertainties:
-                ermsg = f"Missing `data_uncertainties` for {self.name}."
-                # be polite
-                if "legacy" in self.variants:
-                    ermsg += " Maybe you intended to use `variant: legacy`?"
+                ermsg = f"""Missing `data_uncertainties` for {self.name}.
+                    Select one of the variants: {list(self.variants.keys())}"""
                 raise ValidationError(ermsg)
 
         # Check that plotting.plot_x is being filled
@@ -553,7 +555,6 @@ class ObservableMetaData:
         all_df = []
         for ufile in self.paths_uncertainties:
             uncyaml = quick_yaml_load(ufile)
-
             mindex = pd.MultiIndex.from_tuples(
                 [(k, v["treatment"], v["type"]) for k, v in uncyaml["definitions"].items()],
                 names=["name", "treatment", "type"],
@@ -652,10 +653,6 @@ class ObservableMetaData:
         if self.ported_from is None:
             return False
 
-        # If it is using a legacy variant and has a ported_from field, then it is a ported one
-        if self.applied_variant is not None and self.applied_variant.startswith("legacy"):
-            return True
-
         # If not using a legacy variant, we consider it ported if the kin variables are still k1,k2,k3
         return {"k1", "k2", "k3"} == set(self.kinematic_coverage)
 
@@ -745,6 +742,18 @@ class ObservableMetaData:
                 new_line_by.append(self.digest_plotting_variable(var))
             self.plotting.line_by = new_line_by
 
+        # And do it also within the normalize dictionary
+        if self.plotting.normalize is not None:
+            # Copy the normalize dictionary and update the figure and line by
+            tmp = dict(self.plotting.normalize)
+            tmp["figure_by"] = []
+            tmp["line_by"] = []
+            for var in self.plotting.normalize.get("figure_by", []):
+                tmp["figure_by"].append(self.digest_plotting_variable(var))
+            for var in self.plotting.normalize.get("line_by", []):
+                tmp["line_by"].append(self.digest_plotting_variable(var))
+            self.plotting.normalize = tmp
+
         self.plotting.already_digested = True
         return self.plotting
 
@@ -827,13 +836,13 @@ class SetMetaData:
         return observable
 
 
-@lru_cache
+@cache
 def parse_set_metadata(metadata_file):
     """Read the metadata file"""
     return parse_yaml_inp(metadata_file, SetMetaData)
 
 
-@lru_cache
+@cache
 def parse_new_metadata(metadata_file, observable_name, variant=None):
     """Given a metadata file in the new format and the specific observable to be read
     load and parse the metadata and select the observable. If any variants are selected, apply them.

nnpdf_data/coredata.py

@@ -5,6 +5,7 @@
 import dataclasses
 from typing import Optional
 
+import numpy as np
 import pandas as pd
 
 from .utils import yaml

nnpdf_data/filter_utils/hera_utils.py

@@ -0,0 +1,105 @@
+from pathlib import Path
+from dataclasses import dataclass
+import typing
+from typing import List
+import numpy as np
+import pandas as pd
+from os import PathLike
+import yaml
+#from validphys.api import API
+
+@dataclass 
+class commondata:
+   central_values: np.ndarray
+   kinematics: np.ndarray
+   statistical_uncertainties: np.ndarray
+   systematic_uncertainties: np.ndarray
+   systypes: List[tuple[str, str]]
+   process: str
+   dataset_name: str
+   kinematic_quantities: List[str]
+
+  
+   # Procedure to create data_*.yaml, kinematics_*.yaml and uncertainties_*.yaml
+   def write_new_commondata(self, data_filename: str | PathLike,
+                            kinematics_filename: str | PathLike,
+                            uncertainties_filename: str | PathLike): 
+      # central data values
+      data = {"data_central": self.central_values.tolist()}
+      with data_filename.open("w+") as f:
+         yaml.dump(data, f, default_flow_style=False, sort_keys=False)
+
+      # kinematic quantieties
+      # TODO add arrays for min and max values to derived type?
+      bins = []
+      for kin in self.kinematics.tolist():
+         bins.append(
+            {self.kinematic_quantities[0]: 
+               {
+               "min": None,
+               "mid": kin[0],
+               "max": None
+               },
+            self.kinematic_quantities[1]:
+               {
+               "min": None,
+               "mid": kin[1],
+               "max": None
+               },
+            self.kinematic_quantities[2]:
+               {
+               "min": None,
+               "mid": kin[2],
+               "max": None
+               }
+             })
+      data = {"bins": bins}
+      with kinematics_filename.open("w+") as f:
+         yaml.dump(data, f, default_flow_style=False, sort_keys=False)
+
+      # uncertainties
+      # There is only one statistical uncertainty per datapoint.
+      definitions = {"stat": 
+                       {
+                          "description": "Statistical uncertainty.", 
+                          "treatment": "ADD", 
+                          "type": "UNCORR"
+                       }
+                    }
+      for isys, sys in enumerate(self.systypes):
+         definitions.update(
+            {f"sys_corr_{isys}":
+               {
+                  "description": f"Systematic uncertainty {isys}",
+                  "treatment": sys[0],
+                  "type": sys[1]
+               }
+            })
+      bins = {"bins": [] }
+      for i, _ in enumerate(self.central_values):
+         systematics = {"stat": self.statistical_uncertainties.tolist()[i]}
+         for isys, sys in enumerate(self.systematic_uncertainties[i].tolist()):
+            systematics.update({f"sys_corr_{isys}": sys})
+         bins["bins"].append(systematics)
+      data = {"definitions": definitions }
+      # TODO Notation of reals is inconsistent from yaml.safe_dump
+      #      sometimes it is in scientific notation sometimes not...
+      with uncertainties_filename.open("w+") as f:
+         yaml.safe_dump(data, f, default_flow_style=False, sort_keys=False)
+         yaml.safe_dump(bins, f, default_flow_style=False, sort_keys=False)
+      
+
+# Subroutines for testing the implementation of the commondata.
+
+## Obtain the covariance matrix for a given variant.
+#def _covmat(name: str, var: str):
+#   inp = {"dataset_input": {"dataset": name, "variant": var}, "theoryid": 700, "use_cuts": "internal"}
+#   return API.covmat_from_systematics(**inp)
+#
+## Compare the covariance matrices of two different variants. True if close.
+#def covmat_is_close(name: str, var1: str, var2: str) -> bool:
+#   return np.isclose(_covmat(name,var1),_covmat(name,var2)).all()
+
+
+
+

nnpdf_data/filter_utils/nmc_hepdata_utils.py

@@ -0,0 +1,59 @@
+""""Common functions to parse NMC data from Hepdata."""
+
+import pandas as pd
+import yaml
+
+from .utils import check_xq2_degenearcy
+
+
+def read_tables(store_path, header_line):
+    """Parse Tables."""
+    dfs = pd.DataFrame()
+    for file in store_path.iterdir():
+        with open(file, "r", encoding="utf-8") as f:
+            lines = f.readlines()
+            df = pd.DataFrame(
+                [l.split(",") for l in lines[header_line:-1]],
+                columns=["Q2", "R", "F2", "stat+", "stat-", "sys+", "sys-"],
+            )
+            df["x"] = float(lines[header_line - 2].split(",")[1])
+            dfs = pd.concat([dfs, df], ignore_index=True) if not dfs.empty else df
+
+    dfs = dfs.astype(float)
+    check_xq2_degenearcy(dfs.Q2.values, dfs.x.values)
+    return dfs.sort_values(["x", "Q2"])
+
+
+def write_files(df, store_path):
+    """Write kinematics, central value and uncertainties files."""
+
+    # Write central data
+    data_central_yaml = {"data_central": [float(x) for x in df["F2"]]}
+    with open(store_path / "data_EM-F2-HEPDATA.yaml", "w", encoding="utf-8") as file:
+        yaml.dump(data_central_yaml, file)
+
+    # Write kin file
+    kin = []
+    for _, row in df.iterrows():
+        kin_value = {
+            "x": {"min": None, "mid": float(row.x), "max": None},
+            "Q2": {"min": None, "mid": float(row.Q2), "max": None},
+        }
+        kin.append(kin_value)
+    kinematics_yaml = {"bins": kin}
+    with open(store_path / "kinematics_EM-F2-HEPDATA.yaml", "w", encoding="utf-8") as file:
+        yaml.dump(kinematics_yaml, file, sort_keys=False)
+
+    # loop on data points
+    error_definition = {
+        "stat": {"description": "statistical uncertainty", "treatment": "ADD", "type": "UNCORR"},
+        "sys": {"description": "systematical uncertainty", "treatment": "MULT", "type": "CORR"},
+    }
+    error = []
+    for _, row in df.iterrows():
+        e = {"stat": float(row["stat+"]), "sys": float(row["sys+"])}
+        error.append(e)
+
+    uncertainties_yaml = {"definitions": error_definition, "bins": error}
+    with open(store_path / "uncertainties_EM-F2-HEPDATA.yaml", "w", encoding="utf-8") as file:
+        yaml.dump(uncertainties_yaml, file, sort_keys=False)

nnpdf_data/filter_utils/utils.py

@@ -162,7 +162,7 @@ def covmat_to_artunc(ndata, covmat_list, no_of_norm_mat=0):
         elif eigval[j] > 0:
             continue
     if not psd_check:
-        raise ValueError('The covariance matrix is not positive-semidefinite')
+        raise ValueError("The covariance matrix is not positive-semidefinite")
     else:
         for i in range(ndata):
             for j in range(ndata):
@@ -244,7 +244,7 @@ def matlist_to_matrix(rows, columns, mat_list):
         matrix = np.array(matrix)
         return matrix
     else:
-        raise Exception('rows * columns != len(mat_list)')
+        raise Exception("rows * columns != len(mat_list)")
 
 
 def concat_matrices(rows, columns, list_of_matrices):
@@ -363,7 +363,7 @@ def trimat_to_fullmat(mode, tri_mat_list):
                     matrix[i][j] = tri_mat_list[list_el]
                     matrix[j][i] = tri_mat_list[list_el]
     else:
-        raise Exception('Mode should be 0 or 1, refer to the function for usage')
+        raise Exception("Mode should be 0 or 1, refer to the function for usage")
     mat_list = []
     for i in range(dim):
         for j in range(dim):
@@ -422,10 +422,22 @@ def prettify_float(dumper, value):
     ret = dumper.represent_float(value)
     if len(ret.value) > 8:
         ret_str = f"{value:.8e}"
-        ret = dumper.represent_scalar('tag:yaml.org,2002:float', ret_str)
+        ret = dumper.represent_scalar("tag:yaml.org,2002:float", ret_str)
     return ret
 
 
+def check_xq2_degenearcy(Q2, x):
+    """Check is the pair of (x,Q2) is unique."""
+    size = len(x)
+    unique_pairs = np.unique(np.array([Q2, x]), axis=1)
+    try:
+        assert unique_pairs.shape[1] == size
+    except AssertionError as exc:
+        raise ValueError(
+            f"""(x,Q2) kinematic is degenerate need to store 3rd kinematic variable as well.
+            unique kinematics are: {unique_pairs.shape[1]}, original size: {size}"""
+        ) from exc
+
 def uncert_skip_variant(source_file, skip_file, uncert_file, uncert_name, remove_source=True):
     r"""
     Create two new uncertainty files, one where the specified uncertainty

nnpdf_data/process_options.py

@@ -37,7 +37,9 @@ class _Vars:
     abs_eta_2 = "abs_eta_2"
     eta_1 = "eta_1"
     eta_2 = "eta_2"
+    m_ll = "m_ll"
     m_ll2 = "m_ll2"
+    abs_y = "abs_y"
 
 
 class _KinematicsInformation:
@@ -164,6 +166,20 @@ def _shp_xq2map(kin_info):
     return np.clip(x, a_min=None, a_max=1, out=x), np.concatenate((q2, q2))
 
 
+def _pht_xq2map(kin_info):
+    # Then compute x, Q2
+    ET = kin_info.get_one_of(_Vars.ET)
+    ET2 = ET**2
+    eta = kin_info.get_one_of(_Vars.eta, _Vars.y)
+    sqrts = kin_info[_Vars.sqrts]
+
+    # eta = y for massless particles
+    x1 = ET / sqrts * np.exp(-eta)
+    x2 = ET / sqrts * np.exp(eta)
+    x = np.concatenate((x1, x2))
+    return np.clip(x, a_min=None, a_max=1, out=x), np.concatenate((ET2, ET2))
+
+
 def _dijets_xq2map(kin_info):
     # Here we can have either ystar or ydiff, but in either case we need to do the same
     ylab_1 = kin_info.get_one_of(_Vars.ystar, _Vars.ydiff, _Vars.eta_1, _Vars.abs_eta_1)
@@ -213,7 +229,6 @@ def _inc_xq2map(kin_info):
     # Compute x, Q2
     # k2 necessary to take the mass for DY inclusive cross sections still not migrated
     mass2 = kin_info.get_one_of(_Vars.m_W2, _Vars.m_Z2, _Vars.m_t2, "k2")
-
     return np.sqrt(mass2) / kin_info[_Vars.sqrts], mass2
 
 
@@ -236,7 +251,7 @@ def _dyboson_xq2map(kin_info):
     originating from a W boson DY process.
     """
     mass2 = kin_info.get_one_of(_Vars.m_W2, _Vars.m_Z2, _Vars.m_V2)
-    eta = kin_info.get_one_of(_Vars.eta, _Vars.y)
+    eta = kin_info.get_one_of(_Vars.eta, _Vars.y, _Vars.abs_eta)
     sqrts = kin_info[_Vars.sqrts]
 
     # eta = y for massless particles
@@ -265,8 +280,8 @@ def _dybosonptrap_xq2map(kin_info):
     using the rapidity of the final lepton pair.
     """
     pT = kin_info[_Vars.pT]
-    eta = kin_info.get_one_of(_Vars.eta, _Vars.y)
-    m_ll2 = kin_info[_Vars.m_ll2]
+    eta = kin_info.get_one_of(_Vars.eta, _Vars.y, _Vars.abs_y)
+    m_ll2 = kin_info.get_one_of(_Vars.m_ll2, _Vars.m_Z2)
     sqrts = kin_info[_Vars.sqrts]
     ET2 = m_ll2 + pT * pT
     x1 = (np.sqrt(ET2) + pT) / sqrts * np.exp(-eta)
@@ -275,6 +290,34 @@ def _dybosonptrap_xq2map(kin_info):
     return x, np.concatenate((ET2, ET2))
 
 
+def _singletop_xq2map(kin_dict):
+
+    y_t = kin_dict[_Vars.y_t]
+    sqrts = kin_dict[_Vars.sqrts]
+    m_t2 = kin_dict[_Vars.m_t2]
+
+    q2 = m_t2
+    ratio = np.sqrt(q2) / sqrts
+    x1 = ratio * np.exp(y_t)
+    x2 = ratio * np.exp(-y_t)
+    x = np.concatenate((x1, x2))
+    return np.clip(x, a_min=None, a_max=1, out=x), np.concatenate((q2, q2))
+
+
+def _dymll_xq2map(kin_info):
+    """
+    Computes x and q2 mapping for DY Z -> 2 leptons mass.
+    x is approximated as x = sqrt(x1*x2) with m_ll^2 = x1*x2*s
+    """
+
+    m_ll = kin_info.get_one_of(_Vars.m_ll)
+    sqrts = kin_info.get_one_of(_Vars.sqrts)
+    m_ll2 = m_ll**2
+    x = m_ll / sqrts
+
+    return x, m_ll2
+
+
 DIS = _Process(
     "DIS",
     "Deep Inelastic Scattering",
@@ -341,7 +384,14 @@ HQP_YQ = _Process(
 HQP_PTQ = _Process(
     "HQP_PTQ",
     "Transverse momentum of top quark in top pair production",
-    accepted_variables=(_Vars.pT_t, _Vars.y_t, _Vars.y_ttBar, _Vars.sqrts, _Vars.m_t2),
+    accepted_variables=(
+        _Vars.pT_t,
+        _Vars.m_ttBar,
+        _Vars.y_t,
+        _Vars.y_ttBar,
+        _Vars.sqrts,
+        _Vars.m_t2,
+    ),
     xq2map_function=_hqp_ptq_xq2map,
 )
 
@@ -370,10 +420,24 @@ HERAJET = _Process(
 DY_2L = _Process(
     "DY_2L",
     "DY W or Z -> 2 leptons ",
-    accepted_variables=(_Vars.y, _Vars.eta, _Vars.m_W2, _Vars.m_Z2, _Vars.m_V2, _Vars.sqrts),
+    accepted_variables=(
+        _Vars.y,
+        _Vars.eta,
+        _Vars.m_W2,
+        _Vars.m_Z2,
+        _Vars.m_V2,
+        _Vars.sqrts,
+        _Vars.abs_eta,
+    ),
     xq2map_function=_dyboson_xq2map,
 )
 
+DY_MLL = _Process(
+    "DY_MLL",
+    "DY Z -> ll mass of lepton pair",
+    accepted_variables=(_Vars.m_ll, _Vars.sqrts),
+    xq2map_function=_dymll_xq2map,
+)
 
 DY_PT = _Process(
     "DY_PT",
@@ -391,6 +455,7 @@ DY_PT_RAP = _Process(
         _Vars.m_Z2,
         _Vars.sqrts,
         _Vars.y,
+        _Vars.abs_y,
         _Vars.eta,
         _Vars.m_ll2,
     ),
@@ -404,12 +469,29 @@ POS_DIS = _Process(
     "POS_DIS", "Positivity of F2 structure functions", accepted_variables=(_Vars.x, _Vars.Q2)
 )
 
+PHT = _Process(
+    "PHT",
+    "Photon production",
+    accepted_variables=(_Vars.eta, _Vars.ET, _Vars.sqrts),
+    xq2map_function=_pht_xq2map,
+)
+
+SINGLETOP = _Process(
+    "SINGLETOP",
+    "Single top production",
+    accepted_variables=(_Vars.m_t2, _Vars.sqrts, _Vars.y_t, _Vars.pT_t),
+    xq2map_function=_singletop_xq2map,
+)
+
+
 PROCESSES = {
     "DIS": DIS,
     "DIS_NC": dataclasses.replace(DIS, name="DIS_NC"),
     "DIS_CC": dataclasses.replace(DIS, name="DIS_CC"),
     "DIS_NCE": dataclasses.replace(DIS, name="DIS_NCE"),
     "DIS_POL": dataclasses.replace(DIS, name="DIS_POL"),
+    "DIS_NC_CHARM": dataclasses.replace(DIS, name="DIS_NC_CHARM"),
+    "DIS_NC_BOTTOM": dataclasses.replace(DIS, name="DIS_NC_BOTTOM"),
     "JET": JET,
     "DIJET": DIJET,
     "SHP_ASY": SHP,
@@ -422,7 +504,8 @@ PROCESSES = {
     "HERADIJET": dataclasses.replace(HERAJET, name="HERADIJET", description="DIS + jj production"),
     "JET_POL": JET_POL,
     "DIJET_POL": DIJET_POL,
-    "DY_Z_Y": dataclasses.replace(DY_2L, name="DY_Z_Y", description="DY Z -> ll rapidity"),
+    "DY_Z_Y": dataclasses.replace(DY_2L, name="DY_Z_Y", description="DY Z -> ll (pseudo)rapidity"),
+    "DY_MLL": DY_MLL,
     "DY_W_ETA": dataclasses.replace(
         DY_2L, name="DY_W_ETA", description="DY W -> l nu pseudorapidity"
     ),
@@ -430,9 +513,12 @@ PROCESSES = {
         DY_2L, name="DY_VB_ETA", description="DY Z/W -> ll pseudorapidity"
     ),
     "DY_NC_PT": dataclasses.replace(DY_PT, name="DY_NC_PT", description="DY Z (ll) + j"),
+    "DY_CC_PT": dataclasses.replace(DY_PT, name="DY_CC_PT", description="DY W + j"),
     "DY_NC_PTRAP": dataclasses.replace(DY_PT_RAP, name="DY_NC_PTRAP", description="DY Z (ll) + j"),
     "POS_XPDF": POS_XPDF,
     "POS_DIS": POS_DIS,
+    "PHT": PHT,
+    "SINGLETOP": SINGLETOP,
 }