Allow a generic number of EKOs to be passed to pineappl evolve

Author: Radonirinaunimi

pineappl_cli/src/evolve.rs

@@ -1,11 +1,11 @@
-use super::helpers::{self, ConvFuns, ConvoluteMode};
+use super::helpers::{self, ConvFuns, ConvoluteMode, EkoNames};
 use super::{GlobalConfiguration, Subcommand};
 use anyhow::{anyhow, Result};
 use clap::{Parser, ValueHint};
 use lhapdf::Pdf;
 use pineappl::fk_table::FkTable;
 use pineappl::grid::Grid;
-use std::path::{Path, PathBuf};
+use std::path::PathBuf;
 use std::process::ExitCode;
 
 #[cfg(feature = "evolve")]
@@ -438,7 +438,7 @@ mod eko {
 #[cfg(feature = "evolve")]
 fn evolve_grid(
     grid: &Grid,
-    ekos: &[&Path],
+    ekos: &[PathBuf],
     use_alphas_from: &Pdf,
     orders: &[(u8, u8)],
     xir: f64,
@@ -461,7 +461,7 @@ fn evolve_grid(
 
     let mut eko_slices: Vec<_> = ekos
         .iter()
-        .map(|eko| EkoSlices::new(eko))
+        .map(|eko| EkoSlices::new(eko.as_path()))
         .collect::<Result<_, _>>()?;
     let eko_slices: Vec<_> = eko_slices.iter_mut().collect();
     let alphas_table = AlphasTable::from_grid(grid, xir, &|q2| use_alphas_from.alphas_q2(q2));
@@ -490,17 +490,14 @@ pub struct Opts {
     /// Path to the input grid.
     #[arg(value_hint = ValueHint::FilePath)]
     input: PathBuf,
-    /// Path to the evolution kernel operator.
-    #[arg(value_hint = ValueHint::FilePath)]
-    eko: PathBuf,
+    /// Path to the evolution kernel operator(s).
+    #[arg(value_name = "EKOs")]
+    ekos: EkoNames,
     /// Path to the converted grid.
     #[arg(value_hint = ValueHint::FilePath)]
     output: PathBuf,
     /// LHAPDF ID(s) or name of the PDF(s)/FF(s).
     conv_funs: ConvFuns,
-    /// Additional path to the 2nd evolution kernel operator.
-    #[arg(value_hint = ValueHint::FilePath, long)]
-    ekob: Option<PathBuf>,
     /// Relative threshold between the table and the converted grid when comparison fails.
     #[arg(default_value = "1e-3", long)]
     accuracy: f64,
@@ -548,12 +545,10 @@ impl Subcommand for Opts {
             cfg,
         );
 
+        let ekonames = helpers::create_eko_paths(&self.ekos, &self.conv_funs.conv_types);
         let fk_table = evolve_grid(
             &grid,
-            &self.ekob.as_ref().map_or_else(
-                || vec![self.eko.as_path()],
-                |ekob| vec![self.eko.as_path(), ekob],
-            ),
+            &ekonames,
             &conv_funs[cfg.use_alphas_from],
             &self.orders,
             self.xir,

pineappl_cli/src/helpers.rs

@@ -10,10 +10,62 @@ use prettytable::Table;
 use std::fs::{File, OpenOptions};
 use std::iter;
 use std::ops::RangeInclusive;
-use std::path::Path;
+use std::path::{Path, PathBuf};
 use std::process::ExitCode;
 use std::str::FromStr;
 
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct EkoNames {
+    pub eko_names: Vec<String>,
+    pub conv_types: Vec<ConvType>,
+}
+
+impl FromStr for EkoNames {
+    type Err = Error;
+
+    fn from_str(arg: &str) -> std::result::Result<Self, Self::Err> {
+        let (eko_names, conv_types) = arg
+            .split(',')
+            .map(|fun| {
+                let (name, typ) = fun.split_once('+').unwrap_or((fun, ""));
+                let name = name.to_owned();
+
+                let typ = match typ {
+                    "" => ConvType::UnpolPDF,
+                    "p" => ConvType::PolPDF,
+                    "f" => ConvType::UnpolFF,
+                    "pf" | "fp" => ConvType::PolFF,
+                    _ => bail!("unknown convolution type '{typ}'"),
+                };
+                Ok::<_, Error>((name, typ))
+            })
+            .collect::<Result<Vec<(String, ConvType)>>>()?
+            .into_iter()
+            .multiunzip();
+
+        Ok(Self {
+            eko_names,
+            conv_types,
+        })
+    }
+}
+
+pub fn create_eko_paths(eko_obj: &EkoNames, conv_types: &[ConvType]) -> Vec<PathBuf> {
+    let vec_ekonames: Vec<String> = conv_types
+        .iter()
+        .map(|convtype| {
+            let eko_cv_idx = eko_obj
+                .conv_types
+                .iter()
+                .position(|&x| x == *convtype)
+                .unwrap_or(0);
+            eko_obj.eko_names[eko_cv_idx].clone()
+        })
+        .collect();
+
+    vec_ekonames.iter().map(PathBuf::from).collect()
+}
+
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub struct ConvFuns {
     pub lhapdf_names: Vec<String>,
@@ -269,7 +321,8 @@ pub fn convolve_scales(
     // TODO: promote this to an error
     assert!(
         cfg.use_alphas_from < conv_funs.len(),
-        "expected `use_alphas_from` to be `0` or `1`, is `{}`",
+        "expected `use_alphas_from` to be an integer within `[0, {})`, but got `{}`",
+        conv_funs.len(),
         cfg.use_alphas_from
     );
 

pineappl_cli/tests/convolve.rs

@@ -36,7 +36,8 @@ const DEFAULT_STR: &str = "b   etal    dsig/detal
 7    4  4.5 2.7517266e1
 ";
 
-const USE_ALPHAS_FROM_ERROR_STR: &str = "expected `use_alphas_from` to be `0` or `1`, is `2`
+const USE_ALPHAS_FROM_ERROR_STR: &str =
+    "expected `use_alphas_from` to be an integer within `[0, 2)`, but got `2`
 ";
 
 const FORCE_POSITIVE_STR: &str = "b   etal    dsig/detal 

pineappl_cli/tests/evolve.rs

@@ -6,16 +6,15 @@ use assert_fs::NamedTempFile;
 
 const HELP_STR: &str = "Evolve a grid with an evolution kernel operator to an FK table
 
-Usage: pineappl evolve [OPTIONS] <INPUT> <EKO> <OUTPUT> <CONV_FUNS>
+Usage: pineappl evolve [OPTIONS] <INPUT> <EKOs> <OUTPUT> <CONV_FUNS>
 
 Arguments:
   <INPUT>      Path to the input grid
-  <EKO>        Path to the evolution kernel operator
+  <EKOs>       Path to the evolution kernel operator(s)
   <OUTPUT>     Path to the converted grid
   <CONV_FUNS>  LHAPDF ID(s) or name of the PDF(s)/FF(s)
 
 Options:
-      --ekob <EKOB>          Additional path to the 2nd evolution kernel operator
       --accuracy <ACCURACY>  Relative threshold between the table and the converted grid when comparison fails [default: 1e-3]
       --digits-abs <ABS>     Set the number of fractional digits shown for absolute numbers [default: 7]
       --digits-rel <REL>     Set the number of fractional digits shown for relative numbers [default: 7]
@@ -428,15 +427,15 @@ fn cms_ttb_8tev_2d_ttm_trap_tot() {
 fn star_wmwp_510gev_wm_al_pol() {
     let output = NamedTempFile::new("fktable6.lz4").unwrap();
 
+    // Here the order of the EKOs are swapped to check that mapping convtype is working
     Command::cargo_bin("pineappl")
         .unwrap()
         .args([
             "evolve",
             "../test-data/STAR_WMWP_510GEV_WM-AL-POL.pineappl.lz4",
-            "../test-data/STAR_WMWP_510GEV_WM-AL-POL_PolPDF.tar",
+            "../test-data/STAR_WMWP_510GEV_WM-AL-POL_UnpolPDF.tar,../test-data/STAR_WMWP_510GEV_WM-AL-POL_PolPDF.tar+p",
             output.path().to_str().unwrap(),
             "240608-tr-pol-nlo-100+p,NNPDF40_nlo_pch_as_01180",
-            "--ekob=../test-data/STAR_WMWP_510GEV_WM-AL-POL_UnpolPDF.tar",
         ])
         .assert()
         .success()