Compatibility with pineappl >= 1.0

pyproject.toml

@@ -32,7 +32,7 @@ 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"

src/pinefarm/external/integrability.py

@@ -1,7 +1,6 @@
 """Integrability interface."""
 
 import dataclasses
-import json
 import typing
 
 import numpy as np
@@ -53,34 +52,94 @@ 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.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.zeros((1, xgrid.size)),
+            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",
+            f"Integrability for pid : {self._info.hadron_pid}",
+        )
+
+        # dump file
+        grid.optimize()
         grid.write(self.grid)
 
     def collect_versions(self):

src/pinefarm/external/interface.py

@@ -152,7 +152,7 @@ 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)

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,9 @@ 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))
+nine_points = list(itertools.product(three_points, three_points, three_points))
 """Nine points prescription for scale variations (as couples, referred to ``(fact,
-ren)`` scales)."""
+ren, frag)`` scales)."""
 
 
 def git_pull(repo, remote_name="origin", branch="master"):
@@ -207,14 +207,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):