From 8cf05ad8e3dc826e0f51856af6b2a9ad29ba6d41 Mon Sep 17 00:00:00 2001 From: juacrumar Date: Mon, 15 Apr 2024 13:03:48 +0200 Subject: [PATCH 1/4] add an example using pineappl to compute predictions --- .../examples/API_extension_Pineappl.ipynb | 321 ++++++++++++++++++ 1 file changed, 321 insertions(+) create mode 100644 validphys2/examples/API_extension_Pineappl.ipynb diff --git a/validphys2/examples/API_extension_Pineappl.ipynb b/validphys2/examples/API_extension_Pineappl.ipynb new file mode 100644 index 0000000000..1c0311424f --- /dev/null +++ b/validphys2/examples/API_extension_Pineappl.ipynb @@ -0,0 +1,321 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "b5ed6828-9d50-4a55-bf09-38ce2c10bfd0", + "metadata": {}, + "source": [ + "Example extending the validphys API to utilize grids instead of FkTables to compute different quantities.\n", + "\n", + "In this example the grids are all in the folder `pineappl_grids` set in the first cell of the notebook.\n", + "\n", + "Since it is using validphys in the background the grids need to have exact the same name they would have if they were FKTables.\n", + "\n", + "This notebooks monkeypatchs the following validphys functions:\n", + "\n", + "```\n", + "validphys.results.results\n", + "validphys.results.results_central\n", + "validphys.theorycovariance.construction.results_central_bytheoryids\n", + "```\n", + "\n", + "to utilize the pineappl grids directly instead of loading them as FKTables.\n", + "\n", + "Note that any function in validphys that computes predictions without going through any of those three will try to use FkTables and will thus fail." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "ff3938d5-f8db-4b73-9935-030aa7c6edb2", + "metadata": {}, + "outputs": [], + "source": [ + "from pathlib import Path\n", + "from validphys.convolution import OP\n", + "from validphys.pineparser import EXT\n", + "import numpy as np\n", + "import pandas as pd\n", + "import pineappl\n", + "from dataclasses import dataclass\n", + "from lhapdf import setVerbosity\n", + "from collections import defaultdict\n", + "import functools\n", + "import tabulate\n", + "\n", + "setVerbosity(0)\n", + "\n", + "grid_path = Path(\"pineappl_grids\")\n", + "\n", + "# Since the _actual_ theory ID is (should?) be irrelevant, just put some number that you have already downloaded\n", + "# This will be used to organize the scale-varied result later\n", + "tid = 600\n", + "\n", + "# 9 points\n", + "all_scales = [(1.0, 1.0), (1.0, 2.0), (2.0, 1.0), (1.0, 0.5), (0.5, 1.0), (0.5, 0.5), (2.0, 2.0), (2.0, 0.5), (0.5, 2.0)]\n", + "# Do just 3 for testing\n", + "all_scales = [(1.0, 1.0), (1.0, 2.0), (2.0, 1.0)]" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "62ef3d68-89ed-4014-8719-4de3fbc1ecc6", + "metadata": {}, + "outputs": [], + "source": [ + "class PineObject:\n", + "\n", + " def __init__(self, pine_path, factor=1.0):\n", + " self._grid = pineappl.grid.Grid.read(pine_path)\n", + "\n", + " # Not all grids need normalization???\n", + " # set it to true _for the time being_\n", + " self._apply_bin = True\n", + "\n", + " self._factor = factor\n", + " self._name = pine_path.name\n", + "\n", + " @functools.lru_cache\n", + " def convolute(self, pdf):\n", + " \"\"\"Convolute the grid with a PDF, output as (nmembers, ndata, nscales)\"\"\"\n", + " if not hasattr(pdf, \"members\"):\n", + " pdf = pdf.load()\n", + " ret = []\n", + " bin_norm = self._grid.bin_normalizations().reshape(-1, 1)\n", + " \n", + " for i, member in enumerate(pdf.members):\n", + " tmp = self._grid.convolute_with_one(2212, member.xfxQ2, member.alphasQ2, xi=all_scales).reshape(-1, len(all_scales))\n", + "\n", + " if self._apply_bin:\n", + " tmp *= bin_norm\n", + " ret.append(tmp)\n", + "\n", + " return np.array(ret)*self._factor\n", + "\n", + " def __str__(self):\n", + " return f\"PineObject({self._name})\"\n", + "\n", + " def __repr__(self):\n", + " return str(self)\n", + "\n", + "class PineContainer:\n", + "\n", + " def __init__(self, pine_objects, dsname=None, operation=OP[\"NULL\"]):\n", + " self._name = dsname\n", + " self._operation = operation\n", + " self._pine_objects = pine_objects\n", + "\n", + " @functools.lru_cache\n", + " def predictions(self, pdf): \n", + " operators = []\n", + " for pine_operator in self._pine_objects:\n", + " tmp = []\n", + " for pine_bin in pine_operator:\n", + " tmp.append(pine_bin.convolute(pdf))\n", + " # tmp is shaped (ndata, scales)\n", + " operators.append(np.concatenate(tmp, axis=1))\n", + "\n", + " # The operators is a list of (nmembers, ndata, nscales)\n", + "\n", + " # Loop over scales to get the result for all members for every scale\n", + " return self._operation(*operators) # (nmembers, ndata, nscales)\n", + " \n", + " def __str__(self):\n", + " return f\"PineContainer({self._name})\"\n", + "\n", + " def __repr__(self):\n", + " return str(self)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "09b0bc28-e540-414f-a789-ed8fb5bac5a6", + "metadata": {}, + "outputs": [], + "source": [ + "# This cell contains the whole monkeypatching logic\n", + "\n", + "import validphys.results\n", + "import validphys.theorycovariance.construction\n", + "\n", + "@functools.lru_cache\n", + "def _get_pine_container(dataset):\n", + " cd = dataset.commondata\n", + " metadata = cd.metadata\n", + " theory_meta = metadata.theory\n", + "\n", + " pinegrids = []\n", + " for operator in theory_meta.FK_tables:\n", + " tmp = []\n", + " for i in operator:\n", + " factor = theory_meta.conversion_factor\n", + " if theory_meta.normalization is not None:\n", + " factor *= theory_meta.normalization.get(i, 1.0)\n", + " \n", + " pine_path = grid_path / f\"{i}.{EXT}\"\n", + " tmp.append(PineObject(pine_path, factor))\n", + " pinegrids.append(tmp)\n", + "\n", + " operation = OP[theory_meta.operation]\n", + " return PineContainer(pinegrids, dsname=dataset.name, operation=operation)\n", + " \n", + "def _pine_predictions(dataset, pdf, central_only=False):\n", + " \"\"\"Given a dataset and a PDF, produces predictions with pineappl\n", + " The output shape is a list of DataFrames with the right shape for ThPredictions\"\"\"\n", + " if central_only:\n", + " pdf = pdf.load_t0()\n", + "\n", + " container = _get_pine_container(dataset)\n", + " res_all_scales = container.predictions(pdf) # (n_members, n_data, n_scales)\n", + "\n", + " cuts = dataset.cuts.load()\n", + "\n", + " all_res = []\n", + " for res in res_all_scales.T:\n", + " all_res.append(pd.DataFrame(res).loc[cuts])\n", + "\n", + " return all_res\n", + "\n", + "def new_results_central_by_theoryid(dataset, pdf, covariance_matrix, sqrt_covmat):\n", + " dresult = validphys.results.DataResult(dataset, covariance_matrix, sqrt_covmat)\n", + " ####### This is the part that changes wrt validphys\n", + " data_path = Path(f\"results_{dataset.name}_{tid}_{pdf.name}.pkl\")\n", + " ret = []\n", + " theory_data_per_scale = _pine_predictions(dataset, pdf, central_only=True)\n", + " for i, theory_data in enumerate(theory_data_per_scale):\n", + " tmp = validphys.results.ThPredictionsResult(theory_data, pdf.stats_class, pdf=pdf, theoryid=tid+i)\n", + " ret.append( (dresult, tmp) )\n", + " #########\n", + " return ret\n", + "\n", + "def new_results(dataset, pdf, covariance_matrix, sqrt_covmat, central_only=False):\n", + " dresult = validphys.results.DataResult(dataset, covariance_matrix, sqrt_covmat)\n", + " ####### This is the part that changes wrt validphys\n", + " data_path = Path(f\"results_{dataset.name}_{tid}_{pdf.name}.pkl\")\n", + " theory_data = _pine_predictions(dataset, pdf, central_only=central_only)[0]\n", + " theory_results = validphys.results.ThPredictionsResult(theory_data, pdf.stats_class, pdf=pdf)\n", + " #########\n", + " return (dresult, theory_results)\n", + "\n", + "def new_results_central(dataset, pdf, covariance_matrix, sqrt_covmat, central_only=False):\n", + " return new_results(dataset, pdf, covariance_matrix, sqrt_covmat, central_only=True)\n", + "\n", + "validphys.results.results = new_results\n", + "validphys.results.results_central = new_results_central\n", + "validphys.theorycovariance.construction.results_central_bytheoryids = new_results_central_by_theoryid" + ] + }, + { + "cell_type": "markdown", + "id": "05728f3a-bf70-4e2e-b135-858ca4419ad1", + "metadata": {}, + "source": [ + "The cell below is just a test that the above worked as expected.\n", + "In principle _any_ function using `results` to compute predictions would work.\n", + "\n", + "The PDF uncertainties are much slower than validphys, grids need to compute many pairs of x/q.\n", + "\n", + "Note: and _any_ function not using `results` should be changed to use it." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "0d88977d-5763-4929-8766-3919c8f70817", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Exp chi2: 0.5382\n", + "Exp+th chi2: 0.5037\n", + "Exp+th+pdf chi2: 0.2724\n" + ] + } + ], + "source": [ + "from validphys.api import API\n", + "\n", + "pdf_name = \"NNPDF40_nnlo_as_01180\"\n", + "dname = \"LHCB_WPWM_8TEV_MUON_Y\"\n", + "kwargs = {\"dataset_input\": {\"dataset\": dname}, \"theoryid\" : tid, \"use_cuts\":\"internal\", \"pdf\": pdf_name}\n", + "theory_opt = {\"point_prescription\": \"3 point\", \"theoryids\": {\"from_\": \"scale_variation_theories\"}, \"use_theorycovmat\": True}\n", + "\n", + "base_chi2 = API.abs_chi2_data(**kwargs)\n", + "print(f\"Exp chi2: {base_chi2.central_result / base_chi2.ndata:.4}\")\n", + "\n", + "th_chi2 = API.abs_chi2_data_thcovmat(**kwargs, **theory_opt)\n", + "print(f\"Exp+th chi2: {th_chi2.central_result / th_chi2.ndata:.4}\")\n", + "\n", + "full_chi2 = API.abs_chi2_data_thcovmat(**kwargs, **theory_opt, use_pdferr=True)\n", + "print(f\"Exp+th+pdf chi2: {full_chi2.central_result / full_chi2.ndata:.4}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "06d4e9a6-854b-4548-9707-7e51744d3000", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/jumax9/Academic_Workspace/NNPDF/src/nnpdf/validphys2/src/validphys/utils.py:193: FutureWarning: In a future version of pandas, a length 1 tuple will be returned when iterating over a groupby with a grouper equal to a list of length 1. Don't supply a list with a single grouper to avoid this warning.\n", + " for same_vals, table in gb:\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Plot a theory-data comparison\n", + "from matplotlib import pyplot as plt\n", + "%matplotlib inline\n", + "figs = API.plot_fancy(**kwargs, normalize_to=\"data\")\n", + "figs[0]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e3877c80-d3dd-4dc3-b14d-a54c40cff6b2", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.2" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From b0c5753e341eb5d94fa75642df6a15121aa81ffb Mon Sep 17 00:00:00 2001 From: juacrumar Date: Mon, 15 Apr 2024 17:59:41 +0200 Subject: [PATCH 2/4] rebase on top of results-in-pdferr; add exception if from_convolution is ever used --- .../examples/API_extension_Pineappl.ipynb | 20 +++++++++++++++---- 1 file changed, 16 insertions(+), 4 deletions(-) diff --git a/validphys2/examples/API_extension_Pineappl.ipynb b/validphys2/examples/API_extension_Pineappl.ipynb index 1c0311424f..d2be9e3425 100644 --- a/validphys2/examples/API_extension_Pineappl.ipynb +++ b/validphys2/examples/API_extension_Pineappl.ipynb @@ -181,7 +181,6 @@ "def new_results_central_by_theoryid(dataset, pdf, covariance_matrix, sqrt_covmat):\n", " dresult = validphys.results.DataResult(dataset, covariance_matrix, sqrt_covmat)\n", " ####### This is the part that changes wrt validphys\n", - " data_path = Path(f\"results_{dataset.name}_{tid}_{pdf.name}.pkl\")\n", " ret = []\n", " theory_data_per_scale = _pine_predictions(dataset, pdf, central_only=True)\n", " for i, theory_data in enumerate(theory_data_per_scale):\n", @@ -193,7 +192,6 @@ "def new_results(dataset, pdf, covariance_matrix, sqrt_covmat, central_only=False):\n", " dresult = validphys.results.DataResult(dataset, covariance_matrix, sqrt_covmat)\n", " ####### This is the part that changes wrt validphys\n", - " data_path = Path(f\"results_{dataset.name}_{tid}_{pdf.name}.pkl\")\n", " theory_data = _pine_predictions(dataset, pdf, central_only=central_only)[0]\n", " theory_results = validphys.results.ThPredictionsResult(theory_data, pdf.stats_class, pdf=pdf)\n", " #########\n", @@ -204,7 +202,13 @@ "\n", "validphys.results.results = new_results\n", "validphys.results.results_central = new_results_central\n", - "validphys.theorycovariance.construction.results_central_bytheoryids = new_results_central_by_theoryid" + "validphys.theorycovariance.construction.results_central_bytheoryids = new_results_central_by_theoryid\n", + "\n", + "# Make sure that from_convolution is never accessed\n", + "def raise_me(pdf, dataset, **kwargs):\n", + " raise ValueError(\".from_convolution is being used, please report this error!\")\n", + "\n", + "validphys.results.ThPredictionsResult.from_convolution = raise_me" ] }, { @@ -232,7 +236,7 @@ "text": [ "Exp chi2: 0.5382\n", "Exp+th chi2: 0.5037\n", - "Exp+th+pdf chi2: 0.2724\n" + "Exp+th+pdf chi2: 0.425\n" ] } ], @@ -295,6 +299,14 @@ "metadata": {}, "outputs": [], "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1356c290-b7f0-43c2-a663-659ea6da2df4", + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { From 593dfe9f48374c5eb998ee5378299736a4ce8ee1 Mon Sep 17 00:00:00 2001 From: juacrumar Date: Thu, 18 Apr 2024 11:22:24 +0200 Subject: [PATCH 3/4] add the saving of the data as pkl files --- .../examples/API_extension_Pineappl.ipynb | 86 ++++++++++++++++++- 1 file changed, 82 insertions(+), 4 deletions(-) diff --git a/validphys2/examples/API_extension_Pineappl.ipynb b/validphys2/examples/API_extension_Pineappl.ipynb index d2be9e3425..9354ccbce2 100644 --- a/validphys2/examples/API_extension_Pineappl.ipynb +++ b/validphys2/examples/API_extension_Pineappl.ipynb @@ -292,13 +292,91 @@ "figs[0]" ] }, + { + "cell_type": "markdown", + "id": "f8302287-5b04-47b0-99c4-0c621639ef1f", + "metadata": {}, + "source": [ + "The cell below creates a `.pkl` format with all results with the following structure:\n", + "\n", + "```\n", + " exp_data: central experimental data\n", + " exp_uncert: experimental uncertainties (+- 1sigma)\n", + " predictions: theoretical predictions for the central scale\n", + " pdf_uncert: pdf uncertainties\n", + " theory_uncert: scale uncertainties\n", + "```\n", + "\n", + "so that it can be reused in other functions." + ] + }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "id": "e3877c80-d3dd-4dc3-b14d-a54c40cff6b2", "metadata": {}, - "outputs": [], - "source": [] + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Computing predictions for H1_2JET_319GEV_290PB-1_DIF_PTQ2 with NNPDF40_nnlo_as_01180 (tid=600)\n", + "Predictions for H1_2JET_319GEV_290PB-1_DIF_PTQ2 written to /tmp/results_H1_2JET_319GEV_290PB-1_DIF_PTQ2_600_NNPDF40_nnlo_as_01180.pkl (pdf='NNPDF40_nnlo_as_01180')\n", + "Computing predictions for H1_2JET_319GEV_290PB-1_DIF_PTQ2 with PDF4LHC21_mc (tid=600)\n", + "Predictions for H1_2JET_319GEV_290PB-1_DIF_PTQ2 written to /tmp/results_H1_2JET_319GEV_290PB-1_DIF_PTQ2_600_PDF4LHC21_mc.pkl (pdf='PDF4LHC21_mc')\n" + ] + } + ], + "source": [ + "def create_data_pickle(dname, pdf, theoryid, force=False, output_folder=Path(\".\")):\n", + " data_path = Path(output_folder) / f\"results_{dname}_{theoryid}_{pdf}.pkl\"\n", + " \n", + " if data_path.exists() and not force:\n", + " print(f\"Skipping {dname} ({pdf}) since {data_path} already exists. If you want to overwrite it use `force=True`\")\n", + " return\n", + " \n", + " print(f\"Computing predictions for {dname} with {pdf} (tid={theoryid})\")\n", + " generic = {\n", + " \"dataset_input\": {\"dataset\": dname},\n", + " \"theoryid\": theoryid,\n", + " \"pdf\": pdf,\n", + " \"use_cuts\": \"internal\",\n", + " }\n", + "\n", + " # These two functions are using the monkey patching from before\n", + " # so you better make sure they are being used in the same notebook!\n", + " # otherwise you will be getting FKTable results and not grids!!!!!!1111\n", + "\n", + " res_data, res_theory = API.results(**generic)\n", + " theory_covmat = API.theory_covmat_dataset(\n", + " **generic,\n", + " point_prescription=\"9 point\",\n", + " theoryids={\"from_\": \"scale_variation_theories\"},\n", + " use_theorycovmat=True,\n", + " )\n", + " ret = {\n", + " \"exp_data\": res_data.central_value,\n", + " \"predictions\": res_theory.central_value,\n", + " \"exp_uncert\": res_data.std_error,\n", + " \"pdf_uncert\": res_theory.std_error,\n", + " \"theory_uncert\": np.sqrt(np.diag(theory_covmat)),\n", + " }\n", + " ds = API.dataset(**generic)\n", + " # Read the cuts \n", + " cuts = ds.cuts.load()+1 # kinematics start at 1\n", + " kin_df = ds.commondata.metadata.load_kinematics().loc[cuts]\n", + " results_df = pd.DataFrame(ret, index=kin_df.index)\n", + "\n", + " results_df.to_pickle(data_path)\n", + " print(f\"Predictions for {dname} written to {data_path} ({pdf=})\")\n", + "\n", + "#Example:\n", + "all_datasets = [\"H1_2JET_319GEV_290PB-1_DIF_PTQ2\"]\n", + "if True:\n", + " for pdf in [\"NNPDF40_nnlo_as_01180\", \"PDF4LHC21_mc\"]:\n", + " for dataset in all_datasets:\n", + " create_data_pickle(dataset, pdf, 600, force=True, output_folder=Path(\"/tmp\"))" + ] }, { "cell_type": "code", @@ -325,7 +403,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.12.2" + "version": "3.12.3" } }, "nbformat": 4, From c7fa0bc1a350f306cc4166edcd8d8bdabd763b4b Mon Sep 17 00:00:00 2001 From: juacrumar Date: Mon, 6 May 2024 18:10:43 +0200 Subject: [PATCH 4/4] add parsing of the shifts key --- .../examples/API_extension_Pineappl.ipynb | 60 ++++++++----------- 1 file changed, 25 insertions(+), 35 deletions(-) diff --git a/validphys2/examples/API_extension_Pineappl.ipynb b/validphys2/examples/API_extension_Pineappl.ipynb index 9354ccbce2..813f6ca204 100644 --- a/validphys2/examples/API_extension_Pineappl.ipynb +++ b/validphys2/examples/API_extension_Pineappl.ipynb @@ -26,7 +26,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 11, "id": "ff3938d5-f8db-4b73-9935-030aa7c6edb2", "metadata": {}, "outputs": [], @@ -41,7 +41,6 @@ "from lhapdf import setVerbosity\n", "from collections import defaultdict\n", "import functools\n", - "import tabulate\n", "\n", "setVerbosity(0)\n", "\n", @@ -54,19 +53,19 @@ "# 9 points\n", "all_scales = [(1.0, 1.0), (1.0, 2.0), (2.0, 1.0), (1.0, 0.5), (0.5, 1.0), (0.5, 0.5), (2.0, 2.0), (2.0, 0.5), (0.5, 2.0)]\n", "# Do just 3 for testing\n", - "all_scales = [(1.0, 1.0), (1.0, 2.0), (2.0, 1.0)]" + "#all_scales = [(1.0, 1.0), (1.0, 2.0), (2.0, 1.0)]" ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 12, "id": "62ef3d68-89ed-4014-8719-4de3fbc1ecc6", "metadata": {}, "outputs": [], "source": [ "class PineObject:\n", "\n", - " def __init__(self, pine_path, factor=1.0):\n", + " def __init__(self, pine_path, factor=1.0, shift=0):\n", " self._grid = pineappl.grid.Grid.read(pine_path)\n", "\n", " # Not all grids need normalization???\n", @@ -75,6 +74,7 @@ "\n", " self._factor = factor\n", " self._name = pine_path.name\n", + " self._shift = shift\n", "\n", " @functools.lru_cache\n", " def convolute(self, pdf):\n", @@ -89,6 +89,10 @@ "\n", " if self._apply_bin:\n", " tmp *= bin_norm\n", + "\n", + " # Apply shifts (if any) usually 0:\n", + " tmp = np.concatenate([np.zeros((self._shift, len(all_scales))), tmp])\n", + " \n", " ret.append(tmp)\n", "\n", " return np.array(ret)*self._factor\n", @@ -130,7 +134,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 13, "id": "09b0bc28-e540-414f-a789-ed8fb5bac5a6", "metadata": {}, "outputs": [], @@ -151,11 +155,15 @@ " tmp = []\n", " for i in operator:\n", " factor = theory_meta.conversion_factor\n", + " shift = 0\n", " if theory_meta.normalization is not None:\n", " factor *= theory_meta.normalization.get(i, 1.0)\n", + "\n", + " if theory_meta.shifts is not None:\n", + " shift = theory_meta.shifts.get(i, 0)\n", " \n", " pine_path = grid_path / f\"{i}.{EXT}\"\n", - " tmp.append(PineObject(pine_path, factor))\n", + " tmp.append(PineObject(pine_path, factor, shift=shift))\n", " pinegrids.append(tmp)\n", "\n", " operation = OP[theory_meta.operation]\n", @@ -169,7 +177,6 @@ "\n", " container = _get_pine_container(dataset)\n", " res_all_scales = container.predictions(pdf) # (n_members, n_data, n_scales)\n", - "\n", " cuts = dataset.cuts.load()\n", "\n", " all_res = []\n", @@ -226,17 +233,19 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 14, "id": "0d88977d-5763-4929-8766-3919c8f70817", - "metadata": {}, + "metadata": { + "scrolled": true + }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Exp chi2: 0.5382\n", - "Exp+th chi2: 0.5037\n", - "Exp+th+pdf chi2: 0.425\n" + "Exp+th chi2: 0.4493\n", + "Exp+th+pdf chi2: 0.3904\n" ] } ], @@ -260,18 +269,10 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 15, "id": "06d4e9a6-854b-4548-9707-7e51744d3000", "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/jumax9/Academic_Workspace/NNPDF/src/nnpdf/validphys2/src/validphys/utils.py:193: FutureWarning: In a future version of pandas, a length 1 tuple will be returned when iterating over a groupby with a grouper equal to a list of length 1. Don't supply a list with a single grouper to avoid this warning.\n", - " for same_vals, table in gb:\n" - ] - }, { "data": { "image/png": "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", @@ -279,7 +280,7 @@ "
" ] }, - "execution_count": 5, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" } @@ -312,21 +313,10 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "id": "e3877c80-d3dd-4dc3-b14d-a54c40cff6b2", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Computing predictions for H1_2JET_319GEV_290PB-1_DIF_PTQ2 with NNPDF40_nnlo_as_01180 (tid=600)\n", - "Predictions for H1_2JET_319GEV_290PB-1_DIF_PTQ2 written to /tmp/results_H1_2JET_319GEV_290PB-1_DIF_PTQ2_600_NNPDF40_nnlo_as_01180.pkl (pdf='NNPDF40_nnlo_as_01180')\n", - "Computing predictions for H1_2JET_319GEV_290PB-1_DIF_PTQ2 with PDF4LHC21_mc (tid=600)\n", - "Predictions for H1_2JET_319GEV_290PB-1_DIF_PTQ2 written to /tmp/results_H1_2JET_319GEV_290PB-1_DIF_PTQ2_600_PDF4LHC21_mc.pkl (pdf='PDF4LHC21_mc')\n" - ] - } - ], + "outputs": [], "source": [ "def create_data_pickle(dname, pdf, theoryid, force=False, output_folder=Path(\".\")):\n", " data_path = Path(output_folder) / f\"results_{dname}_{theoryid}_{pdf}.pkl\"\n",