Remove unused (sequential) function for the time-being

Author: Radonirinaunimi

pineappl/src/evolution.rs

@@ -357,145 +357,6 @@ fn ndarray_from_subgrid_orders_slice(
     Ok((x1n, (!zero).then_some(array)))
 }
 
-pub(crate) fn evolve_slice_sequential(
-    grid: &Grid,
-    operators: &[ArrayView4<f64>],
-    infos: &[OperatorSliceInfo],
-    scale_values: &[f64],
-    order_mask: &[bool],
-    xi: (f64, f64, f64),
-    alphas_table: &AlphasTable,
-) -> Result<(Array3<SubgridEnum>, Vec<Channel>)> {
-    let gluon_has_pid_zero = gluon_has_pid_zero(grid);
-
-    // TODO: implement matching of different scales for different EKOs
-    let mut fac1_scales: Vec<_> = infos.iter().map(|info| info.fac1).collect();
-    fac1_scales.sort_by(f64::total_cmp);
-    assert!(fac1_scales
-        .windows(2)
-        .all(|scales| subgrid::node_value_eq(scales[0], scales[1])));
-    let fac1 = fac1_scales[0];
-
-    assert_eq!(operators.len(), infos.len());
-    assert_eq!(operators.len(), grid.convolutions().len());
-
-    let (pid_indices, pids01): (Vec<_>, Vec<_>) = izip!(0..infos.len(), operators, infos)
-        .map(|(d, operator, info)| {
-            pid_slices(operator, info, gluon_has_pid_zero, &|pid1| {
-                grid.channels()
-                    .iter()
-                    .flat_map(Channel::entry)
-                    .any(|(pids, _)| pids[d] == pid1)
-            })
-        })
-        .collect::<Result<Vec<_>>>()?
-        .into_iter()
-        .unzip();
-
-    let mut channels0: Vec<_> = pids01
-        .iter()
-        .map(|pids| pids.iter().map(|&(pid0, _)| pid0))
-        .multi_cartesian_product()
-        .collect();
-    channels0.sort_unstable();
-    channels0.dedup();
-    let channels0 = channels0;
-
-    let mut sub_fk_tables = Vec::with_capacity(grid.bwfl().len() * channels0.len());
-
-    // TODO: generalize to `n`
-    let mut last_x1 = vec![Vec::new(); infos.len()];
-    let mut eko_slices = vec![Vec::new(); infos.len()];
-    let dim: Vec<_> = infos.iter().map(|info| info.x0.len()).collect();
-
-    for subgrids_oc in grid.subgrids().axis_iter(Axis(1)) {
-        let mut tables = vec![ArrayD::zeros(dim.clone()); channels0.len()];
-
-        for (subgrids_o, channel1) in subgrids_oc.axis_iter(Axis(1)).zip(grid.channels()) {
-            let (x1, array) = ndarray_from_subgrid_orders_slice(
-                grid,
-                fac1,
-                grid.kinematics(),
-                &subgrids_o,
-                grid.orders(),
-                order_mask,
-                xi,
-                alphas_table,
-            )?;
-
-            // skip over zero arrays to speed up evolution and avoid problems with NaNs
-            let Some(array) = array else {
-                continue;
-            };
-
-            for (last_x1, x1, pid_indices, slices, operator, info) in izip!(
-                &mut last_x1,
-                x1,
-                &pid_indices,
-                &mut eko_slices,
-                operators,
-                infos
-            ) {
-                if (last_x1.len() != x1.len())
-                    || last_x1
-                        .iter()
-                        .zip(x1.iter())
-                        .any(|(&lhs, &rhs)| !subgrid::node_value_eq(lhs, rhs))
-                {
-                    *slices = operator_slices(operator, info, pid_indices, &x1)?;
-                    *last_x1 = x1;
-                }
-            }
-
-            for (pids1, factor) in channel1.entry() {
-                for (fk_table, ops) in
-                    channels0
-                        .iter()
-                        .zip(tables.iter_mut())
-                        .filter_map(|(pids0, fk_table)| {
-                            izip!(pids0, pids1, &pids01, &eko_slices)
-                                .map(|(&pid0, &pid1, pids, slices)| {
-                                    pids.iter().zip(slices).find_map(|(&(p0, p1), op)| {
-                                        ((p0 == pid0) && (p1 == pid1)).then_some(op)
-                                    })
-                                })
-                                // TODO: avoid using `collect`
-                                .collect::<Option<Vec<_>>>()
-                                .map(|ops| (fk_table, ops))
-                        })
-                {
-                    general_tensor_mul(*factor, array.view(), &ops, fk_table.view_mut());
-                }
-            }
-        }
-
-        let mut node_values = vec![scale_values.to_vec()];
-
-        for info in infos {
-            node_values.push(info.x0.clone());
-        }
-
-        sub_fk_tables.extend(tables.into_iter().map(|table| {
-            ImportSubgridV1::new(
-                // TODO: insert one more axis if initial frg scale unequals fac
-                PackedArray::from(table.insert_axis(Axis(0)).view()),
-                node_values.clone(),
-            )
-            .into()
-        }));
-    }
-
-    Ok((
-        Array1::from_iter(sub_fk_tables)
-            .into_shape((1, grid.bwfl().len(), channels0.len()))
-            .unwrap(),
-        channels0
-            .into_iter()
-            .map(|c| Channel::new(vec![(c, 1.0)]))
-            .collect(),
-    ))
-}
-
 pub(crate) fn evolve_slice(
     grid: &Grid,
     operators: &[ArrayView4<f64>],