Allow to specify multiple convolution functions with CLI

CHANGELOG.md

@@ -17,6 +17,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - added `PidBasis::charge_conjugate` and `PidBasis::guess`
 - added `Grid::set_pid_basis` method
 - added `Grid::subgrids` and `Grid::subgrids_mut` methods
+- added new switch `conv_fun_uncert_from` to subcommand `plot` to allow
+  choosing with convolution function uncertainty should be plotted
 
 ### Changed
 
@@ -39,6 +41,11 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - changed member `lumi_id_types` of `OperatorInfo` and `OperatorSliceInfo` to
   `pid_basis`, which is now of type `PidBasis`
 - renamed module `pineappl::lumi` to `pineappl::convolutions`
+- renamed switch `--pdf` to `--conv-fun` in the subcommand `uncert`. This
+  switch now optionally accepts a list of indices, which determines the
+  corresponding convolution function (PDF/FF), for which the uncertainty should
+  calculated
+- renamed `no_pdf_unc` to `no_conv_fun_unc` in subcommand `plot`
 
 ### Removed
 
@@ -54,6 +61,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - removed `TryFromGridError::MetadataMissing`
 - removed `Grid::subgrid` and `Grid::set_subgrid` methods; these functions have
   been replaced with `Grid::subgrids` and `Grid::subgrids_mut`
+- removed the switch `--pdf-with-scale-cov` from `pineappl uncert`
 
 ## [0.7.4] - 23/05/2024
 

pineappl_cli/src/analyze.rs

@@ -1,4 +1,4 @@
-use super::helpers::{self, ConvoluteMode};
+use super::helpers::{self, ConvFuns, ConvoluteMode};
 use super::{GlobalConfiguration, Subcommand};
 use anyhow::Result;
 use clap::builder::TypedValueParser;
@@ -39,9 +39,8 @@ pub struct CkfOpts {
     /// Path to the input grid.
     #[arg(value_hint = ValueHint::FilePath)]
     input: PathBuf,
-    /// LHAPDF id or name of the PDF set.
-    #[arg(value_parser = helpers::parse_pdfset)]
-    pdfset: String,
+    /// LHAPDF ID(s) or name(s) of the PDF(s)/FF(s).
+    conv_funs: ConvFuns,
     /// Order defining the K factors.
     #[arg(value_parser = helpers::parse_order)]
     order: (u32, u32),
@@ -65,7 +64,7 @@ pub struct CkfOpts {
 impl Subcommand for CkfOpts {
     fn run(&self, cfg: &GlobalConfiguration) -> Result<ExitCode> {
         let grid = helpers::read_grid(&self.input)?;
-        let mut pdf = helpers::create_pdf(&self.pdfset)?;
+        let mut conv_funs = helpers::create_conv_funs(&self.conv_funs)?;
 
         let orders_den = if self.orders_den.is_empty() {
             grid.orders()
@@ -87,7 +86,7 @@ impl Subcommand for CkfOpts {
                 lumi_mask[lumi] = true;
                 helpers::convolve(
                     &grid,
-                    &mut pdf,
+                    &mut conv_funs,
                     &[self.order],
                     &[],
                     &lumi_mask,
@@ -103,7 +102,7 @@ impl Subcommand for CkfOpts {
                 lumi_mask[lumi] = true;
                 helpers::convolve(
                     &grid,
-                    &mut pdf,
+                    &mut conv_funs,
                     &orders_den,
                     &[],
                     &lumi_mask,

pineappl_cli/src/channels.rs

@@ -1,4 +1,4 @@
-use super::helpers::{self, ConvoluteMode};
+use super::helpers::{self, ConvFuns, ConvoluteMode};
 use super::{GlobalConfiguration, Subcommand};
 use anyhow::Result;
 use clap::builder::TypedValueParser;
@@ -14,9 +14,8 @@ pub struct Opts {
     /// Path to the input grid.
     #[arg(value_hint = ValueHint::FilePath)]
     input: PathBuf,
-    /// LHAPDF id or name of the PDF set.
-    #[arg(value_parser = helpers::parse_pdfset)]
-    pdfset: String,
+    /// LHAPDF ID(s) or name(s) of the PDF(s)/FF(s).
+    conv_funs: ConvFuns,
     /// Show absolute numbers of each contribution.
     #[arg(long, short)]
     absolute: bool,
@@ -65,7 +64,7 @@ pub struct Opts {
 impl Subcommand for Opts {
     fn run(&self, cfg: &GlobalConfiguration) -> Result<ExitCode> {
         let grid = helpers::read_grid(&self.input)?;
-        let mut pdf = helpers::create_pdf(&self.pdfset)?;
+        let mut conv_funs = helpers::create_conv_funs(&self.conv_funs)?;
 
         let mut channels: Vec<_> = self.channels.iter().cloned().flatten().collect();
         channels.sort_unstable();
@@ -93,7 +92,7 @@ impl Subcommand for Opts {
                 channel_mask[channel] = true;
                 helpers::convolve(
                     &grid,
-                    &mut pdf,
+                    &mut conv_funs,
                     &self.orders,
                     &[],
                     &channel_mask,

pineappl_cli/src/convolve.rs

@@ -1,4 +1,4 @@
-use super::helpers::{self, ConvoluteMode};
+use super::helpers::{self, ConvFuns, ConvoluteMode};
 use super::{GlobalConfiguration, Subcommand};
 use anyhow::Result;
 use clap::{Parser, ValueHint};
@@ -15,8 +15,8 @@ pub struct Opts {
     #[arg(value_hint = ValueHint::FilePath)]
     input: PathBuf,
     /// LHAPDF id(s) or name of the PDF set(s).
-    #[arg(required = true, value_parser = helpers::parse_pdfset)]
-    pdfsets: Vec<String>,
+    #[arg(required = true)]
+    conv_funs: Vec<ConvFuns>,
     /// Selects a subset of bins.
     #[arg(
         long,
@@ -49,12 +49,12 @@ pub struct Opts {
 impl Subcommand for Opts {
     fn run(&self, cfg: &GlobalConfiguration) -> Result<ExitCode> {
         let grid = helpers::read_grid(&self.input)?;
-        let mut pdf = helpers::create_pdf(&self.pdfsets[0])?;
+        let mut conv_funs_0 = helpers::create_conv_funs(&self.conv_funs[0])?;
         let bins: Vec<_> = self.bins.iter().cloned().flatten().collect();
 
         let results = helpers::convolve(
             &grid,
-            &mut pdf,
+            &mut conv_funs_0,
             &self.orders,
             &bins,
             &[],
@@ -77,13 +77,13 @@ impl Subcommand for Opts {
         );
         let bin_count = limits.len();
 
-        let other_results: Vec<_> = self.pdfsets[1..]
+        let other_results: Vec<_> = self.conv_funs[1..]
             .iter()
-            .flat_map(|pdfset| {
-                let mut pdf = helpers::create_pdf(pdfset).unwrap();
+            .flat_map(|conv_funs| {
+                let mut conv_funs = helpers::create_conv_funs(conv_funs).unwrap();
                 helpers::convolve(
                     &grid,
-                    &mut pdf,
+                    &mut conv_funs,
                     &self.orders,
                     &bins,
                     &[],
@@ -108,7 +108,7 @@ impl Subcommand for Opts {
         }
         title.add_cell(cell!(c->format!("{y_label}\n[{y_unit}]")));
 
-        for other in self.pdfsets[1..].iter().map(|pdf| helpers::pdf_label(pdf)) {
+        for other in self.conv_funs[1..].iter().map(|conv_funs| &conv_funs.label) {
             let mut cell = cell!(c->format!("{other}\n[{y_unit}] [%]"));
             cell.set_hspan(2);
             title.add_cell(cell);

pineappl_cli/src/diff.rs

@@ -1,4 +1,4 @@
-use super::helpers::{self, ConvoluteMode};
+use super::helpers::{self, ConvFuns, ConvoluteMode};
 use super::{GlobalConfiguration, Subcommand};
 use anyhow::{bail, Result};
 use clap::{Parser, ValueHint};
@@ -16,9 +16,8 @@ pub struct Opts {
     /// Path to the second grid.
     #[arg(value_hint = ValueHint::FilePath)]
     input2: PathBuf,
-    /// LHAPDF id or name of the PDF set.
-    #[arg(value_parser = helpers::parse_pdfset)]
-    pdfset: String,
+    /// LHAPDF ID(s) or name(s) of the PDF(s)/FF(s).
+    conv_funs: ConvFuns,
     /// Ignore differences in the orders and sum them.
     #[arg(long)]
     ignore_orders: bool,
@@ -127,7 +126,7 @@ impl Subcommand for Opts {
             bail!("channels differ");
         }
 
-        let mut pdf = helpers::create_pdf(&self.pdfset)?;
+        let mut conv_funs = helpers::create_conv_funs(&self.conv_funs)?;
 
         let mut table = helpers::create_table();
         let mut title = Row::empty();
@@ -149,7 +148,7 @@ impl Subcommand for Opts {
 
             let results1 = helpers::convolve(
                 &grid1,
-                &mut pdf,
+                &mut conv_funs,
                 &orders1,
                 &[],
                 &[],
@@ -159,7 +158,7 @@ impl Subcommand for Opts {
             );
             let results2 = helpers::convolve(
                 &grid2,
-                &mut pdf,
+                &mut conv_funs,
                 &orders2,
                 &[],
                 &[],
@@ -205,7 +204,7 @@ impl Subcommand for Opts {
                 .map(|&order| {
                     helpers::convolve(
                         &grid1,
-                        &mut pdf,
+                        &mut conv_funs,
                         &[order],
                         &[],
                         &[],
@@ -220,7 +219,7 @@ impl Subcommand for Opts {
                 .map(|&order| {
                     helpers::convolve(
                         &grid2,
-                        &mut pdf,
+                        &mut conv_funs,
                         &[order],
                         &[],
                         &[],

pineappl_cli/src/evolve.rs

@@ -1,4 +1,4 @@
-use super::helpers::{self, ConvoluteMode};
+use super::helpers::{self, ConvFuns, ConvoluteMode};
 use super::{GlobalConfiguration, Subcommand};
 use anyhow::{anyhow, Result};
 use clap::{Parser, ValueHint};
@@ -425,7 +425,7 @@ mod eko {
 fn evolve_grid(
     grid: &Grid,
     eko: &Path,
-    pdf: &Pdf,
+    use_alphas_from: &Pdf,
     orders: &[(u32, u32)],
     xir: f64,
     xif: f64,
@@ -446,7 +446,7 @@ fn evolve_grid(
         .collect();
 
     let mut eko_slices = EkoSlices::new(eko)?;
-    let alphas_table = AlphasTable::from_grid(grid, xir, &|q2| pdf.alphas_q2(q2));
+    let alphas_table = AlphasTable::from_grid(grid, xir, &|q2| use_alphas_from.alphas_q2(q2));
 
     if use_old_evolve {
         if let EkoSlices::V0 {
@@ -506,9 +506,8 @@ pub struct Opts {
     /// Path to the converted grid.
     #[arg(value_hint = ValueHint::FilePath)]
     output: PathBuf,
-    /// LHAPDF id or name of the PDF set to check the converted grid with.
-    #[arg(value_parser = helpers::parse_pdfset)]
-    pdfset: String,
+    /// LHAPDF ID(s) or name of the PDF(s)/FF(s).
+    conv_funs: ConvFuns,
     /// Relative threshold between the table and the converted grid when comparison fails.
     #[arg(default_value = "1e-3", long)]
     accuracy: f64,
@@ -542,10 +541,10 @@ impl Subcommand for Opts {
         use prettytable::row;
 
         let grid = helpers::read_grid(&self.input)?;
-        let mut pdf = helpers::create_pdf(&self.pdfset)?;
+        let mut conv_funs = helpers::create_conv_funs(&self.conv_funs)?;
         let results = helpers::convolve_scales(
             &grid,
-            &mut pdf,
+            &mut conv_funs,
             &self.orders,
             &[],
             &[],
@@ -557,15 +556,15 @@ impl Subcommand for Opts {
         let fk_table = evolve_grid(
             &grid,
             &self.eko,
-            &pdf,
+            &conv_funs[cfg.use_alphas_from],
             &self.orders,
             self.xir,
             self.xif,
             self.use_old_evolve,
         )?;
         let evolved_results = helpers::convolve_scales(
             fk_table.grid(),
-            &mut pdf,
+            &mut conv_funs,
             &[],
             &[],
             &[],

pineappl_cli/src/export.rs

@@ -1,4 +1,4 @@
-use super::helpers::{self, ConvoluteMode};
+use super::helpers::{self, ConvFuns, ConvoluteMode};
 use super::{GlobalConfiguration, Subcommand};
 use anyhow::{anyhow, Result};
 use clap::builder::{PossibleValuesParser, TypedValueParser};
@@ -16,15 +16,15 @@ mod applgrid;
 fn convert_into_applgrid(
     output: &Path,
     grid: &Grid,
-    pdf: &mut Pdf,
+    conv_funs: &mut [Pdf],
     _: usize,
     discard_non_matching_scales: bool,
 ) -> Result<(&'static str, Vec<f64>, usize, Vec<bool>)> {
     // TODO: check also scale-varied results
 
     let (mut applgrid, order_mask) =
         applgrid::convert_into_applgrid(grid, output, discard_non_matching_scales)?;
-    let results = applgrid::convolve_applgrid(applgrid.pin_mut(), pdf);
+    let results = applgrid::convolve_applgrid(applgrid.pin_mut(), conv_funs);
 
     Ok(("APPLgrid", results, 1, order_mask))
 }
@@ -33,7 +33,7 @@ fn convert_into_applgrid(
 fn convert_into_applgrid(
     _: &Path,
     _: &Grid,
-    _: &mut Pdf,
+    _: &mut [Pdf],
     _: usize,
     _: bool,
 ) -> Result<(&'static str, Vec<f64>, usize, Vec<bool>)> {
@@ -45,13 +45,19 @@ fn convert_into_applgrid(
 fn convert_into_grid(
     output: &Path,
     grid: &Grid,
-    pdf: &mut Pdf,
+    conv_funs: &mut [Pdf],
     scales: usize,
     discard_non_matching_scales: bool,
 ) -> Result<(&'static str, Vec<f64>, usize, Vec<bool>)> {
     if let Some(extension) = output.extension() {
         if extension == "appl" || extension == "root" {
-            return convert_into_applgrid(output, grid, pdf, scales, discard_non_matching_scales);
+            return convert_into_applgrid(
+                output,
+                grid,
+                conv_funs,
+                scales,
+                discard_non_matching_scales,
+            );
         }
     }
 
@@ -67,9 +73,8 @@ pub struct Opts {
     /// Path to the converted grid.
     #[arg(value_hint = ValueHint::FilePath)]
     output: PathBuf,
-    /// LHAPDF id or name of the PDF set to check the converted grid with.
-    #[arg(value_parser = helpers::parse_pdfset)]
-    pdfset: String,
+    /// LHAPDF ID(s) or name of the PDF(s)/FF(s) to check the converted grid with.
+    conv_funs: ConvFuns,
     /// Relative threshold between the table and the converted grid when comparison fails.
     #[arg(default_value = "1e-10", long)]
     accuracy: f64,
@@ -97,13 +102,13 @@ impl Subcommand for Opts {
         use prettytable::{cell, row};
 
         let grid = helpers::read_grid(&self.input)?;
-        let mut pdf = helpers::create_pdf(&self.pdfset)?;
+        let mut conv_funs = helpers::create_conv_funs(&self.conv_funs)?;
 
         // TODO: figure out `member` from `self.pdfset`
         let (grid_type, results, scale_variations, order_mask) = convert_into_grid(
             &self.output,
             &grid,
-            &mut pdf,
+            &mut conv_funs,
             self.scales,
             self.discard_non_matching_scales,
         )?;
@@ -148,7 +153,7 @@ impl Subcommand for Opts {
         } else {
             let reference_results = helpers::convolve(
                 &grid,
-                &mut pdf,
+                &mut conv_funs,
                 &orders,
                 &[],
                 &[],