Use Conv in the CAPI

Author: cschwan

examples/cpp/advanced-filling.cpp

@@ -37,10 +37,10 @@ int main() {
     // hadrons. Then we add the corresponding PID of each of the hadrons, and finally define the
     // Basis onto which the partons are mapped.
     pineappl_pid_basis pid_basis = PINEAPPL_PID_BASIS_EVOL;
-    int32_t pdg_ids[2] = { 2212, 2212};
-    pineappl_conv_type h1 = PINEAPPL_CONV_TYPE_UNPOL_PDF;
-    pineappl_conv_type h2 = PINEAPPL_CONV_TYPE_UNPOL_PDF;
-    pineappl_conv_type convolution_types[2] = { h1, h2 };
+    pineappl_conv convs[] = {
+        { PINEAPPL_CONV_TYPE_UNPOL_PDF, 2212 },
+        { PINEAPPL_CONV_TYPE_UNPOL_PDF, 2212 },
+    };
 
     // Define the kinematics required for this process. In the following example we have ONE
     // single scale and two momentum fractions (corresponding to the two initial-state hadrons).
@@ -74,7 +74,7 @@ int main() {
     // exponents in `orders`, 24 bins given as the 25 limits in `bins` and potential extra
     // parameters in `keyval`.
     auto* grid = pineappl_grid_new2(bins.size() - 1, bins.data(), orders.size() / 5, orders.data(),
-        channels, pid_basis, convolution_types, pdg_ids, 3, interpolations, kinematics, mu_scales);
+        channels, pid_basis, convs, 3, interpolations, kinematics, mu_scales);
 
     // now we no longer need `channels`
     pineappl_channels_delete(channels);

examples/cpp/fill-grid.cpp

@@ -180,10 +180,10 @@ int main() {
     // hadrons. Then we add the corresponding PID of each of the hadrons, and finally define the
     // Basis onto which the partons are mapped.
     pineappl_pid_basis pid_basis = PINEAPPL_PID_BASIS_EVOL;
-    int32_t pdg_ids[2] = { 2212, 2212};
-    pineappl_conv_type h1 = PINEAPPL_CONV_TYPE_UNPOL_PDF;
-    pineappl_conv_type h2 = PINEAPPL_CONV_TYPE_UNPOL_PDF;
-    pineappl_conv_type convolution_types[2] = { h1, h2 };
+    pineappl_conv convs[] = {
+        { PINEAPPL_CONV_TYPE_UNPOL_PDF, 2212 },
+        { PINEAPPL_CONV_TYPE_UNPOL_PDF, 2212 },
+    };
 
     // Define the kinematics required for this process. In the following example we have ONE
     // single scale and two momentum fractions (corresponding to the two initial-state hadrons).
@@ -217,7 +217,7 @@ int main() {
     // exponents in `orders`, 24 bins given as the 25 limits in `bins` and potential extra
     // parameters in `keyval`.
     auto* grid = pineappl_grid_new2(bins.size() - 1, bins.data(), orders.size() / 5, orders.data(),
-        channels, pid_basis, convolution_types, pdg_ids, 3, interpolations, kinematics, mu_scales);
+        channels, pid_basis, convs, 3, interpolations, kinematics, mu_scales);
 
     // now we no longer need `keyval` and `channels`
     pineappl_channels_delete(channels);

examples/fortran/lhapdf_example.f90

@@ -11,6 +11,7 @@ program lhapdf_example
     type(pineappl_kinematics)      :: kinematics(3)
     type(pineappl_scale_func_form) :: mu_scales_form(3)
     type(pineappl_interp)          :: interp_info(3)
+    type(pineappl_conv)            :: convolutions(2)
 
     type(pineappl_xfx) :: xfx
     type(pineappl_alphas) :: alphas
@@ -53,8 +54,13 @@ program lhapdf_example
         pineappl_scale_func_form(PINEAPPL_SCALE_FUNC_FORM_NO_SCALE, pineappl_scale_func_form_body(0, 0)) &
     ]
 
+    convolutions = [ &
+        pineappl_conv(pineappl_unpol_pdf, 2212), &
+        pineappl_conv(pineappl_unpol_pdf, 2212) &
+    ]
+
     grid = pineappl_grid_new2(2, [0.0_dp, 1.0_dp, 2.0_dp], 1, [2_1, 0_1, 0_1, 0_1, 0_1], channels, pineappl_pdg, &
-        [pineappl_unpol_pdf, pineappl_unpol_pdf], [2212, 2212], 3, interp_info, kinematics, mu_scales_form)
+        convolutions, 3, interp_info, kinematics, mu_scales_form)
 
     call pineappl_grid_fill_all2(grid, 0, 0.5_dp, [100.0_dp, 0.5_dp, 0.5_dp], [0.5_dp, 0.5_dp, 0.5_dp])
     call pineappl_grid_fill_all2(grid, 0, 1.5_dp, [100.0_dp, 0.5_dp, 0.5_dp], [1.5_dp, 1.5_dp, 1.5_dp])

examples/fortran/pineappl.f90

@@ -105,6 +105,11 @@ module pineappl
         type(pineappl_scale_func_form_body) :: body
     end type
 
+    type, bind(c) :: pineappl_conv
+        integer(kind(pineappl_conv_type)) :: conv_type
+        integer(c_int32_t) :: pid
+    end type
+
     type, bind(c) :: pineappl_interp
         real(c_double) :: min
         real(c_double) :: max
@@ -345,18 +350,17 @@ type (c_ptr) function grid_new(lumi, orders, order_params, bins, bin_limits, key
         end function
 
         type (c_ptr) function grid_new2(bins, bin_limits, orders, order_params, channels, &
-            pid_basis, convolution_types, convolution_pdg_ids, interpolations, interp_info, &
+            pid_basis, convolutions, interpolations, interp_info, &
             kinematics, mu_scales) bind(c, name = 'pineappl_grid_new2')
             use iso_c_binding
             import ! so we can use pineappl_kinematics and pineappl_interp
 
             integer (c_int32_t), value :: pid_basis
             type (c_ptr), value :: channels
-            integer (c_int32_t) :: convolution_types(*)
             integer (c_size_t), value :: orders, bins, interpolations
             integer (c_int8_t) :: order_params(*)
             real (c_double) :: bin_limits(*)
-            integer (c_int32_t) :: convolution_pdg_ids(*)
+            type (pineappl_conv) :: convolutions(*)
             type (pineappl_kinematics) :: kinematics(*)
             type (pineappl_interp) :: interp_info(*)
             type (pineappl_scale_func_form) :: mu_scales(*)
@@ -932,17 +936,15 @@ type (pineappl_grid) function pineappl_grid_new(lumi, orders, order_params, bins
     end function
 
     type (pineappl_grid) function pineappl_grid_new2(bins, bin_limits, orders, order_params, &
-        channels, pid_basis, convolution_types, convolution_pdg_ids, interpolations, interp_info, &
-        kinematics, mu_scales)
+        channels, pid_basis, convolutions, interpolations, interp_info, kinematics, mu_scales)
         implicit none
 
         integer(kind(pineappl_pid_basis)), intent(in)                             :: pid_basis
         type (pineappl_channels), intent(in)                                      :: channels
         integer, intent(in)                                                       :: orders, bins, interpolations
         integer(int8), dimension(5 * orders), intent(in)                          :: order_params
         real (dp), dimension(bins + 1), intent(in)                                :: bin_limits
-        integer(kind(pineappl_conv_type)), dimension(interpolations - 1), intent(in) :: convolution_types
-        integer, dimension(interpolations - 1), intent(in)                        :: convolution_pdg_ids
+        type (pineappl_conv), dimension(*), intent(in), target                    :: convolutions
         type (pineappl_kinematics), dimension(interpolations), intent(in), target :: kinematics
         type (pineappl_interp), dimension(interpolations), intent(in)             :: interp_info
         type (pineappl_scale_func_form), dimension(interpolations)                :: mu_scales
@@ -956,8 +958,7 @@ type (pineappl_grid) function pineappl_grid_new2(bins, bin_limits, orders, order
             order_params, &
             channels%ptr, &
             pid_basis, &
-            convolution_types, &
-            convolution_pdg_ids, &
+            convolutions, &
             int(interpolations, c_size_t), &
             interp_info, &
             kinematics, &

examples/fortran/test.f90

@@ -11,6 +11,7 @@ program test_pineappl
     type(pineappl_kinematics)      :: kinematics(3)
     type(pineappl_scale_func_form) :: mu_scales_form(3)
     type(pineappl_interp)          :: interp_info(3)
+    type(pineappl_conv)            :: convolutions(2)
 
     real(dp), allocatable :: result(:), bin_limits_left(:), bin_limits_right(:), bin_normalizations(:)
 
@@ -63,8 +64,13 @@ program test_pineappl
         pineappl_scale_func_form(PINEAPPL_SCALE_FUNC_FORM_NO_SCALE, pineappl_scale_func_form_body(0, 0)) &
     ]
 
+    convolutions = [ &
+        pineappl_conv(pineappl_unpol_pdf, 2212), &
+        pineappl_conv(pineappl_unpol_pdf, 2212) &
+    ]
+
     grid = pineappl_grid_new2(2, [0.0_dp, 1.0_dp, 2.0_dp], 1, [2_1, 0_1, 0_1, 0_1, 0_1], channels, pineappl_pdg, &
-        [pineappl_unpol_pdf, pineappl_unpol_pdf], [2212, 2212], 3, interp_info, kinematics, mu_scales_form)
+        convolutions, 3, interp_info, kinematics, mu_scales_form)
 
     if (pineappl_grid_order_count(grid) /= 1) then
         write(*, *) "pineappl_grid_order_count(): ", pineappl_grid_order_count(grid)
@@ -131,7 +137,7 @@ program test_pineappl
     end if
 
     grid2 = pineappl_grid_new2(1, [2.0_dp, 3.0_dp], 1, [2_1, 0_1, 0_1, 0_1, 0_1], channels, pineappl_pdg, &
-        [pineappl_unpol_pdf, pineappl_unpol_pdf], [2212, 2212], 3, interp_info, kinematics, mu_scales_form)
+        convolutions, 3, interp_info, kinematics, mu_scales_form)
 
     call pineappl_grid_merge_and_delete(grid, grid2)
 

examples/object-oriented-cpp/dyaa.cpp

@@ -130,12 +130,12 @@ int main() {
 
   // --- Construct the PineAPPL grid
   pineappl_pid_basis pid_basis = PINEAPPL_PID_BASIS_EVOL;
-  std::vector<std::int32_t> pids = {2212, 2212};
 
   // Define the types of convolutions
-  pineappl_conv_type h1 = PINEAPPL_CONV_TYPE_UNPOL_PDF;
-  pineappl_conv_type h2 = PINEAPPL_CONV_TYPE_UNPOL_PDF;
-  std::vector<pineappl_conv_type> convolution_types = {h1, h2};
+  std::vector<pineappl_conv> convolutions = {
+      {PINEAPPL_CONV_TYPE_UNPOL_PDF, 2212},
+      {PINEAPPL_CONV_TYPE_UNPOL_PDF, 2212}
+  };
 
   // Define the Kinematics
   pineappl_kinematics scales = {PINEAPPL_KINEMATICS_SCALE, 0};
@@ -164,7 +164,7 @@ int main() {
   pineappl_scale_func_form no_scale_form = {PINEAPPL_SCALE_FUNC_FORM_NO_SCALE, 0};
   std::vector<pineappl_scale_func_form> mu_scales = {scale_form, scale_form, no_scale_form};
 
-  PineAPPL::Grid grid(orders, channels, pid_basis, pids, convolution_types,
+  PineAPPL::Grid grid(orders, channels, pid_basis, convolutions,
                       kinematics, interpolations, bins, mu_scales);
 
   // fill the grid with phase-space points

pineappl_capi/cbindgen.toml

@@ -35,6 +35,7 @@ rename_variants = "ScreamingSnakeCase"
 
 [export.rename]
 "Channels" = "pineappl_channels"
+"Conv" = "pineappl_conv"
 "ConvType" = "pineappl_conv_type"
 "Grid" = "pineappl_grid"
 "GridOptFlags" = "pineappl_gof"

pineappl_capi/include/PineAPPL.hpp

@@ -153,21 +153,18 @@ struct Grid {
   Grid(std::vector<Order> &orders,
        const Channels &channels,
        pineappl_pid_basis pid_basis,
-       std::vector<int32_t> pids,
-       std::vector<pineappl_conv_type> &convolution_types,
+       std::vector<pineappl_conv> &convolutions,
        std::vector<pineappl_kinematics> &kinematics,
        std::vector<pineappl_interp> &interp,
        std::vector<double> &bin_limits,
        std::vector<pineappl_scale_func_form> &mu_scales)
       : Grid(nullptr) {
     const std::size_t n_orders = orders.size();
     const std::size_t n_bins = bin_limits.size() - 1;
-    const std::size_t n_convs = convolution_types.size();
+    const std::size_t n_convs = convolutions.size();
 
     // Various checks for the input arguments
     assert(n_orders >= 1 && "Orders cannot be empty.");
-    assert(n_convs == pids.size() &&
-           "Number of convolutions and pids are different.");
     assert(n_convs == kinematics.size() - 1 &&
            "Mismatch in the number of convolutions and the kinematics.");
     assert(kinematics.size() == interp.size() &&
@@ -186,7 +183,7 @@ struct Grid {
 
     this->raw = pineappl_grid_new2(
         n_bins, bin_limits.data(), n_orders, raw_orders.data(), channels.raw,
-        pid_basis, convolution_types.data(), pids.data(), interp.size(),
+        pid_basis, convolutions.data(), interp.size(),
         interp.data(), kinematics.data(), mu_scales.data());
   }
 

pineappl_capi/src/lib.rs

@@ -67,7 +67,7 @@ use std::collections::HashMap;
 use std::ffi::{CStr, CString};
 use std::fs::File;
 use std::mem;
-use std::os::raw::{c_char, c_int, c_void};
+use std::os::raw::{c_char, c_void};
 use std::path::Path;
 use std::slice;
 
@@ -1625,8 +1625,7 @@ pub unsafe extern "C" fn pineappl_grid_new2(
     order_params: *const u8,
     channels: *const Channels,
     pid_basis: PidBasis,
-    convolution_types: *const ConvType,
-    convolution_pdg_ids: *const c_int,
+    convolutions: *const Conv,
     interpolations: usize,
     interps: *const Interp,
     kinematics: *const Kinematics,
@@ -1649,19 +1648,10 @@ pub unsafe extern "C" fn pineappl_grid_new2(
         .collect();
     let Channels {
         channels,
-        convolutions,
+        convolutions: nb_convolutions,
     } = unsafe { &*channels }.clone();
 
-    // Construct the convolution objects
-    let convolution_types =
-        unsafe { slice::from_raw_parts(convolution_types, convolutions).to_vec() };
-    let convolution_pdg_ids =
-        unsafe { slice::from_raw_parts(convolution_pdg_ids, convolutions).to_vec() };
-    let convolutions = convolution_types
-        .iter()
-        .zip(convolution_pdg_ids)
-        .map(|(&convolution_type, pdg_id)| Conv::new(convolution_type, pdg_id))
-        .collect();
+    let convolutions = unsafe { slice::from_raw_parts(convolutions, nb_convolutions) }.to_vec();
 
     // Grid interpolations
     let interp_slices = unsafe { std::slice::from_raw_parts(interps, interpolations) };