Fix broken documentation links

Author: cschwan

pineappl/src/boc.rs

@@ -1,5 +1,5 @@
-//! Module containing structures for the 3 dimensions of a [`Grid`]: bins, [`Order`] and channels
-//! (`boc`).
+//! Module containing structures for the 3 dimensions of a [`Grid`]: [`Bin`], [`Order`] and
+//! channels (`boc`).
 //!
 //! [`Grid`]: super::grid::Grid
 
@@ -734,13 +734,13 @@ impl Order {
     }
 
     /// Return a mask suitable to pass as the `order_mask` parameter of [`Grid::convolve`],
-    /// [`Grid::evolve_with_slice_iter`] or [`Grid::evolve_info`]. The selection of `orders` is
-    /// controlled using the `max_as` and `max_al` parameters, for instance setting `max_as = 1`
-    /// and `max_al = 0` selects the LO QCD only, `max_as = 2` and `max_al = 0` the NLO QCD;
-    /// setting `max_as = 3` and `max_al = 2` would select all NLOs, and the NNLO QCD.
+    /// [`Grid::evolve`] or [`Grid::evolve_info`]. The selection of `orders` is controlled using
+    /// the `max_as` and `max_al` parameters, for instance setting `max_as = 1` and `max_al = 0`
+    /// selects the LO QCD only, `max_as = 2` and `max_al = 0` the NLO QCD; setting `max_as = 3`
+    /// and `max_al = 2` would select all NLOs, and the NNLO QCD.
     ///
     /// [`Grid::convolve`]: super::grid::Grid::convolve
-    /// [`Grid::evolve_with_slice_iter`]: super::grid::Grid::evolve_with_slice_iter
+    /// [`Grid::evolve`]: super::grid::Grid::evolve
     /// [`Grid::evolve_info`]: super::grid::Grid::evolve_info
     ///
     /// # Example

pineappl/src/evolution.rs

@@ -1,4 +1,4 @@
-//! Supporting classes and functions for [`Grid::evolve_with_slice_iter`].
+//! Supporting classes and functions for [`Grid::evolve`].
 
 use super::boc::{Channel, Kinematics, Order};
 use super::convolutions::ConvType;
@@ -33,21 +33,22 @@ pub struct EvolveInfo {
     pub ren1: Vec<f64>,
 }
 
-/// Information about the evolution kernel operator slice (EKO) passed to
-/// [`Grid::evolve_with_slice_iter`](super::grid::Grid::evolve_with_slice_iter) as `operator`,
-/// which is used to convert a [`Grid`] into an [`FkTable`](super::fk_table::FkTable). The
-/// dimensions of the EKO must correspond to the values given in [`fac1`](Self::fac1),
+/// Information about the evolution kernel operator slice (EKO) passed to [`Grid::evolve`] as
+/// `operator`, which is used to convert a [`Grid`] into an [`FkTable`](super::fk_table::FkTable).
+/// The dimensions of the EKO must correspond to the values given in [`fac1`](Self::fac1),
 /// [`pids0`](Self::pids0), [`x0`](Self::x0), [`pids1`](Self::pids1) and [`x1`](Self::x1), exactly
 /// in this order. Members with a `1` are defined at the squared factorization scale given as
-/// `fac1` (often called process scale) and are found in the [`Grid`] that
-/// `Grid::evolve_with_slice_iter` is called with. Members with a `0` are defined at the squared
-/// factorization scale [`fac0`](Self::fac0) (often called fitting scale or starting scale) and are
-/// found in the `FkTable` resulting from [`Grid::evolve_with_slice_iter`].
+/// `fac1` (often called process scale) and are found in the [`Grid`] that [`Grid::evolve`] is
+/// called with. Members with a `0` are defined at the squared factorization scale
+/// [`fac0`](Self::fac0) (often called fitting scale or starting scale) and are found in the
+/// `FkTable` resulting from [`Grid::evolve`].
 ///
 /// The EKO slice may convert a `Grid` from a basis given by the particle identifiers `pids1` to a
 /// possibly different basis given by `pids0`. This basis must also be identified using
 /// [`pid_basis`](Self::pid_basis), which tells
 /// [`FkTable::convolve`](super::fk_table::FkTable::convolve) how to perform a convolution.
+///
+/// [`Grid::evolve`]: super::grid::Grid::evolve
 #[derive(Clone)]
 pub struct OperatorSliceInfo {
     /// Squared factorization/fragmentation scale of the `FkTable`.
@@ -66,9 +67,10 @@ pub struct OperatorSliceInfo {
 
     /// Particle ID basis for `FkTable`.
     pub pid_basis: PidBasis,
-    /// Type of convolution which this operator evolves. This also determines whether [`fac0`]
-    /// and [`fac1`] is a factorization ([`ConvType::UnpolPDF`] or [`ConvType::PolPDF`]) or a
-    /// fragmentation ([`ConvType::UnpolFF`] or [`ConvType::PolFF`]) scale.
+    /// Type of convolution which this operator evolves. This also determines whether
+    /// [`Self::fac0`] and [`Self::fac1`] is a factorization ([`ConvType::UnpolPDF`] or
+    /// [`ConvType::PolPDF`]) or a fragmentation ([`ConvType::UnpolFF`] or [`ConvType::PolFF`])
+    /// scale.
     pub conv_type: ConvType,
 }
 

pineappl/src/fk_table.rs

@@ -16,11 +16,10 @@ use std::str::FromStr;
 /// Structure implementing FK tables. These are special [`Grid`]s, for which the following
 /// additional guarantees are given:
 ///
-/// - all subgrids of the grid evaluate the PDFs at a single factorization scale given by
-///   [`FkTable::muf2`].
-/// - all subgrids, for both hadronic initial states (if both initial states are hadronic), share
-///   the same `x` grid. See [`FkTable::x_grid`].
-/// - the channel definitions are *simple*, meaning that every entry consists of a single pair of
+/// - all subgrids of the grid evaluate the convolution functions at a single factorization and
+///   fragmentation scale given by [`FkTable::fac0`] and [`FkTable::frg0`], respectively.
+/// - all subgrids share the same `x` grid. See [`FkTable::x_grid`].
+/// - the channel definitions are *simple*, meaning that every entry consists of a single tuple of
 ///   partons with trivial factor `1.0`, and all tuples are distinct from each other. See
 ///   [`Grid::channels`].
 /// - the FK table's grid contains only a single [`Order`], whose exponents are all zero.

pineappl/src/grid.rs

@@ -1089,9 +1089,8 @@ impl Grid {
     ///
     /// # Errors
     ///
-    /// Returns a [`GridError::EvolutionFailure`] if either the `operator` or its `info` is
-    /// incompatible with this `Grid`. Returns a [`GridError::Other`] if the iterator from `slices`
-    /// return an error.
+    /// Returns an error if either the `operator` or its `info` is incompatible with this `Grid`,
+    /// or if the iterator from `slices` return an error.
     ///
     /// # Panics
     ///

pineappl/src/lib.rs

@@ -5,17 +5,17 @@
 //! The main type of this crate is [`Grid`], which represents the interpolation grids that
 //! `PineAPPL` implements. Roughly speaking, a `Grid` is a three-dimensional array of [`Subgrid`]
 //! objects together with metadata. The three dimensions are
-//! 1. (perturbative) orders, represented by the type [`Order`] and accessible by
+//! 1. bins, whose limits can be accessed by [`Grid::bwfl()`], and
+//! 2. (perturbative) orders, represented by the type [`Order`] and accessible by
 //!    [`Grid::orders()`],
-//! 2. bins, whose limits can be accessed by [`Grid::bin_info()`], and
 //! 3. channels, whose definition is returned by [`Grid::channels()`].
 //!
 //! `Subgrid` is a `trait` and objects that implement it are of the type [`SubgridEnum`]. The
 //! latter is an `enum` of different types that are optimized to different scenarios: fast event
 //! filling, small storage profile, etc.
 //!
 //! [`Grid`]: grid::Grid
-//! [`Grid::bin_info()`]: grid::Grid::bin_info
+//! [`Grid::bwfl()`]: grid::Grid::bwfl
 //! [`Grid::channels()`]: grid::Grid::channels
 //! [`Grid::orders()`]: grid::Grid::orders
 //! [`Subgrid`]: subgrid::Subgrid

pineappl/src/pids.rs

@@ -170,7 +170,7 @@ impl PidBasis {
     }
 }
 
-/// Return type of [`PidBasis::optimization_rules`].
+/// Return type of [`PidBasis::opt_rules`].
 pub struct OptRules(pub Vec<(i32, i32)>, pub Vec<i32>);
 
 /// Translates IDs from the evolution basis into IDs using PDG Monte Carlo IDs.
@@ -444,9 +444,9 @@ pub const fn charge_conjugate_pdg_pid(pid: i32) -> i32 {
     }
 }
 
-/// Given `tuples` represting a linear combination of PDG MC IDs, return a PID for the `evol`
-/// basis. The order of each tuple in `tuples` is not relevant. This function inverts
-/// [`evol_to_pdg_mc_ids`]. If the inversion is not possible, `None` is returned.
+/// Given `tuples` representing a linear combination of PDG MC IDs, return a PID for the
+/// [`PidBasis::Evol`] basis. The order of each tuple in `tuples` is not relevant. If the inversion
+/// is not possible, `None` is returned.
 #[must_use]
 pub fn pdg_mc_ids_to_evol(tuples: &[(i32, f64)]) -> Option<i32> {
     let mut tuples = tuples.to_vec();

pineappl/src/subgrid.rs

@@ -55,8 +55,7 @@ impl SubgridEnum {
 #[derive(Debug, Eq, PartialEq)]
 pub struct Stats {
     /// Number of possible total entries for a subgrid. This number is the product of the lengths
-    /// of the slices returned by [`Subgrid::mu2_grid`], [`Subgrid::x1_grid`] and
-    /// [`Subgrid::x2_grid`].
+    /// of the containers returned by [`Subgrid::node_values`].
     pub total: usize,
     /// Number of allocated entries for a subgrid. This number is always smaller or equal than
     /// [`Self::total`].
@@ -79,7 +78,7 @@ pub trait Subgrid {
 
     /// Fill the subgrid with `weight` that is being interpolated with `interps` using the
     /// kinematic information in `ntuple`. The parameter `ntuple` assumes the same ordering given
-    /// by `kinematics` in [`Grid::new`] that was used to create the grid.
+    /// by `kinematics` in [`Grid::new`](super::grid::Grid::new) that was used to create the grid.
     fn fill(&mut self, interps: &[Interp], ntuple: &[f64], weight: f64);
 
     /// Returns true if `fill` was never called for this grid.