Numerical FONLL

benchmarks/runners/apfel_.py

@@ -141,6 +141,10 @@ def benchmark_pto(self, pto):
         )
         self.run([{"PTO": pto}], obs_updates, ["ToyLH"])
 
+    # ============================================================================ #
+    #                               ZM-VFNS                                        #
+    # ============================================================================ #
+
 
 @pytest.mark.skip
 class BenchmarkFlavorNumberScheme(ApfelBenchmark):
@@ -151,99 +155,156 @@ class BenchmarkFlavorNumberScheme(ApfelBenchmark):
     # and thus we can NOT probe as low Q2 as before.
 
     @staticmethod
-    def theory_updates_ffns(pto):
+    def theory_updates_zm(pto):
         sv = {
-            "XIR": [0.5, 2.0],
-            "XIF": [0.5, 2.0],
+            # "XIR": [0.5, 2.0],
+            # "XIF": [0.5, 2.0],
             "PTO": [pto],
-            "FNS": ["FFNS"],
-            "mb": 1e6,
-            "mt": 1e6,
+            "FNS": ["ZM-VFNS"],
         }
-        theory_updates = cartesian_product(sv)
-        # add FONLL
-        sv["FNS"] = ["FONLL-A"]
-        sv["NfFF"] = [4]
-        theory_updates.append(cartesian_product(sv))
-        return theory_updates
+        return cartesian_product(sv)
 
     @staticmethod
-    def obs_updates_ffns():
+    def obs_updates_zm():
         kins = []
-        kins.extend(
-            [
-                dict(x=x, Q2=10.0)
-                for x in observables.default_card["interpolation_xgrid"][3::3]
-            ]
-        )
-        kins.extend([dict(x=0.001, Q2=Q2) for Q2 in np.geomspace(5, 22, 10).tolist()])
+        # kins.extend(
+        #     [
+        #         dict(x=x, Q2=10.0)
+        #         for x in observables.default_card["interpolation_xgrid"][3::3]
+        #     ]
+        # )
+        kins.extend([dict(x=0.01, Q2=Q2) for Q2 in np.geomspace(5, 1e4, 10).tolist()])
         obs_updates = observables.build(
-            ["F2total", "F2charm", "FLtotal", "FLcharm", "F3total", "F3charm"],
-            kins,
-            update={"prDIS": ["NC", "CC"]},
+            ["F2_total", "F3_total", "FL_total"], kins, update={"prDIS": ["NC", "CC"]}
         )
         return obs_updates
 
+    def benchmark_zm(self, pto):
+        self.run(
+            self.theory_updates_zm(pto),
+            self.obs_updates_zm(),
+            ["ToyLH"],
+        )
+
+    # ============================================================================ #
+    #                               FFNS                                           #
+    # ============================================================================ #
+
     @staticmethod
-    def theory_updates_zm(pto):
+    def theory_updates_ffns(pto):
         sv = {
-            "XIR": [0.5, 2.0],
-            "XIF": [0.5, 2.0],
+            # "XIR": [0.5, 2.0],
+            # "XIF": [0.5, 2.0],
             "PTO": [pto],
-            "FNS": ["ZM-VFNS"],
+            "FNS": ["FFNS"],
+            "mb": [1e7],
+            "mt": [1e8],
+            "NfFF": [3],
+            "Qref": [1.9],
+            "nfref": [3],
         }
+        # theory_updates = cartesian_product(sv)
+        # sv["NfFF"] = [5]
+        # theory_updates.append(cartesian_product(sv))
         return cartesian_product(sv)
 
     @staticmethod
-    def obs_updates_zm():
+    def obs_updates_ffns():
         kins = []
         kins.extend(
             [
                 dict(x=x, Q2=10.0)
-                for x in observables.default_card["interpolation_xgrid"][10::3]
+                for x in observables.default_card["interpolation_xgrid"][12::3]
             ]
         )
-        kins.extend([dict(x=0.001, Q2=Q2) for Q2 in np.geomspace(3, 1e4, 10).tolist()])
+        kins.extend([dict(x=0.001, Q2=Q2) for Q2 in np.geomspace(10, 20, 5).tolist()])
         obs_updates = observables.build(
-            ["F2_total", "F3_total", "FL_total"], kins, update={"prDIS": ["NC", "CC"]}
+            [
+                # "F2_total",
+                # "F2_charm",
+                # "F2_bottom",
+                "F2_light"
+            ],
+            kins,
+            update={
+                "prDIS": [
+                    "NC",
+                    # "CC"
+                ]
+            },
         )
         return obs_updates
 
+    def benchmark_ffns(self, pto):
+        self.run(
+            self.theory_updates_ffns(pto),
+            self.obs_updates_ffns(),
+            ["NNPDF40_nnlo_as_01180"],
+        )
+
+    # ============================================================================ #
+    #                               FFN0                                           #
+    # ============================================================================ #
+
+    @staticmethod
+    def theory_updates_ffn0(pto):
+        sv = {
+            # "XIR": [0.5, 2.0],
+            # "XIF": [0.5, 2.0],
+            # "kcThr": [np.inf],
+            # "kbThr": [np.inf],
+            # "ktThr": [np.inf],
+            "PTO": [pto],
+            "FNS": ["FFN0"],
+            "mb": [1e7],
+            "mt": [1e8],
+            "NfFF": [3],
+            "Qref": [1.9],
+            "nfref": [3],
+        }
+        return cartesian_product(sv)
+
     @staticmethod
-    def obs_updates_pol():
+    def obs_updates_ffn0():
         kins = []
         kins.extend(
             [
-                dict(x=x, Q2=10.0)
-                for x in observables.default_card["interpolation_xgrid"][10::3]
+                dict(x=x, Q2=10**2)
+                for x in observables.default_card["interpolation_xgrid"][12::3]
             ]
         )
-        kins.extend([dict(x=0.001, Q2=Q2) for Q2 in np.geomspace(3, 1e4, 10).tolist()])
+        kins.extend(
+            [dict(x=0.001, Q2=Q**2) for Q in np.geomspace(1, 1e4, 5).tolist()]
+        )
         obs_updates = observables.build(
-            ["g1_total"], kins, update={"prDIS": ["EM"], "PolarizationDIS": [True]}
+            [
+                "F2_charm",
+                # "F2_bottom",
+                # "F2_top",
+                # "F2_light",
+                # "F2_total",
+            ],
+            kins,
+            update={
+                "prDIS": [
+                    "NC",
+                    # "CC",
+                ]
+            },
         )
         return obs_updates
 
-    def benchmark_ffns(self, pto):
+    def benchmark_ffn0(self, pto):
         self.run(
-            self.theory_updates_ffns(pto),
-            self.obs_updates_ffns(),
+            self.theory_updates_ffn0(pto),
+            self.obs_updates_ffn0(),
             ["ToyLH"],
         )
 
-    def benchmark_zm(self, pto):
-        self.run(
-            self.theory_updates_zm(pto),
-            self.obs_updates_zm(),
-            ["ToyLH"],
-        )
 
-    def benchmark_polarized(self, pto):
-        self.run(
-            [{"PTO": pto, "FNS": "ZM-VFNS"}],
-            self.obs_updates_pol(),
-            ["ToyLH"],
-        )
+# ============================================================================ #
+#                                  IC                                          #
+# ============================================================================ #
 
 
 class ApfelICBenchmark(ApfelBenchmark):
@@ -261,15 +322,15 @@ def obs_updates(allow_cc=False):
         obs = [
             {
                 "prDIS": "NC",
-                "observables": {f: kinematics for f in ["F2charm", "FLcharm"]},
+                "observables": {f: kinematics for f in ["F2_charm", "FL_charm"]},
             },
         ]
         if allow_cc:
             obs.append(
                 {
                     "prDIS": "CC",
                     "observables": {
-                        f: kinematics for f in ["F2charm", "FLcharm", "F3charm"]
+                        f: kinematics for f in ["F2_charm", "FL_charm", "F3_charm"]
                     },
                 }
             )
@@ -278,19 +339,10 @@ def obs_updates(allow_cc=False):
 
 class BenchmarkICFFNS(ApfelICBenchmark):
     def benchmark_lo(self):
-        self.run([{"IC": 1}], self.obs_updates(True), ["conly", "CT14llo_NF4"])
-
-    def benchmark_nlo(self):
-        self.run([{"PTO": 1, "IC": 1}], self.obs_updates(), ["conly", "CT14llo_NF4"])
-
+        self.run([{"IC": 1}], self.obs_updates(True), ["CT14llo_NF4"])
 
-class BenchmarkICFONLL(ApfelICBenchmark):
     def benchmark_nlo(self):
-        self.run(
-            [{"PTO": 1, "IC": 1, "FNS": "FONLL-A", "NfFF": 4}],
-            self.obs_updates(),
-            ["conly", "CT14llo_NF4"],
-        )
+        self.run([{"PTO": 1, "IC": 1}], self.obs_updates(), ["CT14llo_NF4"])
 
 
 if __name__ == "__main__":
@@ -306,18 +358,26 @@ def benchmark_nlo(self):
     # pos.benchmark_pto(0)
     # pos.benchmark_pto(1)
 
+    ffn0bench = BenchmarkFlavorNumberScheme()
+    # ffn0bench.benchmark_zm(0)
+    # ffn0bench.benchmark_zm(1)
+    # ffn0bench.benchmark_zm(2)
+    # ffn0bench.benchmark_ffns(1)
+    # ffn0bench.benchmark_ffns(2)
+    # ffn0bench.benchmark_ffn0(0)
+    # ffn0bench.benchmark_ffn0(1)
+    ffn0bench.benchmark_ffn0(2)
+
     # ffns = BenchmarkICFFNS()
     # ffns.benchmark_lo()
     # ffns.benchmark_nlo()
-    # fonll = BenchmarkICFONLL()
-    # fonll.benchmark_nlo()
 
     # xs = BenchmarkXS()
     # xs.benchmark_pto(0)
 
-    pol = BenchmarkFlavorNumberScheme()
-    pol.benchmark_polarized(0)
-    pol.benchmark_polarized(1)
+    # pol = BenchmarkFlavorNumberScheme()
+    # pol.benchmark_polarized(0)
+    # pol.benchmark_polarized(1)
 
 # def plain_assert_external(theory, obs, sf, yad):
 #     # APFEL has a discretization in Q2/m2
@@ -375,14 +435,3 @@ def benchmark_nlo(self):
 #             ):
 #                 return False
 #             return None
-
-#         def fonll_assert(theory, _obs, sf, yad):
-#             if (
-#                 sf == "FLbottom"
-#                 and theory["mb"] ** 2 / 4 < yad["Q2"] < theory["mb"] ** 2
-#             ):
-#                 # APFEL has a discreization in Q2/m2
-#                 return dict(abs=5e-6)
-#             if sf == "FLcharm" and yad["Q2"] < 7 and theory["DAMP"] == 1:
-#                 return dict(abs=2e-5)
-#             return None

benchmarks/runners/sandbox.py

@@ -151,7 +151,6 @@ def run_pineappl(self):
         #  t["FNS"] = "FFNS"
         t["NfFF"] = 4
         t["PTO"] = 1
-        #  t["kDISbThr"] = 10
         #  t["mb"] = 1e6
         #  t["mt"] = 1e7
         self.run([t], [o], [

extras/fonll_hq_treatment/utils.py

@@ -48,9 +48,6 @@
     "Comments": "NNPDF4.0 NNLO alphas=0.118",
     "global_nx": 0,
     "EScaleVar": 1,
-    "kDIScThr": 1.0,
-    "kDISbThr": 1.0,
-    "kDIStThr": 1.0,
 }
 
 observables_card = {