Add code to convolve converted grid

Author: cschwan

pineappl_cli/src/export.rs

@@ -49,24 +49,61 @@ fn convert_into_applgrid(
 fn convert_into_fastnlo(
     output: &Path,
     grid: &Grid,
-    conv_funs: &mut [Pdf],
-    _: usize,
+    fun_names: &ConvFuns,
+    scales: usize,
     discard_non_matching_scales: bool,
 ) -> Result<(&'static str, Vec<f64>, usize, Vec<bool>)> {
-    // TODO: check also scale-varied results
+    use pineappl_fastnlo::ffi;
+
+    // TODO: other cases NYI
+    assert_eq!(scales, 1);
+
+    // TODO: convert this into an error?
+    assert_eq!(fun_names.lhapdf_names.len(), 1);
+
+    // this creates a file, but doesn't give us an object that we can convolve with a function
+    let order_mask = fastnlo::convert_into_fastnlo(grid, output, discard_non_matching_scales)?;
+
+    // so load this file, giving the right PDF set
+    let mut file = ffi::make_fastnlo_lhapdf_with_name_file_set(
+        output.to_str().unwrap(),
+        &fun_names.lhapdf_names[0],
+        // UNWRAP: this shouldn't be negative or overflow
+        fun_names.members[0].unwrap_or(0).try_into().unwrap(),
+    );
 
-    let (mut fastnlo, order_mask) =
-        fastnlo::convert_into_fastnlo(grid, output, discard_non_matching_scales)?;
-    let results = fastnlo::convolve_fastnlo(fastnlo.pin_mut(), conv_funs);
+    let mut reader = ffi::downcast_lhapdf_to_reader_mut(file.as_mut().unwrap());
 
-    Ok(("fastNLO", results, 1, order_mask))
+    // fastNLO does not support a fragmentation scale
+    let unpermuted_results: Vec<_> = helpers::SCALES_VECTOR_REN_FAC[0..scales]
+        .iter()
+        .map(|&(xir, xif, _)| {
+            if !reader.as_mut().SetScaleFactorsMuRMuF(xir, xif) {
+                return None;
+            }
+            reader.as_mut().CalcCrossSection();
+            Some(ffi::GetCrossSection(reader.as_mut(), false))
+        })
+        .take_while(Option::is_some)
+        .map(Option::unwrap)
+        .collect();
+
+    assert!(matches!(unpermuted_results.len(), 1 | 3 | 7 | 9));
+
+    let bins = unpermuted_results[0].len();
+
+    let results: Vec<_> = (0..bins)
+        .flat_map(|bin| unpermuted_results.iter().map(move |r| r[bin]))
+        .collect();
+
+    Ok(("fastNLO", results, scales, order_mask))
 }
 
 #[cfg(not(feature = "fastnlo"))]
 fn convert_into_fastnlo(
     _: &Path,
     _: &Grid,
-    _: &mut [Pdf],
+    _: &ConvFuns,
     _: usize,
     _: bool,
 ) -> Result<(&'static str, Vec<f64>, usize, Vec<bool>)> {
@@ -79,6 +116,7 @@ fn convert_into_grid(
     output: &Path,
     grid: &mut Grid,
     conv_funs: &mut [Pdf],
+    fun_names: &ConvFuns,
     scales: usize,
     discard_non_matching_scales: bool,
 ) -> Result<(&'static str, Vec<f64>, usize, Vec<bool>)> {
@@ -101,7 +139,7 @@ fn convert_into_grid(
             return convert_into_fastnlo(
                 output,
                 grid,
-                conv_funs,
+                fun_names,
                 scales,
                 discard_non_matching_scales,
             );
@@ -158,6 +196,7 @@ impl Subcommand for Opts {
             &self.output,
             &mut grid,
             &mut conv_funs,
+            &self.conv_funs,
             self.scales,
             self.discard_non_matching_scales,
         )?;

pineappl_cli/src/export/fastnlo.rs

@@ -1,18 +1,15 @@
 use anyhow::{Result, bail};
-use cxx::UniquePtr;
 use float_cmp::assert_approx_eq;
-use lhapdf::Pdf;
 use pineappl::boc::Order;
 use pineappl::grid::Grid;
-use pineappl_fastnlo::ffi::{self, fastNLOLHAPDF};
+use pineappl_fastnlo::ffi;
 use std::path::Path;
-use std::pin::Pin;
 
 pub fn convert_into_fastnlo(
     grid: &Grid,
     output: &Path,
     _discard_non_matching_scales: bool,
-) -> Result<(UniquePtr<fastNLOLHAPDF>, Vec<bool>)> {
+) -> Result<Vec<bool>> {
     let bwfl = grid.bwfl();
     let dim = bwfl.dimensions();
 
@@ -108,12 +105,5 @@ pub fn convert_into_fastnlo(
 
     ffi::WriteTable(fastnlo.pin_mut(), &output);
 
-    todo!()
-}
-
-pub fn convolve_fastnlo(_grid: Pin<&mut fastNLOLHAPDF>, conv_funs: &mut [Pdf]) -> Vec<f64> {
-    // TODO: add support for convolving an fastNLO table with two functions
-    assert_eq!(conv_funs.len(), 1);
-
-    todo!()
+    Ok(order_mask)
 }