pub struct Order {
pub alphas: u32,
pub alpha: u32,
pub logxir: u32,
pub logxif: u32,
}
Expand description
Coupling powers for each grid.
Fields§
§alphas: u32
Exponent of the strong coupling.
alpha: u32
Exponent of the electromagnetic coupling.
logxir: u32
Exponent of the logarithm of the scale factor of the renomalization scale.
logxif: u32
Exponent of the logarithm of the scale factor of the factorization scale.
Implementations§
source§impl Order
impl Order
sourcepub const fn new(alphas: u32, alpha: u32, logxir: u32, logxif: u32) -> Self
pub const fn new(alphas: u32, alpha: u32, logxir: u32, logxif: u32) -> Self
Constructor. This function mainly exists to have a way of constructing Order
that is less
verbose.
sourcepub fn create_mask(
orders: &[Self],
max_as: u32,
max_al: u32,
logs: bool
) -> Vec<bool>
pub fn create_mask( orders: &[Self], max_as: u32, max_al: u32, logs: bool ) -> Vec<bool>
Return a mask suitable to pass as the order_mask
parameter of Grid::convolute
,
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.
§Example
In the case of Drell—Yan, there are the following orders:
- exactly one leading order (LO),
- two next-to-leading orders (NLO), which are
- the NLO QCD and
- the NLO EW, and
- three next-to-next-to-leading orders (NNLO),
- the NNLO QCD,
- the NNLO EW, and finally
- the mixed NNLO QCD—EW.
use pineappl::grid::Order;
let orders = [
Order::new(0, 2, 0, 0), // LO : alpha^2
Order::new(1, 2, 0, 0), // NLO QCD : alphas alpha^2
Order::new(0, 3, 0, 0), // NLO EW : alpha^3
Order::new(2, 2, 0, 0), // NNLO QCD : alphas^2 alpha^2
Order::new(1, 3, 0, 0), // NNLO QCD—EW : alphas alpha^3
Order::new(0, 4, 0, 0), // NNLO EW : alpha^4
];
// LO EW
assert_eq!(Order::create_mask(&orders, 0, 1, false), [true, false, false, false, false, false]);
// LO QCD
assert_eq!(Order::create_mask(&orders, 1, 0, false), [true, false, false, false, false, false]);
// LO
assert_eq!(Order::create_mask(&orders, 1, 1, false), [true, false, false, false, false, false]);
// NLO QCD
assert_eq!(Order::create_mask(&orders, 2, 0, false), [true, true, false, false, false, false]);
// NLO EW
assert_eq!(Order::create_mask(&orders, 0, 2, false), [true, false, true, false, false, false]);
// NNLO QCD
assert_eq!(Order::create_mask(&orders, 3, 0, false), [true, true, false, true, false, false]);
// NNLO EW
assert_eq!(Order::create_mask(&orders, 0, 3, false), [true, false, true, false, false, true]);
Orders containing non-zero powers of logarithms can be selected as well if logs
is set to
true
:
use pineappl::grid::Order;
let orders = [
Order::new(0, 2, 0, 0), // LO : alpha^2
Order::new(1, 2, 0, 0), // NLO QCD : alphas alpha^2
Order::new(1, 2, 1, 0), // NLO QCD : alphas alpha^2 logxif
Order::new(0, 3, 0, 0), // NLO EW : alpha^3
Order::new(0, 3, 1, 0), // NLO EW : alpha^3 logxif
];
assert_eq!(Order::create_mask(&orders, 0, 2, true), [true, false, false, true, true]);
For the more complicated example of top-pair production one can see the difference between the selection for different LOs:
use pineappl::grid::Order;
let orders = [
Order::new(2, 0, 0, 0), // LO QCD : alphas^2
Order::new(1, 1, 0, 0), // LO QCD—EW : alphas alpha
Order::new(0, 2, 0, 0), // LO EW : alpha^2
Order::new(3, 0, 0, 0), // NLO QCD : alphas^3
Order::new(2, 1, 0, 0), // NLO QCD—EW : alphas^2 alpha
Order::new(1, 2, 0, 0), // NLO QCD—EW : alphas alpha^2
Order::new(0, 3, 0, 0), // NLO EW : alpha^3
];
// LO EW
assert_eq!(Order::create_mask(&orders, 0, 1, false), [false, false, true, false, false, false, false]);
// LO QCD
assert_eq!(Order::create_mask(&orders, 1, 0, false), [true, false, false, false, false, false, false]);
// LO
assert_eq!(Order::create_mask(&orders, 1, 1, false), [true, true, true, false, false, false, false]);
Trait Implementations§
source§impl<'de> Deserialize<'de> for Order
impl<'de> Deserialize<'de> for Order
source§fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
__D: Deserializer<'de>,
fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
__D: Deserializer<'de>,
source§impl Ord for Order
impl Ord for Order
source§impl PartialEq for Order
impl PartialEq for Order
source§impl PartialOrd for Order
impl PartialOrd for Order
1.0.0 · source§fn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read more