From 8128481d2c601204a16a68496f9b511103ac863d Mon Sep 17 00:00:00 2001 From: tgiani Date: Fri, 11 Nov 2022 17:57:22 +0100 Subject: [PATCH 01/14] adding ccbar basis in vp2 and editing FK rotation --- n3fit/src/n3fit/layers/rotations.py | 2 +- validphys2/src/validphys/pdfbases.py | 836 +++++++++++++++++++-------- 2 files changed, 605 insertions(+), 233 deletions(-) diff --git a/n3fit/src/n3fit/layers/rotations.py b/n3fit/src/n3fit/layers/rotations.py index 88fa8d722b..347571094d 100644 --- a/n3fit/src/n3fit/layers/rotations.py +++ b/n3fit/src/n3fit/layers/rotations.py @@ -78,7 +78,7 @@ def call(self, pdf_raw): x[2], # v x[3], # v3 x[4], # v8 - x[2], # v15 + x[8], # v15 x[2], # v24 x[2], # v35 x[5], # t3 diff --git a/validphys2/src/validphys/pdfbases.py b/validphys2/src/validphys/pdfbases.py index 6154b59325..d90d1c45c8 100644 --- a/validphys2/src/validphys/pdfbases.py +++ b/validphys2/src/validphys/pdfbases.py @@ -15,28 +15,31 @@ from validphys.gridvalues import grid_values, central_grid_values -#This mapping maps the keys passed to LHAPDF (PDG codes) to nice LaTeX labels. -PDG_PARTONS = dict(( - (-6, r'\bar{t}'), - (-5 , r"\bar{b}"), - (-4 , r"\bar{c}"), - (-3 , r"\bar{s}"), - (-2 , r"\bar{u}"), - (-1 , r"\bar{d}"), - (0 , r"g"), - (1 , r"d"), - (2 , r"u"), - (3 , r"s"), - (4 , r"c"), - (5 , r"b"), - (6 , r"t"), - (22 , r"\gamma"), - (21 , r"g"), - )) +# This mapping maps the keys passed to LHAPDF (PDG codes) to nice LaTeX labels. +PDG_PARTONS = dict( + ( + (-6, r"\bar{t}"), + (-5, r"\bar{b}"), + (-4, r"\bar{c}"), + (-3, r"\bar{s}"), + (-2, r"\bar{u}"), + (-1, r"\bar{d}"), + (0, r"g"), + (1, r"d"), + (2, r"u"), + (3, r"s"), + (4, r"c"), + (5, r"b"), + (6, r"t"), + (22, r"\gamma"), + (21, r"g"), + ) +) # Canonical ordering of PDG codes (so flavour basis) ALL_FLAVOURS = (-6, -5, -4, -3, -2, -1, 21, 1, 2, 3, 4, 5, 6, 22) -DEFAULT_FLARR = (-3,-2,-1,0,1,2,3,4) +DEFAULT_FLARR = (-3, -2, -1, 0, 1, 2, 3, 4) + def pdg_id_to_canonical_index(flindex): """Given an LHAPDF id, return its index in the ALL_FLAVOURS list.""" @@ -44,16 +47,21 @@ def pdg_id_to_canonical_index(flindex): return ALL_FLAVOURS.index(21) return ALL_FLAVOURS.index(flindex) + def list_bases(): - """ List available PDF bases """ + """List available PDF bases""" import validphys.pdfbases as thismodule - return dict(inspect.getmembers(thismodule, lambda x: isinstance(x, thismodule.Basis))) + + return dict( + inspect.getmembers(thismodule, lambda x: isinstance(x, thismodule.Basis)) + ) + def check_basis(basis, flavours): """ - Check to verify a given basis and set of flavours. - Returns a dictionary with the relevant instance of the basis - class and flavour specification + Check to verify a given basis and set of flavours. + Returns a dictionary with the relevant instance of the basis + class and flavour specification """ if isinstance(basis, str): @@ -70,43 +78,49 @@ class and flavour specification flavours = basis.to_known_elements(flavours) except UnknownElement as e: bad = e.args[0] - raise CheckError(f"Unknown basis element '{bad}'", str(bad), - alternatives=basis.indexes, display_alternatives='all') from e + raise CheckError( + f"Unknown basis element '{bad}'", + str(bad), + alternatives=basis.indexes, + display_alternatives="all", + ) from e + + return {"basis": basis, "flavours": flavours} - return {'basis':basis, 'flavours':flavours} -#These are various ways to refering to the PDG partons with nicer text labels. +# These are various ways to refering to the PDG partons with nicer text labels. PDG_ALIASES = { - r'\bar{t}': -6, - 'tbar' : -6, - '\\bar{b}': -5, - 'bbar' : -5, - '\\bar{c}': -4, - 'cbar' : -4, - '\\bar{d}': -1, - 'dbar' : -1, - '\\bar{s}': -3, - 'sbar' : -3, - '\\bar{u}': -2, - 'ubar' : -2, - '\\gamma': 22, - 'photon': 22, - 't': 6, - 'top': 6, - 'b': 5, - 'bottom': 5, - 'c': 4, - 'charm': 4, - 'd': 1, - 'down': 1, - 'g': 21, - 'gluon': 21, - 's': 3, - 'strange': 3, - 'u': 2, - 'up': 2, - 0 : 21, - } + r"\bar{t}": -6, + "tbar": -6, + "\\bar{b}": -5, + "bbar": -5, + "\\bar{c}": -4, + "cbar": -4, + "\\bar{d}": -1, + "dbar": -1, + "\\bar{s}": -3, + "sbar": -3, + "\\bar{u}": -2, + "ubar": -2, + "\\gamma": 22, + "photon": 22, + "t": 6, + "top": 6, + "b": 5, + "bottom": 5, + "c": 4, + "charm": 4, + "d": 1, + "down": 1, + "g": 21, + "gluon": 21, + "s": 3, + "strange": 3, + "u": 2, + "up": 2, + 0: 21, +} + def parse_flarr(flarr): """Parse a free form list into a list of PDG parton indexes @@ -128,6 +142,7 @@ def parse_flarr(flarr): raise ValueError(msg) return out + class UnknownElement(KeyError): pass @@ -163,12 +178,18 @@ class Basis(abc.ABC): of LaTeX is desired. """ - def __init__(self, labels, *, aliases=None, - default_elements=None, element_representations=None): + def __init__( + self, + labels, + *, + aliases=None, + default_elements=None, + element_representations=None, + ): self.labels = labels - #self._known_flavours = ALL_FLAVOURS[] + # self._known_flavours = ALL_FLAVOURS[] if default_elements is None: default_elements = labels self.default_elements = default_elements @@ -176,9 +197,11 @@ def __init__(self, labels, *, aliases=None, element_representations = {} self.element_representations = element_representations - indexes = {lb:i for i,lb in enumerate(labels)} + indexes = {lb: i for i, lb in enumerate(labels)} if aliases: - indexes.update({alias:indexes[alias_label] for alias,alias_label in aliases.items()}) + indexes.update( + {alias: indexes[alias_label] for alias, alias_label in aliases.items()} + ) else: aliases = [] @@ -198,7 +221,7 @@ def elementlabel(self, element): raise UnknownElement(element) def has_element(self, element): - """ Return true if basis has knowledge of the given element """ + """Return true if basis has knowledge of the given element""" try: self.elementlabel(element) return True @@ -290,6 +313,7 @@ def central_grid_values(self, pdf, vmat, xmat, qmat): func = functools.partial(central_grid_values, pdf) return self.apply_grid_values(func, vmat, xmat, qmat) + class LinearBasis(Basis): """A basis that implements a linear transformation of flavours. @@ -307,7 +331,6 @@ def __init__(self, labels, from_flavour_mat, *args, **kwargs): self.from_flavour_mat = from_flavour_mat super().__init__(labels, *args, **kwargs) - """ NOTE: At the moment, we don't need the inverse functionality, namely transforming from basis to flavour. But if we do, it should be computed @@ -372,9 +395,6 @@ def to_other_base(self, basis_arr, other_base): """ - - - def _flaray_from_flindexes(self, flinds): """Convert a list of flavor basis indexes to PDG codes to pass to LHAPDF""" @@ -386,29 +406,26 @@ def _flmask_from_base_indexes(self, inds): possibly obtained with `_to_indexes`).""" return np.count_nonzero(self.from_flavour_mat[inds, :], axis=0) > 0 - def apply_grid_values(self, func, vmat, xmat, qmat): - #Indexes in the transformation from the "free form" inpt + # Indexes in the transformation from the "free form" inpt inds = self._to_indexes(vmat) - #Indexes in flavour basis required to compute these elements + # Indexes in flavour basis required to compute these elements flinds = self._flmask_from_base_indexes(inds) - #The submatrix of the transformation matrix + # The submatrix of the transformation matrix index = np.ix_(inds, flinds) transformation = self.from_flavour_mat[index] - #The PDG codes for LHAPDF + # The PDG codes for LHAPDF flmat = self._flaray_from_flindexes(flinds) gv = func(flmat, xmat, qmat) - #Matrix product along the flavour axis - rotated_gv = np.einsum('bc,acde->abde', transformation, gv) + # Matrix product along the flavour axis + rotated_gv = np.einsum("bc,acde->abde", transformation, gv) return rotated_gv - - @classmethod def from_mapping(cls, mapping, *, aliases=None, default_elements=None): """Construct a basus from a mapping of the form @@ -416,7 +433,9 @@ def from_mapping(cls, mapping, *, aliases=None, default_elements=None): arr = np.zeros(shape=(len(mapping), len(ALL_FLAVOURS))) labels = tuple(mapping) for i, coefs in enumerate(mapping.values()): - indexes = [pdg_id_to_canonical_index(val) for val in parse_flarr(coefs.keys())] + indexes = [ + pdg_id_to_canonical_index(val) for val in parse_flarr(coefs.keys()) + ] values = coefs.values() arr[i, indexes] = list(values) return cls(labels, arr, aliases=aliases, default_elements=default_elements) @@ -437,6 +456,7 @@ class ScalarFunctionTransformation(Basis): and returns a grid with a single basis element. """ + def __init__(self, transform_func, *args, **kwargs): self.transform_func = transform_func super().__init__(*args, **kwargs) @@ -465,141 +485,366 @@ def scalar_function_transformation(label, *args, **kwargs): decorator: callable A decorator that can be applied to a suitable transformation function. """ + def f_(transform_func): return ScalarFunctionTransformation(transform_func, [label], *args, **kwargs) return f_ -flavour = LinearBasis(ALL_FLAVOURS, np.eye(len(ALL_FLAVOURS)), aliases=PDG_ALIASES, - default_elements = DEFAULT_FLARR, element_representations=PDG_PARTONS +flavour = LinearBasis( + ALL_FLAVOURS, + np.eye(len(ALL_FLAVOURS)), + aliases=PDG_ALIASES, + default_elements=DEFAULT_FLARR, + element_representations=PDG_PARTONS, ) -#dicts are oredered in python 3.6+... code shouldn't vreak if they aren't -#though -#see Eqs.(56),(57) https://arxiv.org/pdf/0808.1231.pdf for evolution basis definition -evolution = LinearBasis.from_mapping({ - r'\Sigma' : {'u': 1, 'ubar': 1, 'd': 1, 'dbar': 1, 's': 1, 'sbar': 1, 'c': 1, 'cbar': 1 ,'b':1, 'bbar': 1, 't': 1, 'tbar': 1}, - 'V' : {'u': 1, 'ubar':-1, 'd': 1, 'dbar':-1, 's': 1, 'sbar':-1, 'c': 1, 'cbar':-1 ,'b':1, 'bbar':-1, 't': 1, 'tbar':-1}, - - 'T3' : {'u': 1, 'ubar': 1, 'd':-1, 'dbar':-1}, - 'V3' : {'u': 1, 'ubar':-1, 'd':-1, 'dbar': 1}, - - 'T8' : {'u': 1, 'ubar': 1, 'd': 1, 'dbar': 1, 's':-2, 'sbar':-2}, - 'V8' : {'u': 1, 'ubar':-1, 'd': 1, 'dbar':-1, 's':-2, 'sbar':+2}, - - 'T15' : {'u': 1, 'ubar': 1, 'd': 1, 'dbar': 1, 's': 1, 'sbar': 1, 'c':-3, 'cbar':-3}, - 'V15' : {'u': 1, 'ubar':-1, 'd': 1, 'dbar':-1, 's': 1, 'sbar':-1, 'c':-3, 'cbar':+3}, - - - 'T24' : {'u': 1, 'ubar': 1, 'd': 1, 'dbar': 1, 's': 1, 'sbar': 1, 'c': 1, 'cbar': 1, 'b':-4, 'bbar':-4}, - 'V24' : {'u': 1, 'ubar':-1, 'd': 1, 'dbar':-1, 's': 1, 'sbar':-1, 'c': 1, 'cbar':-1, 'b':-4, 'bbar':+4}, - - 'T35' : {'u': 1, 'ubar': 1, 'd': 1, 'dbar': 1, 's': 1, 'sbar': 1, 'c': 1, 'cbar': 1, 'b': 1, 'bbar': 1, 't':-5, 'tbar':-5}, - 'V35' : {'u': 1, 'ubar':-1, 'd': 1, 'dbar':-1, 's': 1, 'sbar':-1, 'c': 1, 'cbar':-1, 'b': 1, 'bbar':-1, 't':-5, 'tbar':+5}, - - 'g' : {'g':1}, - 'photon' : {'photon':1}, +# dicts are oredered in python 3.6+... code shouldn't vreak if they aren't +# though +# see Eqs.(56),(57) https://arxiv.org/pdf/0808.1231.pdf for evolution basis definition +evolution = LinearBasis.from_mapping( + { + r"\Sigma": { + "u": 1, + "ubar": 1, + "d": 1, + "dbar": 1, + "s": 1, + "sbar": 1, + "c": 1, + "cbar": 1, + "b": 1, + "bbar": 1, + "t": 1, + "tbar": 1, + }, + "V": { + "u": 1, + "ubar": -1, + "d": 1, + "dbar": -1, + "s": 1, + "sbar": -1, + "c": 1, + "cbar": -1, + "b": 1, + "bbar": -1, + "t": 1, + "tbar": -1, + }, + "T3": {"u": 1, "ubar": 1, "d": -1, "dbar": -1}, + "V3": {"u": 1, "ubar": -1, "d": -1, "dbar": 1}, + "T8": {"u": 1, "ubar": 1, "d": 1, "dbar": 1, "s": -2, "sbar": -2}, + "V8": {"u": 1, "ubar": -1, "d": 1, "dbar": -1, "s": -2, "sbar": +2}, + "T15": { + "u": 1, + "ubar": 1, + "d": 1, + "dbar": 1, + "s": 1, + "sbar": 1, + "c": -3, + "cbar": -3, + }, + "V15": { + "u": 1, + "ubar": -1, + "d": 1, + "dbar": -1, + "s": 1, + "sbar": -1, + "c": -3, + "cbar": +3, + }, + "T24": { + "u": 1, + "ubar": 1, + "d": 1, + "dbar": 1, + "s": 1, + "sbar": 1, + "c": 1, + "cbar": 1, + "b": -4, + "bbar": -4, + }, + "V24": { + "u": 1, + "ubar": -1, + "d": 1, + "dbar": -1, + "s": 1, + "sbar": -1, + "c": 1, + "cbar": -1, + "b": -4, + "bbar": +4, + }, + "T35": { + "u": 1, + "ubar": 1, + "d": 1, + "dbar": 1, + "s": 1, + "sbar": 1, + "c": 1, + "cbar": 1, + "b": 1, + "bbar": 1, + "t": -5, + "tbar": -5, + }, + "V35": { + "u": 1, + "ubar": -1, + "d": 1, + "dbar": -1, + "s": 1, + "sbar": -1, + "c": 1, + "cbar": -1, + "b": 1, + "bbar": -1, + "t": -5, + "tbar": +5, + }, + "g": {"g": 1}, + "photon": {"photon": 1}, }, - aliases = {'gluon':'g', 'singlet': r'\Sigma', 'sng': r'\Sigma', 'sigma': r'\Sigma', - 'v': 'V', 'v3': 'V3', 'v8': 'V8', 't3': 'T3', 't8': 'T8', 't15': 'T15'}, - default_elements=(r'\Sigma', 'V', 'T3', 'V3', 'T8', 'V8', 'T15', 'gluon', ) + aliases={ + "gluon": "g", + "singlet": r"\Sigma", + "sng": r"\Sigma", + "sigma": r"\Sigma", + "v": "V", + "v3": "V3", + "v8": "V8", + "t3": "T3", + "t8": "T8", + "t15": "T15", + "v15": "V15", + }, + default_elements=( + r"\Sigma", + "V", + "T3", + "V3", + "T8", + "V8", + "T15", + "gluon", + ), ) EVOL = evolution -PDF4LHC20 = LinearBasis.from_mapping({ - r'\Sigma': { - 'u': 1, 'ubar': 1, 'd': 1, 'dbar': 1, 's': 1, 'sbar': 1, - 'c': 1, 'cbar': 1, 'b': 1, 'bbar': 1, 't': 1, 'tbar': 1}, - 'g': {'g': 1}, - - 'V': { - 'u': 1, 'ubar': -1, 'd': 1, 'dbar': -1, 's': 1, 'sbar': -1, - 'c': 1, 'cbar': -1, 'b': 1, 'bbar': -1, 't': 1, 'tbar': -1}, - - 'V3': {'u': 1, 'ubar': -1, 'd': -1, 'dbar': 1}, +ccbar_asymm = evolution - 'T3': {'u': 1, 'ubar': 1, 'd': -1, 'dbar': -1}, - 'T8': {'u': 1, 'ubar': 1, 'd': 1, 'dbar': 1, 's': -2, 'sbar': -2}, - - 'photon': {'photon': 1}, +PDF4LHC20 = LinearBasis.from_mapping( + { + r"\Sigma": { + "u": 1, + "ubar": 1, + "d": 1, + "dbar": 1, + "s": 1, + "sbar": 1, + "c": 1, + "cbar": 1, + "b": 1, + "bbar": 1, + "t": 1, + "tbar": 1, + }, + "g": {"g": 1}, + "V": { + "u": 1, + "ubar": -1, + "d": 1, + "dbar": -1, + "s": 1, + "sbar": -1, + "c": 1, + "cbar": -1, + "b": 1, + "bbar": -1, + "t": 1, + "tbar": -1, + }, + "V3": {"u": 1, "ubar": -1, "d": -1, "dbar": 1}, + "T3": {"u": 1, "ubar": 1, "d": -1, "dbar": -1}, + "T8": {"u": 1, "ubar": 1, "d": 1, "dbar": 1, "s": -2, "sbar": -2}, + "photon": {"photon": 1}, + }, + aliases={ + "gluon": "g", + "singlet": r"\Sigma", + "sng": r"\Sigma", + "sigma": r"\Sigma", + "v": "V", + "v3": "V3", + "t3": "T3", + "t8": "T8", }, - aliases = {'gluon':'g', 'singlet': r'\Sigma', 'sng': r'\Sigma', 'sigma': r'\Sigma', - 'v': 'V', 'v3': 'V3', 't3': 'T3', 't8': 'T8'}, - default_elements=(r'\Sigma', 'gluon', 'V', 'V3', 'T3', 'T8', )) + default_elements=( + r"\Sigma", + "gluon", + "V", + "V3", + "T3", + "T8", + ), +) NN31IC = LinearBasis.from_mapping( { - r'\Sigma': { - 'u': 1, 'ubar': 1, 'd': 1, 'dbar': 1, 's': 1, 'sbar': 1, - 'c': 1, 'cbar': 1, 'b': 1, 'bbar': 1, 't': 1, 'tbar': 1}, - 'g': {'g': 1}, - - 'V': { - 'u': 1, 'ubar': -1, 'd': 1, 'dbar': -1, 's': 1, 'sbar': -1, - 'c': 1, 'cbar': -1, 'b': 1, 'bbar': -1, 't': 1, 'tbar': -1}, - - 'V3': {'u': 1, 'ubar': -1, 'd': -1, 'dbar': 1}, - 'V8': {'u': 1, 'ubar': -1, 'd': 1, 'dbar': -1, 's': -2, 'sbar': +2}, - - 'T3': {'u': 1, 'ubar': 1, 'd': -1, 'dbar': -1}, - 'T8': {'u': 1, 'ubar': 1, 'd': 1, 'dbar': 1, 's': -2, 'sbar': -2}, - - r'c^+': {'c': 1, 'cbar': 1}, - - 'photon': {'photon': 1}, + r"\Sigma": { + "u": 1, + "ubar": 1, + "d": 1, + "dbar": 1, + "s": 1, + "sbar": 1, + "c": 1, + "cbar": 1, + "b": 1, + "bbar": 1, + "t": 1, + "tbar": 1, + }, + "g": {"g": 1}, + "V": { + "u": 1, + "ubar": -1, + "d": 1, + "dbar": -1, + "s": 1, + "sbar": -1, + "c": 1, + "cbar": -1, + "b": 1, + "bbar": -1, + "t": 1, + "tbar": -1, + }, + "V3": {"u": 1, "ubar": -1, "d": -1, "dbar": 1}, + "V8": {"u": 1, "ubar": -1, "d": 1, "dbar": -1, "s": -2, "sbar": +2}, + "T3": {"u": 1, "ubar": 1, "d": -1, "dbar": -1}, + "T8": {"u": 1, "ubar": 1, "d": 1, "dbar": 1, "s": -2, "sbar": -2}, + r"c^+": {"c": 1, "cbar": 1}, + "photon": {"photon": 1}, }, aliases={ - 'gluon': 'g', 'singlet': r'\Sigma', 'sng': r'\Sigma', 'sigma': r'\Sigma', 'cp': r'c^+', - 'v': 'V', 'v3': 'V3', 'v8': 'V8', 't3': 'T3', 't8': 'T8'}, - default_elements=(r'\Sigma', 'gluon', 'V', 'V3', 'V8', 'T3', 'T8', r'c^+', )) + "gluon": "g", + "singlet": r"\Sigma", + "sng": r"\Sigma", + "sigma": r"\Sigma", + "cp": r"c^+", + "v": "V", + "v3": "V3", + "v8": "V8", + "t3": "T3", + "t8": "T8", + }, + default_elements=( + r"\Sigma", + "gluon", + "V", + "V3", + "V8", + "T3", + "T8", + r"c^+", + ), +) NN31PC = LinearBasis.from_mapping( { - r'\Sigma': { - 'u': 1, 'ubar': 1, 'd': 1, 'dbar': 1, 's': 1, 'sbar': 1, - 'c': 1, 'cbar': 1, 'b': 1, 'bbar': 1, 't': 1, 'tbar': 1}, - 'g': {'g': 1}, - - 'V': { - 'u': 1, 'ubar': -1, 'd': 1, 'dbar': -1, 's': 1, 'sbar': -1, - 'c': 1, 'cbar': -1, 'b': 1, 'bbar': -1, 't': 1, 'tbar': -1}, - - 'V3': {'u': 1, 'ubar': -1, 'd': -1, 'dbar': 1}, - 'V8': {'u': 1, 'ubar': -1, 'd': 1, 'dbar': -1, 's': -2, 'sbar': +2}, - - 'T3': {'u': 1, 'ubar': 1, 'd': -1, 'dbar': -1}, - 'T8': {'u': 1, 'ubar': 1, 'd': 1, 'dbar': 1, 's': -2, 'sbar': -2}, - 'photon': {'photon': 1}, + r"\Sigma": { + "u": 1, + "ubar": 1, + "d": 1, + "dbar": 1, + "s": 1, + "sbar": 1, + "c": 1, + "cbar": 1, + "b": 1, + "bbar": 1, + "t": 1, + "tbar": 1, + }, + "g": {"g": 1}, + "V": { + "u": 1, + "ubar": -1, + "d": 1, + "dbar": -1, + "s": 1, + "sbar": -1, + "c": 1, + "cbar": -1, + "b": 1, + "bbar": -1, + "t": 1, + "tbar": -1, + }, + "V3": {"u": 1, "ubar": -1, "d": -1, "dbar": 1}, + "V8": {"u": 1, "ubar": -1, "d": 1, "dbar": -1, "s": -2, "sbar": +2}, + "T3": {"u": 1, "ubar": 1, "d": -1, "dbar": -1}, + "T8": {"u": 1, "ubar": 1, "d": 1, "dbar": 1, "s": -2, "sbar": -2}, + "photon": {"photon": 1}, }, aliases={ - 'gluon': 'g', 'singlet': r'\Sigma', 'sng': r'\Sigma', 'sigma': r'\Sigma', - 'v': 'V', 'v3': 'V3', 'v8': 'V8', 't3': 'T3', 't8': 'T8'}, - default_elements=(r'\Sigma', 'gluon', 'V', 'V3', 'V8', 'T3', 'T8')) + "gluon": "g", + "singlet": r"\Sigma", + "sng": r"\Sigma", + "sigma": r"\Sigma", + "v": "V", + "v3": "V3", + "v8": "V8", + "t3": "T3", + "t8": "T8", + }, + default_elements=(r"\Sigma", "gluon", "V", "V3", "V8", "T3", "T8"), +) FLAVOUR = LinearBasis.from_mapping( { - 'u': {'u': 1}, - 'ubar': {'ubar': 1}, - 'd': {'d': 1}, - 'dbar': {'dbar': 1}, - 's': {'s': 1}, - 'sbar': {'sbar': 1}, - 'c': {'c': 1}, - 'g': {'g': 1}, + "u": {"u": 1}, + "ubar": {"ubar": 1}, + "d": {"d": 1}, + "dbar": {"dbar": 1}, + "s": {"s": 1}, + "sbar": {"sbar": 1}, + "c": {"c": 1}, + "g": {"g": 1}, }, - default_elements=('u', 'ubar', 'd', 'dbar', 's', 'sbar', 'c', 'g', )) - -pdg = LinearBasis.from_mapping({ -'g/10': {'g':0.1}, -'u_{v}': {'u':1, 'ubar':-1}, -'d_{v}': {'d':1, 'dbar': -1}, -'s': {'s':1}, -r'\bar{u}': {'ubar':1}, -r'\bar{d}': {'dbar':1}, -'c': {'c':1}, -}) + default_elements=( + "u", + "ubar", + "d", + "dbar", + "s", + "sbar", + "c", + "g", + ), +) + +pdg = LinearBasis.from_mapping( + { + "g/10": {"g": 0.1}, + "u_{v}": {"u": 1, "ubar": -1}, + "d_{v}": {"d": 1, "dbar": -1}, + "s": {"s": 1}, + r"\bar{u}": {"ubar": 1}, + r"\bar{d}": {"dbar": 1}, + "c": {"c": 1}, + } +) + @scalar_function_transformation(label="u_V") def u_valence(func, xmat, qmat): @@ -608,6 +853,7 @@ def u_valence(func, xmat, qmat): ubar = gv[:, [1], ...] return u - ubar + @scalar_function_transformation(label="d_V") def d_valence(func, xmat, qmat): gv = func([1, -1], xmat, qmat) @@ -615,6 +861,7 @@ def d_valence(func, xmat, qmat): dbar = gv[:, [1], ...] return d - dbar + @scalar_function_transformation(label="S") def total_sea(func, xmat, qmat): gv = func([3, -2, -1, -3], xmat, qmat) @@ -622,7 +869,8 @@ def total_sea(func, xmat, qmat): ubar = gv[:, [1], ...] dbar = gv[:, [2], ...] sbar = gv[:, [3], ...] - return 2.*(ubar + dbar) + s + sbar + return 2.0 * (ubar + dbar) + s + sbar + @scalar_function_transformation(label="u/d") def ud_ratio(func, xmat, qmat): @@ -631,6 +879,7 @@ def ud_ratio(func, xmat, qmat): den = gv[:, [1], ...] return num / den + @scalar_function_transformation(label="d/u") def du_ratio(func, xmat, qmat): gv = func([1, 2], xmat, qmat) @@ -638,6 +887,7 @@ def du_ratio(func, xmat, qmat): den = gv[:, [1], ...] return num / den + @scalar_function_transformation(label=r"\bar{d}/\bar{u}") def dbarubar_ratio(func, xmat, qmat): gv = func([-1, -2], xmat, qmat) @@ -645,14 +895,14 @@ def dbarubar_ratio(func, xmat, qmat): den = gv[:, [1], ...] return num / den - + @scalar_function_transformation(label="Rs", element_representations={"Rs": "R_{s}"}) def strange_fraction(func, xmat, qmat): gv = func([-3, 3, -2, -1], xmat, qmat) sbar, s, ubar, dbar = (gv[:, [i], ...] for i in range(4)) return (sbar + s) / (ubar + dbar) - + def fitbasis_to_NN31IC(flav_info, fitbasis): """Return a rotation matrix R_{ij} which takes from one of the possible fitting basis (evolution, NN31IC, FLAVOUR) to the NN31IC basis, @@ -683,52 +933,173 @@ def fitbasis_to_NN31IC(flav_info, fitbasis): matrix performing the change of basis from fitbasis to NN31IC """ - if fitbasis == 'NN31IC': + if fitbasis == "NN31IC": return np.identity(8) - elif fitbasis == 'NN31PC': - sng = {'sng': 1, 'v': 0, 'v3': 0, 'v8': 0, 't3': 0, 't8': 0, 'g': 0 } - v = {'sng': 0, 'v': 1, 'v3': 0, 'v8': 0, 't3': 0, 't8': 0, 'g': 0 } - v3 = {'sng': 0, 'v': 0, 'v3': 1, 'v8': 0, 't3': 0, 't8': 0, 'g': 0 } - v8 = {'sng': 0, 'v': 0, 'v3': 0, 'v8': 1, 't3': 0, 't8': 0, 'g': 0 } - t3 = {'sng': 0, 'v': 0, 'v3': 0, 'v8': 0, 't3': 1, 't8': 0, 'g': 0 } - t8 = {'sng': 0, 'v': 0, 'v3': 0, 'v8': 0, 't3': 0, 't8': 1, 'g': 0 } - cp = {'sng': 0, 'v': 0, 'v3': 0, 'v8': 0, 't3': 0, 't8': 0, 'g': 0 } - g = {'sng': 0, 'v': 0, 'v3': 0, 'v8': 0, 't3': 0, 't8': 0, 'g': 1 } - - elif fitbasis == 'FLAVOUR': - sng = {'u': 1, 'ubar': 1, 'd': 1, 'dbar': 1, 's': 1, 'sbar': 1, 'c': 2, 'g': 0 } - v = {'u': 1, 'ubar': -1, 'd': 1, 'dbar': -1, 's': 1, 'sbar': -1, 'c': 0, 'g': 0 } - v3 = {'u': 1, 'ubar': -1, 'd': -1, 'dbar': 1, 's': 0, 'sbar': 0, 'c': 0, 'g': 0 } - v8 = {'u': 1, 'ubar': -1, 'd': 1, 'dbar': -1, 's': -2, 'sbar': 2, 'c': 0, 'g': 0 } - t3 = {'u': 1, 'ubar': 1, 'd': -1, 'dbar': -1, 's': 0, 'sbar': 0, 'c': 0, 'g': 0 } - t8 = {'u': 1, 'ubar': 1, 'd': 1, 'dbar': 1, 's': -2, 'sbar': -2, 'c': 0, 'g': 0 } - cp = {'u': 0, 'ubar': 0, 'd': 0, 'dbar': 0, 's': 0, 'sbar': 0, 'c': 2, 'g': 0 } - g = {'u': 0, 'ubar': 0, 'd': 0, 'dbar': 0, 's': 0, 'sbar': 0, 'c': 0, 'g': 1 } - - elif fitbasis == 'EVOL' or fitbasis == 'evolution': - sng = {'sng': 1, 'v': 0, 'v3': 0, 'v8': 0, 't3': 0, 't8': 0, 't15': 0, 'g': 0 } - v = {'sng': 0, 'v': 1, 'v3': 0, 'v8': 0, 't3': 0, 't8': 0, 't15': 0, 'g': 0 } - v3 = {'sng': 0, 'v': 0, 'v3': 1, 'v8': 0, 't3': 0, 't8': 0, 't15': 0, 'g': 0 } - v8 = {'sng': 0, 'v': 0, 'v3': 0, 'v8': 1, 't3': 0, 't8': 0, 't15': 0, 'g': 0 } - t3 = {'sng': 0, 'v': 0, 'v3': 0, 'v8': 0, 't3': 1, 't8': 0, 't15': 0, 'g': 0 } - t8 = {'sng': 0, 'v': 0, 'v3': 0, 'v8': 0, 't3': 0, 't8': 1, 't15': 0, 'g': 0 } - cp = {'sng': 0.25, 'v': 0, 'v3': 0, 'v8': 0, 't3': 0, 't8': 0, 't15': -0.25, 'g': 0 } - g = {'sng': 0, 'v': 0, 'v3': 0, 'v8': 0, 't3': 0, 't8': 0, 't15': 0, 'g': 1 } - - elif fitbasis == 'PDF4LHC20': - sng = {'sng': 1, 'v': 0, 'v3': 0, 'v8': 0, 't3': 0, 't8': 0, 't15': 0, 'g': 0 } - v = {'sng': 0, 'v': 1, 'v3': 0, 'v8': 0, 't3': 0, 't8': 0, 't15': 0, 'g': 0 } - v3 = {'sng': 0, 'v': 0, 'v3': 1, 'v8': 0, 't3': 0, 't8': 0, 't15': 0, 'g': 0 } - v8 = {'sng': 0, 'v': 1, 'v3': 0, 'v8': 0, 't3': 0, 't8': 0, 't15': 0, 'g': 0 } - t3 = {'sng': 0, 'v': 0, 'v3': 0, 'v8': 0, 't3': 1, 't8': 0, 't15': 0, 'g': 0 } - t8 = {'sng': 0, 'v': 0, 'v3': 0, 'v8': 0, 't3': 0, 't8': 1, 't15': 0, 'g': 0 } - cp = {'sng': 0, 'v': 0, 'v3': 0, 'v8': 0, 't3': 0, 't8': 0, 't15': 0, 'g': 0 } - g = {'sng': 0, 'v': 0, 'v3': 0, 'v8': 0, 't3': 0, 't8': 0, 't15': 0, 'g': 1 } - - flist = [sng, g, v, v3, v8, t3, t8, cp] - - evol_basis = False + elif fitbasis == "NN31PC": + sng = {"sng": 1, "v": 0, "v3": 0, "v8": 0, "t3": 0, "t8": 0, "g": 0} + v = {"sng": 0, "v": 1, "v3": 0, "v8": 0, "t3": 0, "t8": 0, "g": 0} + v3 = {"sng": 0, "v": 0, "v3": 1, "v8": 0, "t3": 0, "t8": 0, "g": 0} + v8 = {"sng": 0, "v": 0, "v3": 0, "v8": 1, "t3": 0, "t8": 0, "g": 0} + t3 = {"sng": 0, "v": 0, "v3": 0, "v8": 0, "t3": 1, "t8": 0, "g": 0} + t8 = {"sng": 0, "v": 0, "v3": 0, "v8": 0, "t3": 0, "t8": 1, "g": 0} + cp = {"sng": 0, "v": 0, "v3": 0, "v8": 0, "t3": 0, "t8": 0, "g": 0} + g = {"sng": 0, "v": 0, "v3": 0, "v8": 0, "t3": 0, "t8": 0, "g": 1} + v15 = {"sng": 0, "v": 0, "v3": 0, "v8": 0, "t3": 0, "t8": 0, "t15": 0, "g": 0} + + elif fitbasis == "FLAVOUR": + sng = {"u": 1, "ubar": 1, "d": 1, "dbar": 1, "s": 1, "sbar": 1, "c": 2, "g": 0} + v = {"u": 1, "ubar": -1, "d": 1, "dbar": -1, "s": 1, "sbar": -1, "c": 0, "g": 0} + v3 = {"u": 1, "ubar": -1, "d": -1, "dbar": 1, "s": 0, "sbar": 0, "c": 0, "g": 0} + v8 = { + "u": 1, + "ubar": -1, + "d": 1, + "dbar": -1, + "s": -2, + "sbar": 2, + "c": 0, + "g": 0, + } + t3 = {"u": 1, "ubar": 1, "d": -1, "dbar": -1, "s": 0, "sbar": 0, "c": 0, "g": 0} + t8 = {"u": 1, "ubar": 1, "d": 1, "dbar": 1, "s": -2, "sbar": -2, "c": 0, "g": 0} + cp = {"u": 0, "ubar": 0, "d": 0, "dbar": 0, "s": 0, "sbar": 0, "c": 2, "g": 0} + g = {"u": 0, "ubar": 0, "d": 0, "dbar": 0, "s": 0, "sbar": 0, "c": 0, "g": 1} + v15 = {"sng": 0, "v": 0, "v3": 0, "v8": 0, "t3": 0, "t8": 0, "t15": 0, "g": 0} + + elif fitbasis == "EVOL" or fitbasis == "evolution": + sng = {"sng": 1, "v": 0, "v3": 0, "v8": 0, "t3": 0, "t8": 0, "t15": 0, "g": 0} + v = {"sng": 0, "v": 1, "v3": 0, "v8": 0, "t3": 0, "t8": 0, "t15": 0, "g": 0} + v3 = {"sng": 0, "v": 0, "v3": 1, "v8": 0, "t3": 0, "t8": 0, "t15": 0, "g": 0} + v8 = {"sng": 0, "v": 0, "v3": 0, "v8": 1, "t3": 0, "t8": 0, "t15": 0, "g": 0} + t3 = {"sng": 0, "v": 0, "v3": 0, "v8": 0, "t3": 1, "t8": 0, "t15": 0, "g": 0} + t8 = {"sng": 0, "v": 0, "v3": 0, "v8": 0, "t3": 0, "t8": 1, "t15": 0, "g": 0} + cp = { + "sng": 0.25, + "v": 0, + "v3": 0, + "v8": 0, + "t3": 0, + "t8": 0, + "t15": -0.25, + "g": 0, + } + g = {"sng": 0, "v": 0, "v3": 0, "v8": 0, "t3": 0, "t8": 0, "t15": 0, "g": 1} + v15 = {"sng": 0, "v": 0, "v3": 0, "v8": 0, "t3": 0, "t8": 0, "t15": 0, "g": 0} + + elif fitbasis == "PDF4LHC20": + sng = {"sng": 1, "v": 0, "v3": 0, "v8": 0, "t3": 0, "t8": 0, "t15": 0, "g": 0} + v = {"sng": 0, "v": 1, "v3": 0, "v8": 0, "t3": 0, "t8": 0, "t15": 0, "g": 0} + v3 = {"sng": 0, "v": 0, "v3": 1, "v8": 0, "t3": 0, "t8": 0, "t15": 0, "g": 0} + v8 = {"sng": 0, "v": 1, "v3": 0, "v8": 0, "t3": 0, "t8": 0, "t15": 0, "g": 0} + t3 = {"sng": 0, "v": 0, "v3": 0, "v8": 0, "t3": 1, "t8": 0, "t15": 0, "g": 0} + t8 = {"sng": 0, "v": 0, "v3": 0, "v8": 0, "t3": 0, "t8": 1, "t15": 0, "g": 0} + cp = {"sng": 0, "v": 0, "v3": 0, "v8": 0, "t3": 0, "t8": 0, "t15": 0, "g": 0} + g = {"sng": 0, "v": 0, "v3": 0, "v8": 0, "t3": 0, "t8": 0, "t15": 0, "g": 1} + v15 = {"sng": 0, "v": 0, "v3": 0, "v8": 0, "t3": 0, "t8": 0, "t15": 0, "g": 0} + + elif fitbasis == "ccbar_asymm": + sng = { + "sng": 1, + "v": 0, + "v3": 0, + "v8": 0, + "t3": 0, + "t8": 0, + "t15": 0, + "g": 0, + "v15": 0, + } + v = { + "sng": 0, + "v": 1, + "v3": 0, + "v8": 0, + "t3": 0, + "t8": 0, + "t15": 0, + "g": 0, + "v15": 0, + } + v3 = { + "sng": 0, + "v": 0, + "v3": 1, + "v8": 0, + "t3": 0, + "t8": 0, + "t15": 0, + "g": 0, + "v15": 0, + } + v8 = { + "sng": 0, + "v": 1, + "v3": 0, + "v8": 0, + "t3": 0, + "t8": 0, + "t15": 0, + "g": 0, + "v15": 0, + } + v15 = { + "sng": 0, + "v": 0, + "v3": 0, + "v8": 0, + "t3": 0, + "t8": 0, + "t15": 0, + "g": 0, + "v15": 1, + } + t3 = { + "sng": 0, + "v": 0, + "v3": 0, + "v8": 0, + "t3": 1, + "t8": 0, + "t15": 0, + "g": 0, + "v15": 0, + } + t8 = { + "sng": 0, + "v": 0, + "v3": 0, + "v8": 0, + "t3": 0, + "t8": 1, + "t15": 0, + "g": 0, + "v15": 0, + } + cp = { + "sng": 0.25, + "v": 0, + "v3": 0, + "v8": 0, + "t3": 0, + "t8": 0, + "t15": -0.25, + "g": 0, + "v15": 0, + } + g = { + "sng": 0, + "v": 0, + "v3": 0, + "v8": 0, + "t3": 0, + "t8": 0, + "t15": 0, + "g": 1, + "v15": 0, + } + + flist = [sng, g, v, v3, v8, t3, t8, cp, v15] mat = [] for f in flist: for flav_dict in flav_info: @@ -736,6 +1107,7 @@ def fitbasis_to_NN31IC(flav_info, fitbasis): mat.append(f[flav_name]) nflavs = len(flav_info) - mat = np.asarray(mat).reshape(8, nflavs) + mat = np.asarray(mat).reshape(9, nflavs) + # Return the transpose of the matrix, to have the first index referring to flavour return mat.transpose() From d7469b223ba4c9a2e8666c8e38ce983fe478939f Mon Sep 17 00:00:00 2001 From: tgiani Date: Wed, 16 Nov 2022 09:24:24 +0100 Subject: [PATCH 02/14] removing black reformatting --- validphys2/src/validphys/pdfbases.py | 846 ++++++++------------------- 1 file changed, 245 insertions(+), 601 deletions(-) diff --git a/validphys2/src/validphys/pdfbases.py b/validphys2/src/validphys/pdfbases.py index d90d1c45c8..2186902a78 100644 --- a/validphys2/src/validphys/pdfbases.py +++ b/validphys2/src/validphys/pdfbases.py @@ -15,31 +15,28 @@ from validphys.gridvalues import grid_values, central_grid_values -# This mapping maps the keys passed to LHAPDF (PDG codes) to nice LaTeX labels. -PDG_PARTONS = dict( - ( - (-6, r"\bar{t}"), - (-5, r"\bar{b}"), - (-4, r"\bar{c}"), - (-3, r"\bar{s}"), - (-2, r"\bar{u}"), - (-1, r"\bar{d}"), - (0, r"g"), - (1, r"d"), - (2, r"u"), - (3, r"s"), - (4, r"c"), - (5, r"b"), - (6, r"t"), - (22, r"\gamma"), - (21, r"g"), - ) -) +#This mapping maps the keys passed to LHAPDF (PDG codes) to nice LaTeX labels. +PDG_PARTONS = dict(( + (-6, r'\bar{t}'), + (-5 , r"\bar{b}"), + (-4 , r"\bar{c}"), + (-3 , r"\bar{s}"), + (-2 , r"\bar{u}"), + (-1 , r"\bar{d}"), + (0 , r"g"), + (1 , r"d"), + (2 , r"u"), + (3 , r"s"), + (4 , r"c"), + (5 , r"b"), + (6 , r"t"), + (22 , r"\gamma"), + (21 , r"g"), + )) # Canonical ordering of PDG codes (so flavour basis) ALL_FLAVOURS = (-6, -5, -4, -3, -2, -1, 21, 1, 2, 3, 4, 5, 6, 22) -DEFAULT_FLARR = (-3, -2, -1, 0, 1, 2, 3, 4) - +DEFAULT_FLARR = (-3,-2,-1,0,1,2,3,4) def pdg_id_to_canonical_index(flindex): """Given an LHAPDF id, return its index in the ALL_FLAVOURS list.""" @@ -47,21 +44,16 @@ def pdg_id_to_canonical_index(flindex): return ALL_FLAVOURS.index(21) return ALL_FLAVOURS.index(flindex) - def list_bases(): - """List available PDF bases""" + """ List available PDF bases """ import validphys.pdfbases as thismodule - - return dict( - inspect.getmembers(thismodule, lambda x: isinstance(x, thismodule.Basis)) - ) - + return dict(inspect.getmembers(thismodule, lambda x: isinstance(x, thismodule.Basis))) def check_basis(basis, flavours): """ - Check to verify a given basis and set of flavours. - Returns a dictionary with the relevant instance of the basis - class and flavour specification + Check to verify a given basis and set of flavours. + Returns a dictionary with the relevant instance of the basis + class and flavour specification """ if isinstance(basis, str): @@ -78,49 +70,43 @@ class and flavour specification flavours = basis.to_known_elements(flavours) except UnknownElement as e: bad = e.args[0] - raise CheckError( - f"Unknown basis element '{bad}'", - str(bad), - alternatives=basis.indexes, - display_alternatives="all", - ) from e - - return {"basis": basis, "flavours": flavours} + raise CheckError(f"Unknown basis element '{bad}'", str(bad), + alternatives=basis.indexes, display_alternatives='all') from e + return {'basis':basis, 'flavours':flavours} -# These are various ways to refering to the PDG partons with nicer text labels. +#These are various ways to refering to the PDG partons with nicer text labels. PDG_ALIASES = { - r"\bar{t}": -6, - "tbar": -6, - "\\bar{b}": -5, - "bbar": -5, - "\\bar{c}": -4, - "cbar": -4, - "\\bar{d}": -1, - "dbar": -1, - "\\bar{s}": -3, - "sbar": -3, - "\\bar{u}": -2, - "ubar": -2, - "\\gamma": 22, - "photon": 22, - "t": 6, - "top": 6, - "b": 5, - "bottom": 5, - "c": 4, - "charm": 4, - "d": 1, - "down": 1, - "g": 21, - "gluon": 21, - "s": 3, - "strange": 3, - "u": 2, - "up": 2, - 0: 21, -} - + r'\bar{t}': -6, + 'tbar' : -6, + '\\bar{b}': -5, + 'bbar' : -5, + '\\bar{c}': -4, + 'cbar' : -4, + '\\bar{d}': -1, + 'dbar' : -1, + '\\bar{s}': -3, + 'sbar' : -3, + '\\bar{u}': -2, + 'ubar' : -2, + '\\gamma': 22, + 'photon': 22, + 't': 6, + 'top': 6, + 'b': 5, + 'bottom': 5, + 'c': 4, + 'charm': 4, + 'd': 1, + 'down': 1, + 'g': 21, + 'gluon': 21, + 's': 3, + 'strange': 3, + 'u': 2, + 'up': 2, + 0 : 21, + } def parse_flarr(flarr): """Parse a free form list into a list of PDG parton indexes @@ -142,7 +128,6 @@ def parse_flarr(flarr): raise ValueError(msg) return out - class UnknownElement(KeyError): pass @@ -178,18 +163,12 @@ class Basis(abc.ABC): of LaTeX is desired. """ - def __init__( - self, - labels, - *, - aliases=None, - default_elements=None, - element_representations=None, - ): + def __init__(self, labels, *, aliases=None, + default_elements=None, element_representations=None): self.labels = labels - # self._known_flavours = ALL_FLAVOURS[] + #self._known_flavours = ALL_FLAVOURS[] if default_elements is None: default_elements = labels self.default_elements = default_elements @@ -197,11 +176,9 @@ def __init__( element_representations = {} self.element_representations = element_representations - indexes = {lb: i for i, lb in enumerate(labels)} + indexes = {lb:i for i,lb in enumerate(labels)} if aliases: - indexes.update( - {alias: indexes[alias_label] for alias, alias_label in aliases.items()} - ) + indexes.update({alias:indexes[alias_label] for alias,alias_label in aliases.items()}) else: aliases = [] @@ -221,7 +198,7 @@ def elementlabel(self, element): raise UnknownElement(element) def has_element(self, element): - """Return true if basis has knowledge of the given element""" + """ Return true if basis has knowledge of the given element """ try: self.elementlabel(element) return True @@ -313,7 +290,6 @@ def central_grid_values(self, pdf, vmat, xmat, qmat): func = functools.partial(central_grid_values, pdf) return self.apply_grid_values(func, vmat, xmat, qmat) - class LinearBasis(Basis): """A basis that implements a linear transformation of flavours. @@ -331,6 +307,7 @@ def __init__(self, labels, from_flavour_mat, *args, **kwargs): self.from_flavour_mat = from_flavour_mat super().__init__(labels, *args, **kwargs) + """ NOTE: At the moment, we don't need the inverse functionality, namely transforming from basis to flavour. But if we do, it should be computed @@ -395,6 +372,9 @@ def to_other_base(self, basis_arr, other_base): """ + + + def _flaray_from_flindexes(self, flinds): """Convert a list of flavor basis indexes to PDG codes to pass to LHAPDF""" @@ -406,26 +386,29 @@ def _flmask_from_base_indexes(self, inds): possibly obtained with `_to_indexes`).""" return np.count_nonzero(self.from_flavour_mat[inds, :], axis=0) > 0 + def apply_grid_values(self, func, vmat, xmat, qmat): - # Indexes in the transformation from the "free form" inpt + #Indexes in the transformation from the "free form" inpt inds = self._to_indexes(vmat) - # Indexes in flavour basis required to compute these elements + #Indexes in flavour basis required to compute these elements flinds = self._flmask_from_base_indexes(inds) - # The submatrix of the transformation matrix + #The submatrix of the transformation matrix index = np.ix_(inds, flinds) transformation = self.from_flavour_mat[index] - # The PDG codes for LHAPDF + #The PDG codes for LHAPDF flmat = self._flaray_from_flindexes(flinds) gv = func(flmat, xmat, qmat) - # Matrix product along the flavour axis - rotated_gv = np.einsum("bc,acde->abde", transformation, gv) + #Matrix product along the flavour axis + rotated_gv = np.einsum('bc,acde->abde', transformation, gv) return rotated_gv + + @classmethod def from_mapping(cls, mapping, *, aliases=None, default_elements=None): """Construct a basus from a mapping of the form @@ -433,9 +416,7 @@ def from_mapping(cls, mapping, *, aliases=None, default_elements=None): arr = np.zeros(shape=(len(mapping), len(ALL_FLAVOURS))) labels = tuple(mapping) for i, coefs in enumerate(mapping.values()): - indexes = [ - pdg_id_to_canonical_index(val) for val in parse_flarr(coefs.keys()) - ] + indexes = [pdg_id_to_canonical_index(val) for val in parse_flarr(coefs.keys())] values = coefs.values() arr[i, indexes] = list(values) return cls(labels, arr, aliases=aliases, default_elements=default_elements) @@ -456,7 +437,6 @@ class ScalarFunctionTransformation(Basis): and returns a grid with a single basis element. """ - def __init__(self, transform_func, *args, **kwargs): self.transform_func = transform_func super().__init__(*args, **kwargs) @@ -485,366 +465,143 @@ def scalar_function_transformation(label, *args, **kwargs): decorator: callable A decorator that can be applied to a suitable transformation function. """ - def f_(transform_func): return ScalarFunctionTransformation(transform_func, [label], *args, **kwargs) return f_ -flavour = LinearBasis( - ALL_FLAVOURS, - np.eye(len(ALL_FLAVOURS)), - aliases=PDG_ALIASES, - default_elements=DEFAULT_FLARR, - element_representations=PDG_PARTONS, +flavour = LinearBasis(ALL_FLAVOURS, np.eye(len(ALL_FLAVOURS)), aliases=PDG_ALIASES, + default_elements = DEFAULT_FLARR, element_representations=PDG_PARTONS ) -# dicts are oredered in python 3.6+... code shouldn't vreak if they aren't -# though -# see Eqs.(56),(57) https://arxiv.org/pdf/0808.1231.pdf for evolution basis definition -evolution = LinearBasis.from_mapping( - { - r"\Sigma": { - "u": 1, - "ubar": 1, - "d": 1, - "dbar": 1, - "s": 1, - "sbar": 1, - "c": 1, - "cbar": 1, - "b": 1, - "bbar": 1, - "t": 1, - "tbar": 1, - }, - "V": { - "u": 1, - "ubar": -1, - "d": 1, - "dbar": -1, - "s": 1, - "sbar": -1, - "c": 1, - "cbar": -1, - "b": 1, - "bbar": -1, - "t": 1, - "tbar": -1, - }, - "T3": {"u": 1, "ubar": 1, "d": -1, "dbar": -1}, - "V3": {"u": 1, "ubar": -1, "d": -1, "dbar": 1}, - "T8": {"u": 1, "ubar": 1, "d": 1, "dbar": 1, "s": -2, "sbar": -2}, - "V8": {"u": 1, "ubar": -1, "d": 1, "dbar": -1, "s": -2, "sbar": +2}, - "T15": { - "u": 1, - "ubar": 1, - "d": 1, - "dbar": 1, - "s": 1, - "sbar": 1, - "c": -3, - "cbar": -3, - }, - "V15": { - "u": 1, - "ubar": -1, - "d": 1, - "dbar": -1, - "s": 1, - "sbar": -1, - "c": -3, - "cbar": +3, - }, - "T24": { - "u": 1, - "ubar": 1, - "d": 1, - "dbar": 1, - "s": 1, - "sbar": 1, - "c": 1, - "cbar": 1, - "b": -4, - "bbar": -4, - }, - "V24": { - "u": 1, - "ubar": -1, - "d": 1, - "dbar": -1, - "s": 1, - "sbar": -1, - "c": 1, - "cbar": -1, - "b": -4, - "bbar": +4, - }, - "T35": { - "u": 1, - "ubar": 1, - "d": 1, - "dbar": 1, - "s": 1, - "sbar": 1, - "c": 1, - "cbar": 1, - "b": 1, - "bbar": 1, - "t": -5, - "tbar": -5, - }, - "V35": { - "u": 1, - "ubar": -1, - "d": 1, - "dbar": -1, - "s": 1, - "sbar": -1, - "c": 1, - "cbar": -1, - "b": 1, - "bbar": -1, - "t": -5, - "tbar": +5, - }, - "g": {"g": 1}, - "photon": {"photon": 1}, - }, - aliases={ - "gluon": "g", - "singlet": r"\Sigma", - "sng": r"\Sigma", - "sigma": r"\Sigma", - "v": "V", - "v3": "V3", - "v8": "V8", - "t3": "T3", - "t8": "T8", - "t15": "T15", - "v15": "V15", +#dicts are oredered in python 3.6+... code shouldn't vreak if they aren't +#though +#see Eqs.(56),(57) https://arxiv.org/pdf/0808.1231.pdf for evolution basis definition +evolution = LinearBasis.from_mapping({ + r'\Sigma' : {'u': 1, 'ubar': 1, 'd': 1, 'dbar': 1, 's': 1, 'sbar': 1, 'c': 1, 'cbar': 1 ,'b':1, 'bbar': 1, 't': 1, 'tbar': 1}, + 'V' : {'u': 1, 'ubar':-1, 'd': 1, 'dbar':-1, 's': 1, 'sbar':-1, 'c': 1, 'cbar':-1 ,'b':1, 'bbar':-1, 't': 1, 'tbar':-1}, + + 'T3' : {'u': 1, 'ubar': 1, 'd':-1, 'dbar':-1}, + 'V3' : {'u': 1, 'ubar':-1, 'd':-1, 'dbar': 1}, + + 'T8' : {'u': 1, 'ubar': 1, 'd': 1, 'dbar': 1, 's':-2, 'sbar':-2}, + 'V8' : {'u': 1, 'ubar':-1, 'd': 1, 'dbar':-1, 's':-2, 'sbar':+2}, + + 'T15' : {'u': 1, 'ubar': 1, 'd': 1, 'dbar': 1, 's': 1, 'sbar': 1, 'c':-3, 'cbar':-3}, + 'V15' : {'u': 1, 'ubar':-1, 'd': 1, 'dbar':-1, 's': 1, 'sbar':-1, 'c':-3, 'cbar':+3}, + + + 'T24' : {'u': 1, 'ubar': 1, 'd': 1, 'dbar': 1, 's': 1, 'sbar': 1, 'c': 1, 'cbar': 1, 'b':-4, 'bbar':-4}, + 'V24' : {'u': 1, 'ubar':-1, 'd': 1, 'dbar':-1, 's': 1, 'sbar':-1, 'c': 1, 'cbar':-1, 'b':-4, 'bbar':+4}, + + 'T35' : {'u': 1, 'ubar': 1, 'd': 1, 'dbar': 1, 's': 1, 'sbar': 1, 'c': 1, 'cbar': 1, 'b': 1, 'bbar': 1, 't':-5, 'tbar':-5}, + 'V35' : {'u': 1, 'ubar':-1, 'd': 1, 'dbar':-1, 's': 1, 'sbar':-1, 'c': 1, 'cbar':-1, 'b': 1, 'bbar':-1, 't':-5, 'tbar':+5}, + + 'g' : {'g':1}, + 'photon' : {'photon':1}, }, - default_elements=( - r"\Sigma", - "V", - "T3", - "V3", - "T8", - "V8", - "T15", - "gluon", - ), + aliases = {'gluon':'g', 'singlet': r'\Sigma', 'sng': r'\Sigma', 'sigma': r'\Sigma', + 'v': 'V', 'v3': 'V3', 'v8': 'V8', 't3': 'T3', 't8': 'T8', 't15': 'T15', 'v15': 'V15',}, + default_elements=(r'\Sigma', 'V', 'T3', 'V3', 'T8', 'V8', 'T15', 'gluon', ) ) EVOL = evolution ccbar_asymm = evolution -PDF4LHC20 = LinearBasis.from_mapping( - { - r"\Sigma": { - "u": 1, - "ubar": 1, - "d": 1, - "dbar": 1, - "s": 1, - "sbar": 1, - "c": 1, - "cbar": 1, - "b": 1, - "bbar": 1, - "t": 1, - "tbar": 1, - }, - "g": {"g": 1}, - "V": { - "u": 1, - "ubar": -1, - "d": 1, - "dbar": -1, - "s": 1, - "sbar": -1, - "c": 1, - "cbar": -1, - "b": 1, - "bbar": -1, - "t": 1, - "tbar": -1, - }, - "V3": {"u": 1, "ubar": -1, "d": -1, "dbar": 1}, - "T3": {"u": 1, "ubar": 1, "d": -1, "dbar": -1}, - "T8": {"u": 1, "ubar": 1, "d": 1, "dbar": 1, "s": -2, "sbar": -2}, - "photon": {"photon": 1}, - }, - aliases={ - "gluon": "g", - "singlet": r"\Sigma", - "sng": r"\Sigma", - "sigma": r"\Sigma", - "v": "V", - "v3": "V3", - "t3": "T3", - "t8": "T8", +PDF4LHC20 = LinearBasis.from_mapping({ + r'\Sigma': { + 'u': 1, 'ubar': 1, 'd': 1, 'dbar': 1, 's': 1, 'sbar': 1, + 'c': 1, 'cbar': 1, 'b': 1, 'bbar': 1, 't': 1, 'tbar': 1}, + 'g': {'g': 1}, + + 'V': { + 'u': 1, 'ubar': -1, 'd': 1, 'dbar': -1, 's': 1, 'sbar': -1, + 'c': 1, 'cbar': -1, 'b': 1, 'bbar': -1, 't': 1, 'tbar': -1}, + + 'V3': {'u': 1, 'ubar': -1, 'd': -1, 'dbar': 1}, + + 'T3': {'u': 1, 'ubar': 1, 'd': -1, 'dbar': -1}, + 'T8': {'u': 1, 'ubar': 1, 'd': 1, 'dbar': 1, 's': -2, 'sbar': -2}, + + 'photon': {'photon': 1}, }, - default_elements=( - r"\Sigma", - "gluon", - "V", - "V3", - "T3", - "T8", - ), -) + aliases = {'gluon':'g', 'singlet': r'\Sigma', 'sng': r'\Sigma', 'sigma': r'\Sigma', + 'v': 'V', 'v3': 'V3', 't3': 'T3', 't8': 'T8'}, + default_elements=(r'\Sigma', 'gluon', 'V', 'V3', 'T3', 'T8', )) NN31IC = LinearBasis.from_mapping( { - r"\Sigma": { - "u": 1, - "ubar": 1, - "d": 1, - "dbar": 1, - "s": 1, - "sbar": 1, - "c": 1, - "cbar": 1, - "b": 1, - "bbar": 1, - "t": 1, - "tbar": 1, - }, - "g": {"g": 1}, - "V": { - "u": 1, - "ubar": -1, - "d": 1, - "dbar": -1, - "s": 1, - "sbar": -1, - "c": 1, - "cbar": -1, - "b": 1, - "bbar": -1, - "t": 1, - "tbar": -1, - }, - "V3": {"u": 1, "ubar": -1, "d": -1, "dbar": 1}, - "V8": {"u": 1, "ubar": -1, "d": 1, "dbar": -1, "s": -2, "sbar": +2}, - "T3": {"u": 1, "ubar": 1, "d": -1, "dbar": -1}, - "T8": {"u": 1, "ubar": 1, "d": 1, "dbar": 1, "s": -2, "sbar": -2}, - r"c^+": {"c": 1, "cbar": 1}, - "photon": {"photon": 1}, + r'\Sigma': { + 'u': 1, 'ubar': 1, 'd': 1, 'dbar': 1, 's': 1, 'sbar': 1, + 'c': 1, 'cbar': 1, 'b': 1, 'bbar': 1, 't': 1, 'tbar': 1}, + 'g': {'g': 1}, + + 'V': { + 'u': 1, 'ubar': -1, 'd': 1, 'dbar': -1, 's': 1, 'sbar': -1, + 'c': 1, 'cbar': -1, 'b': 1, 'bbar': -1, 't': 1, 'tbar': -1}, + + 'V3': {'u': 1, 'ubar': -1, 'd': -1, 'dbar': 1}, + 'V8': {'u': 1, 'ubar': -1, 'd': 1, 'dbar': -1, 's': -2, 'sbar': +2}, + + 'T3': {'u': 1, 'ubar': 1, 'd': -1, 'dbar': -1}, + 'T8': {'u': 1, 'ubar': 1, 'd': 1, 'dbar': 1, 's': -2, 'sbar': -2}, + + r'c^+': {'c': 1, 'cbar': 1}, + + 'photon': {'photon': 1}, }, aliases={ - "gluon": "g", - "singlet": r"\Sigma", - "sng": r"\Sigma", - "sigma": r"\Sigma", - "cp": r"c^+", - "v": "V", - "v3": "V3", - "v8": "V8", - "t3": "T3", - "t8": "T8", - }, - default_elements=( - r"\Sigma", - "gluon", - "V", - "V3", - "V8", - "T3", - "T8", - r"c^+", - ), -) + 'gluon': 'g', 'singlet': r'\Sigma', 'sng': r'\Sigma', 'sigma': r'\Sigma', 'cp': r'c^+', + 'v': 'V', 'v3': 'V3', 'v8': 'V8', 't3': 'T3', 't8': 'T8'}, + default_elements=(r'\Sigma', 'gluon', 'V', 'V3', 'V8', 'T3', 'T8', r'c^+', )) NN31PC = LinearBasis.from_mapping( { - r"\Sigma": { - "u": 1, - "ubar": 1, - "d": 1, - "dbar": 1, - "s": 1, - "sbar": 1, - "c": 1, - "cbar": 1, - "b": 1, - "bbar": 1, - "t": 1, - "tbar": 1, - }, - "g": {"g": 1}, - "V": { - "u": 1, - "ubar": -1, - "d": 1, - "dbar": -1, - "s": 1, - "sbar": -1, - "c": 1, - "cbar": -1, - "b": 1, - "bbar": -1, - "t": 1, - "tbar": -1, - }, - "V3": {"u": 1, "ubar": -1, "d": -1, "dbar": 1}, - "V8": {"u": 1, "ubar": -1, "d": 1, "dbar": -1, "s": -2, "sbar": +2}, - "T3": {"u": 1, "ubar": 1, "d": -1, "dbar": -1}, - "T8": {"u": 1, "ubar": 1, "d": 1, "dbar": 1, "s": -2, "sbar": -2}, - "photon": {"photon": 1}, + r'\Sigma': { + 'u': 1, 'ubar': 1, 'd': 1, 'dbar': 1, 's': 1, 'sbar': 1, + 'c': 1, 'cbar': 1, 'b': 1, 'bbar': 1, 't': 1, 'tbar': 1}, + 'g': {'g': 1}, + + 'V': { + 'u': 1, 'ubar': -1, 'd': 1, 'dbar': -1, 's': 1, 'sbar': -1, + 'c': 1, 'cbar': -1, 'b': 1, 'bbar': -1, 't': 1, 'tbar': -1}, + + 'V3': {'u': 1, 'ubar': -1, 'd': -1, 'dbar': 1}, + 'V8': {'u': 1, 'ubar': -1, 'd': 1, 'dbar': -1, 's': -2, 'sbar': +2}, + + 'T3': {'u': 1, 'ubar': 1, 'd': -1, 'dbar': -1}, + 'T8': {'u': 1, 'ubar': 1, 'd': 1, 'dbar': 1, 's': -2, 'sbar': -2}, + 'photon': {'photon': 1}, }, aliases={ - "gluon": "g", - "singlet": r"\Sigma", - "sng": r"\Sigma", - "sigma": r"\Sigma", - "v": "V", - "v3": "V3", - "v8": "V8", - "t3": "T3", - "t8": "T8", - }, - default_elements=(r"\Sigma", "gluon", "V", "V3", "V8", "T3", "T8"), -) + 'gluon': 'g', 'singlet': r'\Sigma', 'sng': r'\Sigma', 'sigma': r'\Sigma', + 'v': 'V', 'v3': 'V3', 'v8': 'V8', 't3': 'T3', 't8': 'T8'}, + default_elements=(r'\Sigma', 'gluon', 'V', 'V3', 'V8', 'T3', 'T8')) FLAVOUR = LinearBasis.from_mapping( { - "u": {"u": 1}, - "ubar": {"ubar": 1}, - "d": {"d": 1}, - "dbar": {"dbar": 1}, - "s": {"s": 1}, - "sbar": {"sbar": 1}, - "c": {"c": 1}, - "g": {"g": 1}, + 'u': {'u': 1}, + 'ubar': {'ubar': 1}, + 'd': {'d': 1}, + 'dbar': {'dbar': 1}, + 's': {'s': 1}, + 'sbar': {'sbar': 1}, + 'c': {'c': 1}, + 'g': {'g': 1}, }, - default_elements=( - "u", - "ubar", - "d", - "dbar", - "s", - "sbar", - "c", - "g", - ), -) - -pdg = LinearBasis.from_mapping( - { - "g/10": {"g": 0.1}, - "u_{v}": {"u": 1, "ubar": -1}, - "d_{v}": {"d": 1, "dbar": -1}, - "s": {"s": 1}, - r"\bar{u}": {"ubar": 1}, - r"\bar{d}": {"dbar": 1}, - "c": {"c": 1}, - } -) - + default_elements=('u', 'ubar', 'd', 'dbar', 's', 'sbar', 'c', 'g', )) + +pdg = LinearBasis.from_mapping({ +'g/10': {'g':0.1}, +'u_{v}': {'u':1, 'ubar':-1}, +'d_{v}': {'d':1, 'dbar': -1}, +'s': {'s':1}, +r'\bar{u}': {'ubar':1}, +r'\bar{d}': {'dbar':1}, +'c': {'c':1}, +}) @scalar_function_transformation(label="u_V") def u_valence(func, xmat, qmat): @@ -853,7 +610,6 @@ def u_valence(func, xmat, qmat): ubar = gv[:, [1], ...] return u - ubar - @scalar_function_transformation(label="d_V") def d_valence(func, xmat, qmat): gv = func([1, -1], xmat, qmat) @@ -861,7 +617,6 @@ def d_valence(func, xmat, qmat): dbar = gv[:, [1], ...] return d - dbar - @scalar_function_transformation(label="S") def total_sea(func, xmat, qmat): gv = func([3, -2, -1, -3], xmat, qmat) @@ -869,8 +624,7 @@ def total_sea(func, xmat, qmat): ubar = gv[:, [1], ...] dbar = gv[:, [2], ...] sbar = gv[:, [3], ...] - return 2.0 * (ubar + dbar) + s + sbar - + return 2.*(ubar + dbar) + s + sbar @scalar_function_transformation(label="u/d") def ud_ratio(func, xmat, qmat): @@ -879,7 +633,6 @@ def ud_ratio(func, xmat, qmat): den = gv[:, [1], ...] return num / den - @scalar_function_transformation(label="d/u") def du_ratio(func, xmat, qmat): gv = func([1, 2], xmat, qmat) @@ -887,7 +640,6 @@ def du_ratio(func, xmat, qmat): den = gv[:, [1], ...] return num / den - @scalar_function_transformation(label=r"\bar{d}/\bar{u}") def dbarubar_ratio(func, xmat, qmat): gv = func([-1, -2], xmat, qmat) @@ -895,14 +647,14 @@ def dbarubar_ratio(func, xmat, qmat): den = gv[:, [1], ...] return num / den - + @scalar_function_transformation(label="Rs", element_representations={"Rs": "R_{s}"}) def strange_fraction(func, xmat, qmat): gv = func([-3, 3, -2, -1], xmat, qmat) sbar, s, ubar, dbar = (gv[:, [i], ...] for i in range(4)) return (sbar + s) / (ubar + dbar) - + def fitbasis_to_NN31IC(flav_info, fitbasis): """Return a rotation matrix R_{ij} which takes from one of the possible fitting basis (evolution, NN31IC, FLAVOUR) to the NN31IC basis, @@ -933,173 +685,66 @@ def fitbasis_to_NN31IC(flav_info, fitbasis): matrix performing the change of basis from fitbasis to NN31IC """ - if fitbasis == "NN31IC": - return np.identity(8) - - elif fitbasis == "NN31PC": - sng = {"sng": 1, "v": 0, "v3": 0, "v8": 0, "t3": 0, "t8": 0, "g": 0} - v = {"sng": 0, "v": 1, "v3": 0, "v8": 0, "t3": 0, "t8": 0, "g": 0} - v3 = {"sng": 0, "v": 0, "v3": 1, "v8": 0, "t3": 0, "t8": 0, "g": 0} - v8 = {"sng": 0, "v": 0, "v3": 0, "v8": 1, "t3": 0, "t8": 0, "g": 0} - t3 = {"sng": 0, "v": 0, "v3": 0, "v8": 0, "t3": 1, "t8": 0, "g": 0} - t8 = {"sng": 0, "v": 0, "v3": 0, "v8": 0, "t3": 0, "t8": 1, "g": 0} - cp = {"sng": 0, "v": 0, "v3": 0, "v8": 0, "t3": 0, "t8": 0, "g": 0} - g = {"sng": 0, "v": 0, "v3": 0, "v8": 0, "t3": 0, "t8": 0, "g": 1} - v15 = {"sng": 0, "v": 0, "v3": 0, "v8": 0, "t3": 0, "t8": 0, "t15": 0, "g": 0} - - elif fitbasis == "FLAVOUR": - sng = {"u": 1, "ubar": 1, "d": 1, "dbar": 1, "s": 1, "sbar": 1, "c": 2, "g": 0} - v = {"u": 1, "ubar": -1, "d": 1, "dbar": -1, "s": 1, "sbar": -1, "c": 0, "g": 0} - v3 = {"u": 1, "ubar": -1, "d": -1, "dbar": 1, "s": 0, "sbar": 0, "c": 0, "g": 0} - v8 = { - "u": 1, - "ubar": -1, - "d": 1, - "dbar": -1, - "s": -2, - "sbar": 2, - "c": 0, - "g": 0, - } - t3 = {"u": 1, "ubar": 1, "d": -1, "dbar": -1, "s": 0, "sbar": 0, "c": 0, "g": 0} - t8 = {"u": 1, "ubar": 1, "d": 1, "dbar": 1, "s": -2, "sbar": -2, "c": 0, "g": 0} - cp = {"u": 0, "ubar": 0, "d": 0, "dbar": 0, "s": 0, "sbar": 0, "c": 2, "g": 0} - g = {"u": 0, "ubar": 0, "d": 0, "dbar": 0, "s": 0, "sbar": 0, "c": 0, "g": 1} - v15 = {"sng": 0, "v": 0, "v3": 0, "v8": 0, "t3": 0, "t8": 0, "t15": 0, "g": 0} - - elif fitbasis == "EVOL" or fitbasis == "evolution": - sng = {"sng": 1, "v": 0, "v3": 0, "v8": 0, "t3": 0, "t8": 0, "t15": 0, "g": 0} - v = {"sng": 0, "v": 1, "v3": 0, "v8": 0, "t3": 0, "t8": 0, "t15": 0, "g": 0} - v3 = {"sng": 0, "v": 0, "v3": 1, "v8": 0, "t3": 0, "t8": 0, "t15": 0, "g": 0} - v8 = {"sng": 0, "v": 0, "v3": 0, "v8": 1, "t3": 0, "t8": 0, "t15": 0, "g": 0} - t3 = {"sng": 0, "v": 0, "v3": 0, "v8": 0, "t3": 1, "t8": 0, "t15": 0, "g": 0} - t8 = {"sng": 0, "v": 0, "v3": 0, "v8": 0, "t3": 0, "t8": 1, "t15": 0, "g": 0} - cp = { - "sng": 0.25, - "v": 0, - "v3": 0, - "v8": 0, - "t3": 0, - "t8": 0, - "t15": -0.25, - "g": 0, - } - g = {"sng": 0, "v": 0, "v3": 0, "v8": 0, "t3": 0, "t8": 0, "t15": 0, "g": 1} - v15 = {"sng": 0, "v": 0, "v3": 0, "v8": 0, "t3": 0, "t8": 0, "t15": 0, "g": 0} - - elif fitbasis == "PDF4LHC20": - sng = {"sng": 1, "v": 0, "v3": 0, "v8": 0, "t3": 0, "t8": 0, "t15": 0, "g": 0} - v = {"sng": 0, "v": 1, "v3": 0, "v8": 0, "t3": 0, "t8": 0, "t15": 0, "g": 0} - v3 = {"sng": 0, "v": 0, "v3": 1, "v8": 0, "t3": 0, "t8": 0, "t15": 0, "g": 0} - v8 = {"sng": 0, "v": 1, "v3": 0, "v8": 0, "t3": 0, "t8": 0, "t15": 0, "g": 0} - t3 = {"sng": 0, "v": 0, "v3": 0, "v8": 0, "t3": 1, "t8": 0, "t15": 0, "g": 0} - t8 = {"sng": 0, "v": 0, "v3": 0, "v8": 0, "t3": 0, "t8": 1, "t15": 0, "g": 0} - cp = {"sng": 0, "v": 0, "v3": 0, "v8": 0, "t3": 0, "t8": 0, "t15": 0, "g": 0} - g = {"sng": 0, "v": 0, "v3": 0, "v8": 0, "t3": 0, "t8": 0, "t15": 0, "g": 1} - v15 = {"sng": 0, "v": 0, "v3": 0, "v8": 0, "t3": 0, "t8": 0, "t15": 0, "g": 0} - + if fitbasis == 'NN31IC': + return np.identity(9) + + elif fitbasis == 'NN31PC': + sng = {'sng': 1, 'v': 0, 'v3': 0, 'v8': 0, 't3': 0, 't8': 0, 'g': 0 } + v = {'sng': 0, 'v': 1, 'v3': 0, 'v8': 0, 't3': 0, 't8': 0, 'g': 0 } + v3 = {'sng': 0, 'v': 0, 'v3': 1, 'v8': 0, 't3': 0, 't8': 0, 'g': 0 } + v8 = {'sng': 0, 'v': 0, 'v3': 0, 'v8': 1, 't3': 0, 't8': 0, 'g': 0 } + t3 = {'sng': 0, 'v': 0, 'v3': 0, 'v8': 0, 't3': 1, 't8': 0, 'g': 0 } + t8 = {'sng': 0, 'v': 0, 'v3': 0, 'v8': 0, 't3': 0, 't8': 1, 'g': 0 } + cp = {'sng': 0, 'v': 0, 'v3': 0, 'v8': 0, 't3': 0, 't8': 0, 'g': 0 } + g = {'sng': 0, 'v': 0, 'v3': 0, 'v8': 0, 't3': 0, 't8': 0, 'g': 1 } + v15 = {'sng': 0, 'v': 0, 'v3': 0, 'v8': 0, 't3': 0, 't8': 0, 't15': 0, 'g': 0} + + elif fitbasis == 'FLAVOUR': + sng = {'u': 1, 'ubar': 1, 'd': 1, 'dbar': 1, 's': 1, 'sbar': 1, 'c': 2, 'g': 0 } + v = {'u': 1, 'ubar': -1, 'd': 1, 'dbar': -1, 's': 1, 'sbar': -1, 'c': 0, 'g': 0 } + v3 = {'u': 1, 'ubar': -1, 'd': -1, 'dbar': 1, 's': 0, 'sbar': 0, 'c': 0, 'g': 0 } + v8 = {'u': 1, 'ubar': -1, 'd': 1, 'dbar': -1, 's': -2, 'sbar': 2, 'c': 0, 'g': 0 } + t3 = {'u': 1, 'ubar': 1, 'd': -1, 'dbar': -1, 's': 0, 'sbar': 0, 'c': 0, 'g': 0 } + t8 = {'u': 1, 'ubar': 1, 'd': 1, 'dbar': 1, 's': -2, 'sbar': -2, 'c': 0, 'g': 0 } + cp = {'u': 0, 'ubar': 0, 'd': 0, 'dbar': 0, 's': 0, 'sbar': 0, 'c': 2, 'g': 0 } + g = {'u': 0, 'ubar': 0, 'd': 0, 'dbar': 0, 's': 0, 'sbar': 0, 'c': 0, 'g': 1 } + v15 = {'u': 0, 'ubar': 0, 'd': 0, 'dbar': 0, 's': 0, 'sbar': 0, 'c': 0, 'g': 0 } + + elif fitbasis == 'EVOL' or fitbasis == 'evolution': + sng = {'sng': 1, 'v': 0, 'v3': 0, 'v8': 0, 't3': 0, 't8': 0, 't15': 0, 'g': 0 } + v = {'sng': 0, 'v': 1, 'v3': 0, 'v8': 0, 't3': 0, 't8': 0, 't15': 0, 'g': 0 } + v3 = {'sng': 0, 'v': 0, 'v3': 1, 'v8': 0, 't3': 0, 't8': 0, 't15': 0, 'g': 0 } + v8 = {'sng': 0, 'v': 0, 'v3': 0, 'v8': 1, 't3': 0, 't8': 0, 't15': 0, 'g': 0 } + t3 = {'sng': 0, 'v': 0, 'v3': 0, 'v8': 0, 't3': 1, 't8': 0, 't15': 0, 'g': 0 } + t8 = {'sng': 0, 'v': 0, 'v3': 0, 'v8': 0, 't3': 0, 't8': 1, 't15': 0, 'g': 0 } + cp = {'sng': 0.25, 'v': 0, 'v3': 0, 'v8': 0, 't3': 0, 't8': 0, 't15': -0.25, 'g': 0 } + g = {'sng': 0, 'v': 0, 'v3': 0, 'v8': 0, 't3': 0, 't8': 0, 't15': 0, 'g': 1 } + v15 = {'sng': 0, 'v': 0, 'v3': 0, 'v8': 0, 't3': 0, 't8': 0, 't15': 0, 'g': 0 } + + elif fitbasis == 'PDF4LHC20': + sng = {'sng': 1, 'v': 0, 'v3': 0, 'v8': 0, 't3': 0, 't8': 0, 't15': 0, 'g': 0 } + v = {'sng': 0, 'v': 1, 'v3': 0, 'v8': 0, 't3': 0, 't8': 0, 't15': 0, 'g': 0 } + v3 = {'sng': 0, 'v': 0, 'v3': 1, 'v8': 0, 't3': 0, 't8': 0, 't15': 0, 'g': 0 } + v8 = {'sng': 0, 'v': 1, 'v3': 0, 'v8': 0, 't3': 0, 't8': 0, 't15': 0, 'g': 0 } + t3 = {'sng': 0, 'v': 0, 'v3': 0, 'v8': 0, 't3': 1, 't8': 0, 't15': 0, 'g': 0 } + t8 = {'sng': 0, 'v': 0, 'v3': 0, 'v8': 0, 't3': 0, 't8': 1, 't15': 0, 'g': 0 } + cp = {'sng': 0, 'v': 0, 'v3': 0, 'v8': 0, 't3': 0, 't8': 0, 't15': 0, 'g': 0 } + g = {'sng': 0, 'v': 0, 'v3': 0, 'v8': 0, 't3': 0, 't8': 0, 't15': 0, 'g': 1 } + v15 = {'sng': 0, 'v': 0, 'v3': 0, 'v8': 0, 't3': 0, 't8': 0, 't15': 0, 'g': 1 } + elif fitbasis == "ccbar_asymm": - sng = { - "sng": 1, - "v": 0, - "v3": 0, - "v8": 0, - "t3": 0, - "t8": 0, - "t15": 0, - "g": 0, - "v15": 0, - } - v = { - "sng": 0, - "v": 1, - "v3": 0, - "v8": 0, - "t3": 0, - "t8": 0, - "t15": 0, - "g": 0, - "v15": 0, - } - v3 = { - "sng": 0, - "v": 0, - "v3": 1, - "v8": 0, - "t3": 0, - "t8": 0, - "t15": 0, - "g": 0, - "v15": 0, - } - v8 = { - "sng": 0, - "v": 1, - "v3": 0, - "v8": 0, - "t3": 0, - "t8": 0, - "t15": 0, - "g": 0, - "v15": 0, - } - v15 = { - "sng": 0, - "v": 0, - "v3": 0, - "v8": 0, - "t3": 0, - "t8": 0, - "t15": 0, - "g": 0, - "v15": 1, - } - t3 = { - "sng": 0, - "v": 0, - "v3": 0, - "v8": 0, - "t3": 1, - "t8": 0, - "t15": 0, - "g": 0, - "v15": 0, - } - t8 = { - "sng": 0, - "v": 0, - "v3": 0, - "v8": 0, - "t3": 0, - "t8": 1, - "t15": 0, - "g": 0, - "v15": 0, - } - cp = { - "sng": 0.25, - "v": 0, - "v3": 0, - "v8": 0, - "t3": 0, - "t8": 0, - "t15": -0.25, - "g": 0, - "v15": 0, - } - g = { - "sng": 0, - "v": 0, - "v3": 0, - "v8": 0, - "t3": 0, - "t8": 0, - "t15": 0, - "g": 1, - "v15": 0, - } + sng = {'sng': 1, 'v': 0, 'v3': 0, 'v8': 0, 't3': 0, 't8': 0, 't15': 0, 'g': 0, 'v15': 0 } + v = {'sng': 0, 'v': 1, 'v3': 0, 'v8': 0, 't3': 0, 't8': 0, 't15': 0, 'g': 0, 'v15': 0 } + v3 = {'sng': 0, 'v': 0, 'v3': 1, 'v8': 0, 't3': 0, 't8': 0, 't15': 0, 'g': 0, 'v15': 0 } + v8 = {'sng': 0, 'v': 0, 'v3': 0, 'v8': 1, 't3': 0, 't8': 0, 't15': 0, 'g': 0, 'v15': 0 } + t3 = {'sng': 0, 'v': 0, 'v3': 0, 'v8': 0, 't3': 1, 't8': 0, 't15': 0, 'g': 0, 'v15': 0 } + t8 = {'sng': 0, 'v': 0, 'v3': 0, 'v8': 0, 't3': 0, 't8': 1, 't15': 0, 'g': 0, 'v15': 0 } + cp = {'sng': 0.25, 'v': 0, 'v3': 0, 'v8': 0, 't3': 0, 't8': 0, 't15': -0.25, 'g': 0, 'v15': 0 } + g = {'sng': 0, 'v': 0, 'v3': 0, 'v8': 0, 't3': 0, 't8': 0, 't15': 0, 'g': 1, 'v15': 0 } + v15 = {'sng': 0, 'v': 0, 'v3': 0, 'v8': 0, 't3': 0, 't8': 0, 't15': 0, 'g': 0, 'v15': 1 } flist = [sng, g, v, v3, v8, t3, t8, cp, v15] + mat = [] for f in flist: for flav_dict in flav_info: @@ -1108,6 +753,5 @@ def fitbasis_to_NN31IC(flav_info, fitbasis): nflavs = len(flav_info) mat = np.asarray(mat).reshape(9, nflavs) - # Return the transpose of the matrix, to have the first index referring to flavour return mat.transpose() From 15343f174fac72510c64aa523da463c0a0aedfe0 Mon Sep 17 00:00:00 2001 From: tgiani Date: Wed, 16 Nov 2022 09:25:25 +0100 Subject: [PATCH 03/14] small fix --- validphys2/src/validphys/pdfbases.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/validphys2/src/validphys/pdfbases.py b/validphys2/src/validphys/pdfbases.py index 2186902a78..4d71eaf39d 100644 --- a/validphys2/src/validphys/pdfbases.py +++ b/validphys2/src/validphys/pdfbases.py @@ -730,7 +730,7 @@ def fitbasis_to_NN31IC(flav_info, fitbasis): t8 = {'sng': 0, 'v': 0, 'v3': 0, 'v8': 0, 't3': 0, 't8': 1, 't15': 0, 'g': 0 } cp = {'sng': 0, 'v': 0, 'v3': 0, 'v8': 0, 't3': 0, 't8': 0, 't15': 0, 'g': 0 } g = {'sng': 0, 'v': 0, 'v3': 0, 'v8': 0, 't3': 0, 't8': 0, 't15': 0, 'g': 1 } - v15 = {'sng': 0, 'v': 0, 'v3': 0, 'v8': 0, 't3': 0, 't8': 0, 't15': 0, 'g': 1 } + v15 = {'sng': 0, 'v': 0, 'v3': 0, 'v8': 0, 't3': 0, 't8': 0, 't15': 0, 'g': 0 } elif fitbasis == "ccbar_asymm": sng = {'sng': 1, 'v': 0, 'v3': 0, 'v8': 0, 't3': 0, 't8': 0, 't15': 0, 'g': 0, 'v15': 0 } From d78ab13d91dc35af285fa732f3ac79403b8ba69d Mon Sep 17 00:00:00 2001 From: tgiani Date: Wed, 16 Nov 2022 10:44:15 +0100 Subject: [PATCH 04/14] fix NN31IC basis --- validphys2/src/validphys/pdfbases.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/validphys2/src/validphys/pdfbases.py b/validphys2/src/validphys/pdfbases.py index 4d71eaf39d..ef2fb0b78f 100644 --- a/validphys2/src/validphys/pdfbases.py +++ b/validphys2/src/validphys/pdfbases.py @@ -686,7 +686,8 @@ def fitbasis_to_NN31IC(flav_info, fitbasis): """ if fitbasis == 'NN31IC': - return np.identity(9) + mat = np.concatenate([np.identity(8), [np.zeros(8)]]) + return mat.transpose() elif fitbasis == 'NN31PC': sng = {'sng': 1, 'v': 0, 'v3': 0, 'v8': 0, 't3': 0, 't8': 0, 'g': 0 } From eee67d86875d98510ae3b447a5180f19ebce4623 Mon Sep 17 00:00:00 2001 From: tgiani Date: Wed, 16 Nov 2022 11:12:40 +0100 Subject: [PATCH 05/14] setting v15=v when c-cbar=0 --- validphys2/src/validphys/pdfbases.py | 19 +++++++++++++------ 1 file changed, 13 insertions(+), 6 deletions(-) diff --git a/validphys2/src/validphys/pdfbases.py b/validphys2/src/validphys/pdfbases.py index ef2fb0b78f..c06a38b1eb 100644 --- a/validphys2/src/validphys/pdfbases.py +++ b/validphys2/src/validphys/pdfbases.py @@ -686,8 +686,15 @@ def fitbasis_to_NN31IC(flav_info, fitbasis): """ if fitbasis == 'NN31IC': - mat = np.concatenate([np.identity(8), [np.zeros(8)]]) - return mat.transpose() + sng = {'sng': 1, 'v': 0, 'v3': 0, 'v8': 0, 't3': 0, 't8': 0, 'cp': 0, 'g': 0 } + v = {'sng': 0, 'v': 1, 'v3': 0, 'v8': 0, 't3': 0, 't8': 0, 'cp': 0, 'g': 0 } + v3 = {'sng': 0, 'v': 0, 'v3': 1, 'v8': 0, 't3': 0, 't8': 0, 'cp': 0, 'g': 0 } + v8 = {'sng': 0, 'v': 0, 'v3': 0, 'v8': 1, 't3': 0, 't8': 0, 'cp': 0, 'g': 0 } + t3 = {'sng': 0, 'v': 0, 'v3': 0, 'v8': 0, 't3': 1, 't8': 0, 'cp': 0, 'g': 0 } + t8 = {'sng': 0, 'v': 0, 'v3': 0, 'v8': 0, 't3': 0, 't8': 1, 'cp': 0, 'g': 0 } + cp = {'sng': 0, 'v': 0, 'v3': 0, 'v8': 0, 't3': 0, 't8': 0, 'cp': 1, 'g': 0 } + g = {'sng': 0, 'v': 0, 'v3': 0, 'v8': 0, 't3': 0, 't8': 0, 'cp': 0, 'g': 1 } + v15 = {'sng': 0, 'v': 1, 'v3': 0, 'v8': 0, 't3': 0, 't8': 0, 'cp': 0, 'g': 0 } elif fitbasis == 'NN31PC': sng = {'sng': 1, 'v': 0, 'v3': 0, 'v8': 0, 't3': 0, 't8': 0, 'g': 0 } @@ -698,7 +705,7 @@ def fitbasis_to_NN31IC(flav_info, fitbasis): t8 = {'sng': 0, 'v': 0, 'v3': 0, 'v8': 0, 't3': 0, 't8': 1, 'g': 0 } cp = {'sng': 0, 'v': 0, 'v3': 0, 'v8': 0, 't3': 0, 't8': 0, 'g': 0 } g = {'sng': 0, 'v': 0, 'v3': 0, 'v8': 0, 't3': 0, 't8': 0, 'g': 1 } - v15 = {'sng': 0, 'v': 0, 'v3': 0, 'v8': 0, 't3': 0, 't8': 0, 't15': 0, 'g': 0} + v15 = {'sng': 0, 'v': 1, 'v3': 0, 'v8': 0, 't3': 0, 't8': 0, 't15': 0, 'g': 0} elif fitbasis == 'FLAVOUR': sng = {'u': 1, 'ubar': 1, 'd': 1, 'dbar': 1, 's': 1, 'sbar': 1, 'c': 2, 'g': 0 } @@ -709,7 +716,7 @@ def fitbasis_to_NN31IC(flav_info, fitbasis): t8 = {'u': 1, 'ubar': 1, 'd': 1, 'dbar': 1, 's': -2, 'sbar': -2, 'c': 0, 'g': 0 } cp = {'u': 0, 'ubar': 0, 'd': 0, 'dbar': 0, 's': 0, 'sbar': 0, 'c': 2, 'g': 0 } g = {'u': 0, 'ubar': 0, 'd': 0, 'dbar': 0, 's': 0, 'sbar': 0, 'c': 0, 'g': 1 } - v15 = {'u': 0, 'ubar': 0, 'd': 0, 'dbar': 0, 's': 0, 'sbar': 0, 'c': 0, 'g': 0 } + v15 = {'u': 1, 'ubar': -1, 'd': 1, 'dbar': -1, 's': 1, 'sbar': -1, 'c': 0, 'g': 0 } elif fitbasis == 'EVOL' or fitbasis == 'evolution': sng = {'sng': 1, 'v': 0, 'v3': 0, 'v8': 0, 't3': 0, 't8': 0, 't15': 0, 'g': 0 } @@ -720,7 +727,7 @@ def fitbasis_to_NN31IC(flav_info, fitbasis): t8 = {'sng': 0, 'v': 0, 'v3': 0, 'v8': 0, 't3': 0, 't8': 1, 't15': 0, 'g': 0 } cp = {'sng': 0.25, 'v': 0, 'v3': 0, 'v8': 0, 't3': 0, 't8': 0, 't15': -0.25, 'g': 0 } g = {'sng': 0, 'v': 0, 'v3': 0, 'v8': 0, 't3': 0, 't8': 0, 't15': 0, 'g': 1 } - v15 = {'sng': 0, 'v': 0, 'v3': 0, 'v8': 0, 't3': 0, 't8': 0, 't15': 0, 'g': 0 } + v15 = {'sng': 0, 'v': 1, 'v3': 0, 'v8': 0, 't3': 0, 't8': 0, 't15': 0, 'g': 0 } elif fitbasis == 'PDF4LHC20': sng = {'sng': 1, 'v': 0, 'v3': 0, 'v8': 0, 't3': 0, 't8': 0, 't15': 0, 'g': 0 } @@ -731,7 +738,7 @@ def fitbasis_to_NN31IC(flav_info, fitbasis): t8 = {'sng': 0, 'v': 0, 'v3': 0, 'v8': 0, 't3': 0, 't8': 1, 't15': 0, 'g': 0 } cp = {'sng': 0, 'v': 0, 'v3': 0, 'v8': 0, 't3': 0, 't8': 0, 't15': 0, 'g': 0 } g = {'sng': 0, 'v': 0, 'v3': 0, 'v8': 0, 't3': 0, 't8': 0, 't15': 0, 'g': 1 } - v15 = {'sng': 0, 'v': 0, 'v3': 0, 'v8': 0, 't3': 0, 't8': 0, 't15': 0, 'g': 0 } + v15 = {'sng': 0, 'v': 1, 'v3': 0, 'v8': 0, 't3': 0, 't8': 0, 't15': 0, 'g': 0 } elif fitbasis == "ccbar_asymm": sng = {'sng': 1, 'v': 0, 'v3': 0, 'v8': 0, 't3': 0, 't8': 0, 't15': 0, 'g': 0, 'v15': 0 } From f19827ba285d137cf93f6a872f1811e3f30d5d8b Mon Sep 17 00:00:00 2001 From: tgiani Date: Wed, 16 Nov 2022 11:28:54 +0100 Subject: [PATCH 06/14] fixing vpinterface test --- n3fit/src/n3fit/tests/test_vpinterface.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/n3fit/src/n3fit/tests/test_vpinterface.py b/n3fit/src/n3fit/tests/test_vpinterface.py index 6b9edf0d15..3575308cc1 100644 --- a/n3fit/src/n3fit/tests/test_vpinterface.py +++ b/n3fit/src/n3fit/tests/test_vpinterface.py @@ -14,7 +14,7 @@ def generate_n3pdf(layers=1, members=1, name="n3fit"): """Generate a N3PDF model""" fake_fl = [ {"fl": i, "largex": [0, 1], "smallx": [1, 2]} - for i in ["u", "ubar", "d", "dbar", "c", "cbar", "s", "sbar"] + for i in ["u", "ubar", "d", "dbar", "c", "g", "s", "sbar"] ] nodes = list(np.random.randint(1, 10, size=layers)) + [8] activations = ["tanh"] * layers + ["linear"] @@ -24,6 +24,7 @@ def generate_n3pdf(layers=1, members=1, name="n3fit"): seed=np.random.randint(100), flav_info=fake_fl, parallel_models=members, + fitbasis="FLAVOUR" ) return N3PDF(pdf_model, name=name) From cfba72ca11bc41c3037d307652d9d129ae4cac79 Mon Sep 17 00:00:00 2001 From: tgiani Date: Fri, 18 Nov 2022 16:40:12 +0100 Subject: [PATCH 07/14] fix sumrules --- n3fit/src/n3fit/layers/msr_normalization.py | 13 ++++++++----- n3fit/src/n3fit/msr.py | 3 +-- 2 files changed, 9 insertions(+), 7 deletions(-) diff --git a/n3fit/src/n3fit/layers/msr_normalization.py b/n3fit/src/n3fit/layers/msr_normalization.py index d5af933e5e..2a73fd238d 100644 --- a/n3fit/src/n3fit/layers/msr_normalization.py +++ b/n3fit/src/n3fit/layers/msr_normalization.py @@ -2,9 +2,10 @@ from n3fit.backends import operations as op GLUON_IDX = [[2]] -V_IDX = [[3], [6], [7], [8]] +V_IDX = [[3], [6], [7]] V3_IDX = [[4]] V8_IDX = [[5]] +V15_IDX = [[8]] class MSR_Normalization(MetaLayer): @@ -30,7 +31,7 @@ def __init__(self, output_dim=14, mode="ALL", **kwargs): if self._msr_enabled: idx += GLUON_IDX if self._vsr_enabled: - idx += V_IDX + V3_IDX + V8_IDX + idx += V_IDX + V3_IDX + V8_IDX + V15_IDX self._out_scatter = op.as_layer( op.scatter_to_one, op_kwargs={"indices": idx, "output_dim": output_dim} @@ -41,9 +42,10 @@ def __init__(self, output_dim=14, mode="ALL", **kwargs): def call(self, pdf_integrated): """Imposes the valence and momentum sum rules: A_g = (1-sigma)/g - A_v = A_v15 = A_v24 = A_v35 = 3/V + A_v = A_v24 = A_v35 = 3/V A_v3 = 1/V_3 A_v8 = 3/V_8 + A_v15 = 3/V_15 Note that both the input and the output are in the 14-flavours fk-basis """ @@ -58,6 +60,7 @@ def call(self, pdf_integrated): n_av = [3.0 / y[V_IDX[0][0]]] * len(V_IDX) n_av3 = [1.0 / y[V3_IDX[0][0]]] * len(V3_IDX) n_av8 = [3.0 / y[V8_IDX[0][0]]] * len(V8_IDX) - norm_constants += n_av + n_av3 + n_av8 - + n_av15 = [3.0 / y[V15_IDX[0][0]]] * len(V15_IDX) + norm_constants += n_av + n_av3 + n_av8 + n_av15 + return self._out_scatter(norm_constants) diff --git a/n3fit/src/n3fit/msr.py b/n3fit/src/n3fit/msr.py index 0bf85c52d3..1a35ec9555 100644 --- a/n3fit/src/n3fit/msr.py +++ b/n3fit/src/n3fit/msr.py @@ -36,7 +36,7 @@ def gen_integration_input(nx): return xgrid, weights_array -def msr_impose(nx=int(2e3), basis_size=8, mode='All', scaler=None): +def msr_impose(nx=int(2e3), basis_size=9, mode='All', scaler=None): """ This function receives: Generates a function that applies a normalization layer to the fit. @@ -69,7 +69,6 @@ def msr_impose(nx=int(2e3), basis_size=8, mode='All', scaler=None): # 2. Prepare the pdf for integration # for that we need to multiply several flavours with 1/x division_by_x = xDivide() - # 3. Now create the integration layer (the layer that will simply integrate, given some weight integrator = xIntegrator(weights_array, input_shape=(nx,)) From 9d0b5a909a3393d1e5cad632b28705bdc162476a Mon Sep 17 00:00:00 2001 From: tgiani Date: Mon, 21 Nov 2022 08:16:56 +0100 Subject: [PATCH 08/14] fix wrong indexing --- n3fit/src/n3fit/layers/msr_normalization.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/n3fit/src/n3fit/layers/msr_normalization.py b/n3fit/src/n3fit/layers/msr_normalization.py index 2a73fd238d..c31bf8fb41 100644 --- a/n3fit/src/n3fit/layers/msr_normalization.py +++ b/n3fit/src/n3fit/layers/msr_normalization.py @@ -2,10 +2,10 @@ from n3fit.backends import operations as op GLUON_IDX = [[2]] -V_IDX = [[3], [6], [7]] +V_IDX = [[3], [7], [8]] V3_IDX = [[4]] V8_IDX = [[5]] -V15_IDX = [[8]] +V15_IDX = [[6]] class MSR_Normalization(MetaLayer): @@ -62,5 +62,5 @@ def call(self, pdf_integrated): n_av8 = [3.0 / y[V8_IDX[0][0]]] * len(V8_IDX) n_av15 = [3.0 / y[V15_IDX[0][0]]] * len(V15_IDX) norm_constants += n_av + n_av3 + n_av8 + n_av15 - + return self._out_scatter(norm_constants) From d3b3fdc59df832cfbba45314353cb148643ff6cf Mon Sep 17 00:00:00 2001 From: tgiani Date: Mon, 21 Nov 2022 13:27:11 +0100 Subject: [PATCH 09/14] small fix --- n3fit/src/n3fit/model_gen.py | 2 +- n3fit/src/n3fit/msr.py | 3 +-- 2 files changed, 2 insertions(+), 3 deletions(-) diff --git a/n3fit/src/n3fit/model_gen.py b/n3fit/src/n3fit/model_gen.py index a89ce19c19..db3ca6fdd3 100644 --- a/n3fit/src/n3fit/model_gen.py +++ b/n3fit/src/n3fit/model_gen.py @@ -565,7 +565,7 @@ def pdfNN_layer_generator( # Normalization and sum rules if impose_sumrule: - sumrule_layer, integrator_input = msr_impose(mode=impose_sumrule, scaler=scaler) + sumrule_layer, integrator_input = msr_impose(basis_size=last_layer_nodes, mode=impose_sumrule, scaler=scaler) model_input.append(integrator_input) else: sumrule_layer = lambda x: x diff --git a/n3fit/src/n3fit/msr.py b/n3fit/src/n3fit/msr.py index 1a35ec9555..09de3fef2f 100644 --- a/n3fit/src/n3fit/msr.py +++ b/n3fit/src/n3fit/msr.py @@ -36,7 +36,7 @@ def gen_integration_input(nx): return xgrid, weights_array -def msr_impose(nx=int(2e3), basis_size=9, mode='All', scaler=None): +def msr_impose(nx=int(2e3), basis_size=8, mode='All', scaler=None): """ This function receives: Generates a function that applies a normalization layer to the fit. @@ -77,7 +77,6 @@ def msr_impose(nx=int(2e3), basis_size=9, mode='All', scaler=None): # 5. Make the xgrid array into a backend input layer so it can be given to the normalization xgrid_input = op.numpy_to_input(xgrid, name="integration_grid") - # Finally prepare a function which will take as input the output of the PDF model # and will return it appropiately normalized. def apply_normalization(layer_pdf): From 94c985472fda2b97597239165adf72d6160bcfe4 Mon Sep 17 00:00:00 2001 From: tgiani Date: Mon, 21 Nov 2022 13:50:58 +0100 Subject: [PATCH 10/14] remove unused basis_size argument --- n3fit/src/n3fit/model_gen.py | 2 +- n3fit/src/n3fit/msr.py | 6 ++---- 2 files changed, 3 insertions(+), 5 deletions(-) diff --git a/n3fit/src/n3fit/model_gen.py b/n3fit/src/n3fit/model_gen.py index db3ca6fdd3..a89ce19c19 100644 --- a/n3fit/src/n3fit/model_gen.py +++ b/n3fit/src/n3fit/model_gen.py @@ -565,7 +565,7 @@ def pdfNN_layer_generator( # Normalization and sum rules if impose_sumrule: - sumrule_layer, integrator_input = msr_impose(basis_size=last_layer_nodes, mode=impose_sumrule, scaler=scaler) + sumrule_layer, integrator_input = msr_impose(mode=impose_sumrule, scaler=scaler) model_input.append(integrator_input) else: sumrule_layer = lambda x: x diff --git a/n3fit/src/n3fit/msr.py b/n3fit/src/n3fit/msr.py index 09de3fef2f..e99006de47 100644 --- a/n3fit/src/n3fit/msr.py +++ b/n3fit/src/n3fit/msr.py @@ -36,7 +36,7 @@ def gen_integration_input(nx): return xgrid, weights_array -def msr_impose(nx=int(2e3), basis_size=8, mode='All', scaler=None): +def msr_impose(nx=int(2e3), mode='All', scaler=None): """ This function receives: Generates a function that applies a normalization layer to the fit. @@ -51,8 +51,6 @@ def msr_impose(nx=int(2e3), basis_size=8, mode='All', scaler=None): ---------- nx: int number of points for the integration grid, default: 2000 - basis_size: int - number of flavours output of the NN, default: 8 mode: str what sum rules to compute (MSR, VSR or All), default: All scaler: scaler @@ -73,7 +71,7 @@ def msr_impose(nx=int(2e3), basis_size=8, mode='All', scaler=None): integrator = xIntegrator(weights_array, input_shape=(nx,)) # 4. Now create the normalization by selecting the right integrations - normalizer = MSR_Normalization(input_shape=(basis_size,), mode=mode) + normalizer = MSR_Normalization(mode=mode) # 5. Make the xgrid array into a backend input layer so it can be given to the normalization xgrid_input = op.numpy_to_input(xgrid, name="integration_grid") From 6c00ee576692f0f68de7b5447b51c519339bb557 Mon Sep 17 00:00:00 2001 From: tgiani Date: Mon, 21 Nov 2022 14:32:12 +0100 Subject: [PATCH 11/14] fix dicision list --- n3fit/src/n3fit/layers/x_operations.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/n3fit/src/n3fit/layers/x_operations.py b/n3fit/src/n3fit/layers/x_operations.py index a61460edfc..f3cc9c32e9 100644 --- a/n3fit/src/n3fit/layers/x_operations.py +++ b/n3fit/src/n3fit/layers/x_operations.py @@ -33,7 +33,7 @@ class xDivide(MetaLayer): def __init__(self, output_dim=BASIS_SIZE, div_list=None, **kwargs): if div_list is None: - div_list = [3, 4, 5] + div_list = [3, 4, 5, 6] self.output_dim = output_dim self.div_list = div_list super().__init__(**kwargs) From b9944d238b10315da03463bf39f5e90ac8120af8 Mon Sep 17 00:00:00 2001 From: tgiani Date: Tue, 22 Nov 2022 16:30:53 +0100 Subject: [PATCH 12/14] adding c valence sumrule and cm second moment to vp tables --- validphys2/src/validphys/sumrules.py | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/validphys2/src/validphys/sumrules.py b/validphys2/src/validphys/sumrules.py index 5196feea16..4e5ee3ee5e 100644 --- a/validphys2/src/validphys/sumrules.py +++ b/validphys2/src/validphys/sumrules.py @@ -96,6 +96,7 @@ def f(x, lpdf, Q): "uvalence": _make_pdf_integrand({"u": 1, "ubar": -1}), "dvalence": _make_pdf_integrand({"d": 1, "dbar": -1}), "svalence": _make_pdf_integrand({"s": 1, "sbar": -1}), + "cvalence": _make_pdf_integrand({"c": 1, "cbar": -1}), } UNKNOWN_SUM_RULES = { @@ -106,6 +107,7 @@ def f(x, lpdf, Q): "s momentum fraction": _make_momentum_fraction_integrand({"s": 1}), "sbar momentum fraction": _make_momentum_fraction_integrand({"sbar": 1}), "cp momentum fraction": _make_momentum_fraction_integrand({"c": 1, "cbar": 1}), + "cm momentum fraction": _make_momentum_fraction_integrand({"c": 1, "cbar": -1}), "g momentum fraction": _make_momentum_fraction_integrand({"g": 1}), "T3": _make_pdf_integrand({"u": 1, "ubar": 1, "d": -1, "dbar": -1}), "T8": _make_pdf_integrand( @@ -118,6 +120,7 @@ def f(x, lpdf, Q): 'uvalence': 2, 'dvalence': 1, 'svalence': 0, + 'cvalence': 0, } @@ -141,7 +144,7 @@ def _sum_rules(rules_dict, lpdf, Q): @check_positive('Q') def sum_rules(pdf:PDF, Q:numbers.Real): - """Compute the momentum, uvalence, dvalence and svalence sum rules for + """Compute the momentum, uvalence, dvalence, svalence and cvalence sum rules for each member (as defined by libnnpdf), at the energy scale ``Q``. Return a SumRulesGrid object with the list of values for each sum rule. The integration is performed with absolute and relative tolerance of 1e-4.""" @@ -166,6 +169,7 @@ def unknown_sum_rules(pdf: PDF, Q: numbers.Real): - s momentum fraction - sbar momentum fraction - cp momentum fraction + - cm momentum fraction - g momentum fraction - T3 - T8 From cfe81ee9d12056ec3a8f8219d2b21274b1bf0fec Mon Sep 17 00:00:00 2001 From: tgiani Date: Fri, 25 Nov 2022 09:24:54 +0100 Subject: [PATCH 13/14] minor edits --- validphys2/src/validphys/pdfbases.py | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/validphys2/src/validphys/pdfbases.py b/validphys2/src/validphys/pdfbases.py index c06a38b1eb..0970a385ba 100644 --- a/validphys2/src/validphys/pdfbases.py +++ b/validphys2/src/validphys/pdfbases.py @@ -508,7 +508,7 @@ def f_(transform_func): EVOL = evolution -ccbar_asymm = evolution +CCBAR_ASYMM = evolution PDF4LHC20 = LinearBasis.from_mapping({ r'\Sigma': { @@ -740,7 +740,7 @@ def fitbasis_to_NN31IC(flav_info, fitbasis): g = {'sng': 0, 'v': 0, 'v3': 0, 'v8': 0, 't3': 0, 't8': 0, 't15': 0, 'g': 1 } v15 = {'sng': 0, 'v': 1, 'v3': 0, 'v8': 0, 't3': 0, 't8': 0, 't15': 0, 'g': 0 } - elif fitbasis == "ccbar_asymm": + elif fitbasis == "CCBAR_ASYMM": sng = {'sng': 1, 'v': 0, 'v3': 0, 'v8': 0, 't3': 0, 't8': 0, 't15': 0, 'g': 0, 'v15': 0 } v = {'sng': 0, 'v': 1, 'v3': 0, 'v8': 0, 't3': 0, 't8': 0, 't15': 0, 'g': 0, 'v15': 0 } v3 = {'sng': 0, 'v': 0, 'v3': 1, 'v8': 0, 't3': 0, 't8': 0, 't15': 0, 'g': 0, 'v15': 0 } @@ -760,6 +760,5 @@ def fitbasis_to_NN31IC(flav_info, fitbasis): mat.append(f[flav_name]) nflavs = len(flav_info) - mat = np.asarray(mat).reshape(9, nflavs) # Return the transpose of the matrix, to have the first index referring to flavour - return mat.transpose() + return np.asarray(mat).reshape(9, nflavs).T From 7cf4ab28ac21bebe67539d0a59eb86ad645c792f Mon Sep 17 00:00:00 2001 From: tgiani Date: Fri, 25 Nov 2022 11:04:52 +0100 Subject: [PATCH 14/14] updating csv file for sumrules test --- .../validphys/tests/regressions/test_sum_rules_MC.csv | 10 ++++++---- .../tests/regressions/test_sum_rules_hessian.csv | 10 ++++++---- 2 files changed, 12 insertions(+), 8 deletions(-) diff --git a/validphys2/src/validphys/tests/regressions/test_sum_rules_MC.csv b/validphys2/src/validphys/tests/regressions/test_sum_rules_MC.csv index e90c460b2e..f23678562d 100644 --- a/validphys2/src/validphys/tests/regressions/test_sum_rules_MC.csv +++ b/validphys2/src/validphys/tests/regressions/test_sum_rules_MC.csv @@ -1,8 +1,9 @@ mean std min max Central value -momentum 1.0000359402582584 5.358395010408105e-07 1.0000346238340416 1.0000372086565177 1.0000359458599606 -uvalence 1.9997926747574069 0.0002809483175437137 1.998765120611357 2.0001202779127008 1.9997937994497308 -dvalence 0.9997164295681845 0.00028118151759189136 0.9986902415578234 1.000046111974624 0.9997173113369415 -svalence 0.00025025303862949585 0.0003303956500365186 -0.00042417491773433236 0.0014490597353980783 0.0002507254062854847 +momentum 1.0000359402582584 5.358395010688445e-07 1.0000346238340414 1.0000372086565177 1.000035945859961 +uvalence 1.9997926747574089 0.0002809483175438455 1.9987651206113481 2.000120277912697 1.9997937994497326 +dvalence 0.9997164295682045 0.00028118151761139914 0.9986902415578238 1.0000461119746196 0.9997173113369362 +svalence 0.0002502530386336261 0.0003303956500400418 -0.0004241749177333505 0.00144905973539311 0.00025072540628739287 +cvalence -1.3250980807101706e-05 1.1497112653961402e-05 -5.583234972306736e-05 1.9950740107887218e-05 -1.3025352765570286e-05 u momentum fraction 0.2555 0.0021 -1.0 -1.0 -1.0 ubar momentum fraction 0.03387 0.00074 -1.0 -1.0 -1.0 d momentum fraction 0.1278 0.0021 -1.0 -1.0 -1.0 @@ -10,6 +11,7 @@ dbar momentum fraction 0.0422 0.0012 -1.0 -1.0 -1.0 s momentum fraction 0.0316 0.002 -1.0 -1.0 -1.0 sbar momentum fraction 0.0253 0.0012 -1.0 -1.0 -1.0 cp momentum fraction 0.0286 0.0017 -1.0 -1.0 -1.0 +cm momentum fraction -7.024e-05 8.7e-07 -1.0 -1.0 -1.0 g momentum fraction 0.4466 0.0017 -1.0 -1.0 -1.0 T3 0.79 0.23 -1.0 -1.0 -1.0 T8 4.73 0.7 -1.0 -1.0 -1.0 diff --git a/validphys2/src/validphys/tests/regressions/test_sum_rules_hessian.csv b/validphys2/src/validphys/tests/regressions/test_sum_rules_hessian.csv index 04168d5838..bd29ecee9e 100644 --- a/validphys2/src/validphys/tests/regressions/test_sum_rules_hessian.csv +++ b/validphys2/src/validphys/tests/regressions/test_sum_rules_hessian.csv @@ -1,8 +1,9 @@ mean std min max Central value -momentum 1.0000359346945835 3.249002390618474e-08 1.0000357949386856 1.000036007099919 1.000035943610909 -uvalence 1.9997947975241677 3.774745222364767e-05 1.9996255039155293 1.9998795897064394 1.9998052948252174 -dvalence 0.9997193904389039 3.913237872100671e-05 0.9995455646219639 0.9998033688013618 0.9997281952294002 -svalence 0.00021668009787772745 4.881864767300481e-05 2.8212616664191614e-05 0.00037062725233145966 0.00021200815810076823 +momentum 1.0000359346945835 3.249002389936152e-08 1.000035794938686 1.0000360070999192 1.000035943610909 +uvalence 1.999794797524114 3.7747452172582034e-05 1.9996255039155355 1.9998795897064396 1.9998052948252143 +dvalence 0.9997193904388911 3.913237869423472e-05 0.9995455646219693 0.9998033688013626 0.9997281952294024 +svalence 0.00021668009787584756 4.8818647675234034e-05 2.8212616642056543e-05 0.00037062725233308336 0.00021200815810049067 +cvalence -1.4051604747740869e-05 1.6214339259070918e-06 -2.1935653748207965e-05 -1.107482404248553e-05 -1.3850510260915482e-05 u momentum fraction 0.2554 0.00025 -1.0 -1.0 -1.0 ubar momentum fraction 0.03386 0.0001 -1.0 -1.0 -1.0 d momentum fraction 0.1277 0.00029 -1.0 -1.0 -1.0 @@ -10,6 +11,7 @@ dbar momentum fraction 0.04224 0.00016 -1.0 -1.0 -1.0 s momentum fraction 0.03172 0.00027 -1.0 -1.0 -1.0 sbar momentum fraction 0.0253 0.00016 -1.0 -1.0 -1.0 cp momentum fraction 0.02882 0.00023 -1.0 -1.0 -1.0 +cm momentum fraction -7.022e-05 1.1e-07 -1.0 -1.0 -1.0 g momentum fraction 0.44649 0.00025 -1.0 -1.0 -1.0 T3 0.807 0.033 -1.0 -1.0 -1.0 T8 4.65 0.1 -1.0 -1.0 -1.0