Compatibility with pineappl >= 1.0

pyproject.toml

@@ -32,12 +32,12 @@ pkgconfig = "^1.5.5"
 pygit2 = "^1.12.0"
 requests = "^2.26.0"
 lhapdf-management = "^0.3"
-pineappl = "^0.8.2"
+pineappl = "^1.0"
 more-itertools = "^8.10.0"
 appdirs = "^1.4.4"
 tomli = "^2.0.1"
 nnpdf-data = { version = "0.0.3" }
-yadism = { extras = ["box"], version = "^0.13.5", optional=true, markers = "python_version < '3.13'" }
+yadism = { extras = ["box"], version = "^0.13.7", optional=true, markers = "python_version < '3.13'" }
 eko = { extras = ["box"], version = "^0.14.2", optional=true, markers = "python_version < '3.13'" }
 
 [tool.poetry.extras]
@@ -103,7 +103,7 @@ addopts = [
 ]
 
 [tool.pylint.master]
-extension-pkg-whitelist = ["numpy", "lhapdf", "pygit2"]
+extension-pkg-whitelist = ["numpy", "lhapdf", "pygit2", "pineappl"]
 ignore-paths = ["benchmarks/", "doc/", "tests/"]
 
 [tool.pylint.messages_control]

src/pinefarm/external/integrability.py

@@ -31,7 +31,6 @@ def evolution_to_flavour(evol_fl):
 @dataclasses.dataclass
 class _IntegrabilityRuncard:
     hadron_pid: int
-    lepton_pid: int
     flavour: int
     xgrid: typing.List[float]
     convolution_type: typing.Optional[str] = "UnpolPDF"
@@ -53,34 +52,93 @@ def __init__(self, *args, **kwargs):
         self._q2 = np.power(self.theory["Q0"], 2)
         self._info = _IntegrabilityRuncard(**yaml_dict)
         self._evo2fl = evolution_to_flavour(self._info.flavour)
-        self.convolution_type = self._info.convolution_type
+        self.polarized = self._info.convolution_type == "PolPDF"
 
     def run(self):
         """Empty function."""
         pass
 
     def generate_pineappl(self):
         """Generate the pineappl grid for the integrability observable."""
+        xgrid = np.array(self._info.xgrid)
+        bins_length = len(xgrid)
+        bin_limits = [float(i) for i in range(0, bins_length + 1)]
+
         ## Generate the grid
-        lumi_entries = [(fl, self._info.lepton_pid, w) for fl, w in self._evo2fl]
-        luminosities = [pineappl.lumi.LumiEntry(lumi_entries)]
+        channels = [([fl], w) for fl, w in self._evo2fl]
+        channels = [pineappl.boc.Channel(channels)]
         # Set default parameters
-        orders = [pineappl.grid.Order(0, 0, 0, 0)]
-        params = pineappl.subgrid.SubgridParams()
+        orders = [pineappl.boc.Order(0, 0, 0, 0, 0)]
+        convolution_types = pineappl.convolutions.ConvType(
+            polarized=self.polarized, time_like=False
+        )
+        convolutions = [
+            pineappl.convolutions.Conv(convolution_types=convolution_types, pid=2212)
+        ]
+        kinematics = [pineappl.boc.Kinematics.Scale(0), pineappl.boc.Kinematics.X(0)]
+        scale_funcs = pineappl.boc.Scales(
+            ren=pineappl.boc.ScaleFuncForm.Scale(0),
+            fac=pineappl.boc.ScaleFuncForm.Scale(0),
+            frg=pineappl.boc.ScaleFuncForm.NoScale(0),
+        )
+        bin_limits = pineappl.boc.BinsWithFillLimits.from_fill_limits(
+            fill_limits=bin_limits
+        )
+        interpolations = [
+            pineappl.interpolation.Interp(
+                min=1,
+                max=1e2,
+                nodes=50,
+                order=3,
+                reweight_meth=pineappl.interpolation.ReweightingMethod.NoReweight,
+                map=pineappl.interpolation.MappingMethod.ApplGridH0,
+                interpolation_meth=pineappl.interpolation.InterpolationMethod.Lagrange,
+            ),  # Interpolation on the Scale
+            pineappl.interpolation.Interp(
+                min=1e-9,
+                max=1,
+                nodes=40,
+                order=3,
+                reweight_meth=pineappl.interpolation.ReweightingMethod.ApplGridX,
+                map=pineappl.interpolation.MappingMethod.ApplGridF2,
+                interpolation_meth=pineappl.interpolation.InterpolationMethod.Lagrange,
+            ),  # Interpolation on momentum fraction x
+        ]
         # Initialize and parametrize grid
-        grid = pineappl.grid.Grid.create(luminosities, orders, [0.0, 1.0], params)
-        grid.set_key_value("convolution_particle_1", str(self._info.hadron_pid))
-        grid.set_key_value("convolution_particle_2", str(self._info.lepton_pid))
-        grid.set_key_value("runcard", json.dumps(self._info.asdict()))
-        grid.set_key_value("lumi_id_types", "pdg_mc_ids")
-        grid.set_key_value("convolution_type_1", self.convolution_type)
-        grid.set_key_value("convolution_type_2", str(None))
-        # Fill grid with x*f(x)
-        # use subgrid because fill doesn't work?
-        x = self._info.xgrid
-        w = np.array(x).reshape((1, -1, 1))
-        sg = pineappl.import_only_subgrid.ImportOnlySubgridV1(w, [self._q2], x, x)
-        grid.set_subgrid(0, 0, 0, sg)
+        grid = pineappl.grid.Grid(
+            pid_basis=pineappl.pids.PidBasis.Evol,
+            channels=channels,
+            orders=orders,
+            bins=bin_limits,
+            convolutions=convolutions,
+            interpolations=interpolations,
+            kinematics=kinematics,
+            scale_funcs=scale_funcs,
+        )
+        subgrid = pineappl.subgrid.ImportSubgridV1(
+            array=np.full((1, xgrid.size), xgrid),
+            node_values=[[self._q2], xgrid],
+        )
+        grid.set_subgrid(0, 0, 0, subgrid.into())
+
+        limits = [[(self._q2, self._q2), (xgrid, xgrid)]]
+
+        # set the correct observables
+        normalizations = [1.0] * bins_length
+        bin_configs = pineappl.boc.BinsWithFillLimits.from_limits_and_normalizations(
+            limits=limits,
+            normalizations=normalizations,
+        )
+        grid.set_bwfl(bin_configs)
+
+        # set the initial state PDF ids for the grid
+        grid.set_metadata(
+            "runcard",
+            json.dumps(self._info.asdict()),
+        )
+
+        # dump file
+        grid.optimize()
         grid.write(self.grid)
 
     def collect_versions(self):

src/pinefarm/external/interface.py

@@ -152,11 +152,10 @@ def annotate_versions(self):
         # other python dependencies versions
         versions["pinefarm"] = __version__
         versions["pinecard"] = self.load_pinecard()
-        versions["pineappl"] = pineappl.__version__
+        versions["pineappl"] = pineappl.version
 
         entries = {}
         entries.update(versions)
-        entries["lumi_id_types"] = "pdg_mc_ids"
         entries["results_pdf"] = self.pdf
         tools.update_grid_metadata(
             self.grid, self.gridtmp, entries, {"results": results_log}

src/pinefarm/external/positivity.py

@@ -28,53 +28,96 @@ def run(self):
 
     def generate_pineappl(self):
         """Generate grid."""
-        self.xgrid = self.runcard["xgrid"]
-        self.lepton_pid = self.runcard["lepton_pid"]
+        self.xgrid = np.array(self.runcard["xgrid"])
         self.pid = self.runcard["pid"]
         self.q2 = self.runcard["q2"]
         self.hadron_pid = self.runcard["hadron_pid"]
         self.convolution_type = self.runcard.get("convolution_type", "UnpolPDF")
 
-        # init pineappl objects
-        lumi_entries = [pineappl.lumi.LumiEntry([(self.pid, self.lepton_pid, 1.0)])]
-        orders = [pineappl.grid.Order(0, 0, 0, 0)]
-        bins = len(self.xgrid)
-        bin_limits = list(map(float, range(0, bins + 1)))
-        # subgrid params - default is just sufficient
-        params = pineappl.subgrid.SubgridParams()
-        # inti grid
-        grid = pineappl.grid.Grid.create(lumi_entries, orders, bin_limits, params)
+        bins_length = len(self.xgrid)
+        bin_limits = [float(i) for i in range(0, bins_length + 1)]
+        polarized = self.convolution_type == "PolPDF"
+
+        # Instantiate the objecs required to construct a new Grid
+        channels = [pineappl.boc.Channel([([self.pid], 1.0)])]
+        orders = [pineappl.boc.Order(0, 0, 0, 0, 0)]
+        convolution_types = pineappl.convolutions.ConvType(
+            polarized=polarized, time_like=False
+        )
+        convolutions = [
+            pineappl.convolutions.Conv(
+                convolution_types=convolution_types, pid=self.hadron_pid
+            )
+        ]
+        kinematics = [pineappl.boc.Kinematics.Scale(0), pineappl.boc.Kinematics.X(0)]
+        scale_funcs = pineappl.boc.Scales(
+            ren=pineappl.boc.ScaleFuncForm.Scale(0),
+            fac=pineappl.boc.ScaleFuncForm.Scale(0),
+            frg=pineappl.boc.ScaleFuncForm.NoScale(0),
+        )
+        bin_limits = pineappl.boc.BinsWithFillLimits.from_fill_limits(
+            fill_limits=bin_limits
+        )
+        interpolations = [
+            pineappl.interpolation.Interp(
+                min=10,
+                max=1e3,
+                nodes=50,
+                order=3,
+                reweight_meth=pineappl.interpolation.ReweightingMethod.NoReweight,
+                map=pineappl.interpolation.MappingMethod.ApplGridH0,
+                interpolation_meth=pineappl.interpolation.InterpolationMethod.Lagrange,
+            ),  # Interpolation on the Scale
+            pineappl.interpolation.Interp(
+                min=1e-5,
+                max=1,
+                nodes=40,
+                order=3,
+                reweight_meth=pineappl.interpolation.ReweightingMethod.ApplGridX,
+                map=pineappl.interpolation.MappingMethod.ApplGridF2,
+                interpolation_meth=pineappl.interpolation.InterpolationMethod.Lagrange,
+            ),  # Interpolation on momentum fraction x
+        ]
+
+        grid = pineappl.grid.Grid(
+            pid_basis=pineappl.pids.PidBasis.Pdg,
+            channels=channels,
+            orders=orders,
+            bins=bin_limits,
+            convolutions=convolutions,
+            interpolations=interpolations,
+            kinematics=kinematics,
+            scale_funcs=scale_funcs,
+        )
+
         limits = []
         # add each point as a bin
         for bin_, x in enumerate(self.xgrid):
             # keep DIS bins
-            limits.append((self.q2, self.q2))
-            limits.append((x, x))
-            # delta function
-            array = np.zeros(len(self.xgrid))
-            array[bin_] = x
-            # create and set
-            subgrid = pineappl.import_only_subgrid.ImportOnlySubgridV1(
-                array[np.newaxis, :, np.newaxis],
-                [self.q2],
-                self.xgrid,
-                [1.0],
+            limits.append([(self.q2, self.q2), (x, x)])
+            # Fill the subgrid with delta functions
+            array_subgrid = np.zeros((1, self.xgrid.size))
+            array_subgrid[0][bin_] = x
+            # create and set the subgrid
+            subgrid = pineappl.subgrid.ImportSubgridV1(
+                array=array_subgrid,
+                node_values=[[self.q2], self.xgrid],
             )
-            grid.set_subgrid(0, bin_, 0, subgrid)
+            grid.set_subgrid(0, bin_, 0, subgrid.into())
         # set the correct observables
-        normalizations = [1.0] * bins
-        remapper = pineappl.bin.BinRemapper(normalizations, limits)
-        grid.set_remapper(remapper)
+        normalizations = [1.0] * bins_length
+        bin_configs = pineappl.boc.BinsWithFillLimits.from_limits_and_normalizations(
+            limits=limits,
+            normalizations=normalizations,
+        )
+        grid.set_bwfl(bin_configs)
 
         # set the initial state PDF ids for the grid
-        grid.set_key_value("convolution_particle_1", str(self.hadron_pid))
-        grid.set_key_value("convolution_particle_2", str(self.lepton_pid))
-        grid.set_key_value("runcard", json.dumps(self.runcard))
-        grid.set_key_value("lumi_id_types", "pdg_mc_ids")
-        grid.set_key_value("convolution_type_1", self.convolution_type)
-        grid.set_key_value("convolution_type_2", str(None))
+        grid.set_metadata("runcard", json.dumps(self.runcard))
+
+        # dump file
         grid.optimize()
-        grid.write(str(self.grid))
+        grid.write(self.grid)
 
     def results(self):
         """Apply PDF to grid."""

src/pinefarm/external/vrap.py

@@ -19,11 +19,10 @@
 
 import numpy as np
 import pandas as pd
+import pineappl
 import yaml
 from ekobox import genpdf
 from lhapdf_management import environment
-from pineappl.bin import BinRemapper
-from pineappl.grid import Grid
 
 from .. import configs, install
 from . import interface
@@ -147,7 +146,7 @@ def run(self):
             tmppine = self.dest / _PINEAPPL
 
             # Now change the name of the grid, optimize and apply any necessary cfactors
-            grid = Grid.read(tmppine.as_posix())
+            grid = pineappl.grid.Grid.read(tmppine.as_posix())
 
             # And give it a sensible name
             if len(self._kin_cards) == 1:
@@ -180,14 +179,14 @@ def generate_pineappl(self):
         """If the run contain more than one grid, merge them all."""
         if len(self._partial_grids) > 1:
             # Use the first subgrid as main grid
-            main_grid = Grid.read(self._partial_grids[0].as_posix())
+            main_grid = pineappl.grid.Grid.read(self._partial_grids[0].as_posix())
             n = len(main_grid.bin_left(0))
-            rebin = BinRemapper(np.ones(n), [(i, i) for i in range(n)])
+            rebin = pineappl.bin.BinRemapper(np.ones(n), [(i, i) for i in range(n)])
             main_grid.set_remapper(rebin)
             with tempfile.TemporaryDirectory() as tmp:
                 for i, grid_path in enumerate(self._partial_grids[1:]):
                     tmp_output = f"{tmp}/bin_{i}.pineappl.lz4"
-                    tmp_grid = Grid.read(grid_path.as_posix())
+                    tmp_grid = pineappl.grid.Grid.read(grid_path.as_posix())
                     tmp_grid.set_remapper(rebin)
                     tmp_grid.write(tmp_output)
                     # Now merge it into the main grid!

src/pinefarm/external/yad.py

@@ -78,7 +78,7 @@ def results(self):
         pdf_out = next(iter(pdf_out.tables.values()))
 
         sv_pdf_out = []
-        for xiR, xiF in tools.nine_points:
+        for xiR, xiF, _xiFR in tools.nine_points:
             sv_point = out.apply_pdf_alphas_alphaqed_xir_xif(
                 pdf,
                 lambda muR: lhapdf.mkAlphaS(self.pdf).alphasQ(muR),

src/pinefarm/table.py

@@ -31,15 +31,18 @@ def convolute_grid(grid, pdf_name, integrated=False):
 
     pdf = lhapdf.mkPDF(pdf_name)
     loaded_grid = pineappl.grid.Grid.read(str(grid))
-    pineappl_results = loaded_grid.convolve_with_one(
-        2212, pdf.xfxQ2, pdf.alphasQ2, xi=tools.nine_points
+    pineappl_results = loaded_grid.convolve(
+        pdg_convs=loaded_grid.convolutions,
+        xfxs=[pdf.xfxQ2],
+        alphas=pdf.alphasQ2,
+        xi=tools.nine_points,
     )
 
     df = pd.DataFrame(more_itertools.chunked(pineappl_results, len(tools.nine_points)))
     df.rename
     df["sv_max"] = df.max(axis=1)
     df["sv_min"] = df.min(axis=1)
-    df.rename(columns={tools.nine_points.index((1.0, 1.0)): "integ"}, inplace=True)
+    df.rename(columns={tools.nine_points.index((1.0, 1.0, 1.0)): "integ"}, inplace=True)
     if integrated:
         normalizations = loaded_grid.bin_normalizations()
         df = df.multiply(normalizations, axis="index")

src/pinefarm/tools.py

@@ -127,9 +127,14 @@ def patch(patch, base_dir="."):
 
 three_points = [0.5, 1.0, 2.0]
 "Three points prescription for scale variations."
-nine_points = list(itertools.product(three_points, three_points))
+twentyseven_points = list(itertools.product(three_points, three_points, three_points))
+"""27 points prescription for scale variations (as couples, referred to ``(fact,
+ren, frag)`` scales)."""
+nine_points = [
+    (a, b, 1.0) for (a, b) in list(itertools.product(three_points, three_points))
+]
 """Nine points prescription for scale variations (as couples, referred to ``(fact,
-ren)`` scales)."""
+ren, frag=1.0)`` scales)."""
 
 
 def git_pull(repo, remote_name="origin", branch="master"):
@@ -207,14 +212,10 @@ def set_grid_metadata(grid, entries=None, entries_from_file=None):
         entries_from_file = {}
 
     for k, v in entries.items():
-        if hasattr(grid, "set_key_value"):
-            grid.set_key_value(k, v)
-        else:  # pineappl 1.0 preparation
-            grid.set_metadata(k, v)
+        grid.set_metadata(k, v)
 
     for k, v in entries_from_file.items():
-        with open(v) as fd:
-            grid.set_key_value(k, fd.read())
+        grid.set_metadata(str(k), str(v))
 
 
 def common_substring(s1, s2, *sn):