laddu 0.20.0

Amplitude analysis tools for Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153

//! Tools for constructing, compiling, and evaluating amplitude-analysis models.
//!
//! laddu exposes symbolic expressions, event datasets, particle and decay
//! topology utilities, execution backends, and optional likelihood, fitting,
//! generation, amplitude, and GPU support through one facade crate. Most
//! applications can import [`prelude`] and enable only the Cargo features they
//! need.
//!
//! # Example
//!
//! ```
//! use laddu::prelude::*;
//!
//! let mass = parameter!("mass");
//! let intensity = (mass.clone() * mass + 1.0).named("intensity");
//! let model = CompiledModel::from_expr(&intensity)?;
//!
//! assert_eq!(model.params().len(), 1);
//! # Ok::<(), CompileError>(())
//! ```

/// A global error type for laddu along with re-exported error types for each crate in the laddu suite.
pub mod error;

#[cfg(feature = "python")]
/// Shared implementation of laddu's Python extension modules.
///
/// This module is public so the small Maturin distribution crates can expand
/// [`laddu_python_module!`]. Rust applications should use the crate-level Rust
/// API instead.
pub mod python;

pub use error::*;
pub use laddu_autodiff as autodiff;
pub use laddu_compile as compile;
pub use laddu_data as data;
pub use laddu_expr as expr;
pub use laddu_expr::parameters as params;
pub use laddu_kernel as kernel;
pub use laddu_physics as physics;
pub use laddu_runtime as runtime;

#[cfg(feature = "generation")]
pub use laddu_generation as generation;

pub use laddu_expr::parameter;
pub use laddu_expr::parameters::Parameter;
pub use laddu_expr::{
    BinaryOp, ColorPreset, ComponentIndex, DisplayColor, Expr, ExprGraph, ExprGraphDotDisplay,
    ExprGraphTreeDisplay, ExprId, ExprMetadata, ExprNode, ExprNodeKind, ExprShape, ExprShapeError,
    ExprSourceKind, NodeSelector, NodeStyle, NodeStyleRule, P4Component, RepeatedSubtrees, UnaryOp,
    acos, atan2, cis, complex, dot, event_p4_component, event_scalar, matmul, matrix,
    matrix_from_flat, matvec, polar_complex, solve, vector,
};
pub use laddu_runtime::{
    BinSpec, Comparison, DatasetBin, DatasetExprExt, DeviceIdentity, IntervalClosure, MemoryBudget,
    MemoryDecision, MemoryPlan, MemoryPoolReport, MemoryReport, MemoryResource, MemoryResourceKind,
    MemoryState, Predicate, ProcessMemoryReport,
};

#[cfg(feature = "svg")]
pub use laddu_expr::GraphRenderError;

#[cfg(feature = "amplitudes")]
pub use laddu_amplitudes as amplitudes;

#[cfg(feature = "likelihood")]
pub use laddu_likelihood as likelihood;

#[cfg(feature = "fit")]
pub use laddu_fit as fit;

#[cfg(feature = "wgpu")]
pub use laddu_wgpu as wgpu;

pub mod prelude {
    //! The experiment-neutral public API for building analyses.
    //!
    //! Collaboration-specific schemas, cuts, formats, and conventions belong
    //! in downstream crates built from these general-purpose primitives.

    pub use crate::{LadduError, LadduResult};
    #[cfg(feature = "amplitudes")]
    pub use laddu_amplitudes::{
        AmplitudeError, AmplitudeResult, KMatrixError, KMatrixResult, blatt_weisskopf_barriers,
        breit_wigner, f_vector, k_matrix, k_matrix_with_background, p_vector,
        p_vector_with_background, relativistic_breit_wigner, relativistic_breit_wigner_custom,
    };
    pub use laddu_autodiff::AutodiffMode;
    pub use laddu_compile::{CompileError, CompileOptions, CompileResult, CompiledModel};
    pub use laddu_data::{
        LadduDataError, LadduDataResult,
        data::{CacheStorage, Dataset, EventBatch, EventBatchBuilder, MemoryPolicy, OwnedEvent},
        io::{
            EventSink, EventSource, Partitioning, ReadPlan, SourceCapabilities, WritePlan,
            memory::{MemorySink, MemorySource},
            parquet::{ParquetSink, ParquetSource},
            root::{RootSink, RootSource},
        },
        schema::{ColumnType, Schema},
    };
    #[cfg(feature = "svg")]
    pub use laddu_expr::GraphRenderError;
    pub use laddu_expr::parameter;
    pub use laddu_expr::parameters::{
        Bounds, FreeParamId, InitialSpec, ParamError, ParamId, ParamLayout, ParamRegistry,
        ParamState, ParamValues, Parameter,
    };
    pub use laddu_expr::{
        BinaryOp, ColorPreset, ComponentIndex, DisplayColor, Expr, ExprGraph, ExprGraphDotDisplay,
        ExprGraphTreeDisplay, ExprId, ExprMetadata, ExprNode, ExprNodeKind, ExprShape,
        ExprShapeError, ExprSourceKind, NodeSelector, NodeStyle, NodeStyleRule, P4Component,
        RepeatedSubtrees, UnaryOp, acos, atan2, cis, complex, dot, event_p4_component,
        event_scalar, matmul, matrix, matrix_from_flat, matvec, polar_complex, solve, vector,
    };
    #[cfg(feature = "fit")]
    pub use laddu_fit::{FitError, FitProblem, FitResult, StochasticFitProblem, ganesh};
    #[cfg(feature = "generation")]
    pub use laddu_generation::{
        ChannelGenerator, EnvelopeKind, EnvelopeMode, EnvelopeOverflow, GenerationError,
        GenerationReport, GenerationResult, InitialMomentum, InitialMomentumResult, MassProposal,
        ModelEvaluator, NamedMass, NamedMomentum, ProposalResult, ProposalRng,
        ScalarProposalResult, ScalarSource, TComponent, TDistribution, TwoBodyScattering,
        UnweightedConfig, VertexProposal, WeightedConfig,
    };
    #[cfg(feature = "likelihood")]
    pub use laddu_likelihood::{
        Axis, BinnedEstimate, BootstrapFitError, CrossSection, CrossSectionIntegrals,
        DifferentialCrossSection, Ensemble, Estimate, ExtendedNllTerm, LassoPenalty, Likelihood,
        LikelihoodError, LikelihoodEvaluation, LikelihoodName, LikelihoodProjection,
        LikelihoodResult, LikelihoodTerm, NllTerm, Objective, RidgePenalty, StochasticObjective,
        next_uncertainty_source_id,
    };
    pub use laddu_physics::quantum::builtin as particles;
    pub use laddu_physics::{
        LadduPhysicsError, LadduPhysicsResult,
        channel::{Channel, Edge, EdgeHandle, Vertex, VertexHandle, VertexView},
        clebsch_gordan,
        histogram::Histogram,
        j, l, m,
        math::*,
        quantum::*,
        s,
        vectors::{RealVec3, RealVec4, Vec3, Vec4},
    };
    pub use laddu_runtime::{
        BinSpec, Comparison, CpuOptions, DatasetBin, DatasetExprExt, Device, DeviceIdentity,
        Execution, ExecutionError, ExecutionOptions, GpuBackend, GpuDeviceSelector, GpuOptions,
        IntervalClosure, JitPolicy, MemoryBudget, MemoryDecision, MemoryPlan, MemoryPoolReport,
        MemoryReport, MemoryResource, MemoryResourceKind, MemoryState, Precision, Predicate,
        ProcessMemoryReport, RuntimeError, RuntimeResult, ThreadPolicy,
    };
}