Struct NLL 

pub struct NLL {
    pub data_evaluator: Evaluator,
    pub accmc_evaluator: Evaluator,
    /* private fields */
}

An extended, unbinned negative log-likelihood evaluator.

Fields

data_evaluator: Evaluator

The internal Evaluator for data

accmc_evaluator: Evaluator

The internal Evaluator for accepted Monte Carlo

Implementations

impl NLL

pub fn new( expression: &Expression, ds_data: &Arc<Dataset>, ds_accmc: &Arc<Dataset>, n_mc: Option<f64>, ) -> LadduResult<Box<Self>>

Construct an NLL from an Expression and two Datasets (data and Monte Carlo). This mirrors loading a model but starts from the expression directly. The number of Monte Carlo events used in the denominator of the normalization integral may also be specified (uses the weighted number of accepted Monte Carlo events if None is given).

pub fn parameters(&self) -> ParameterMap

The parameters for this NLL.

pub fn n_free(&self) -> usize

Number of free parameters.

pub fn n_fixed(&self) -> usize

Number of fixed parameters.

pub fn n_parameters(&self) -> usize

Total number of parameters.

pub fn expression(&self) -> Expression

Returns the expression represented by this NLL.

pub fn compiled_expression(&self) -> CompiledExpression

Returns a tree-like diagnostic snapshot of the compiled expression for this NLL’s current active-amplitude mask.

pub fn to_stochastic( &self, batch_size: usize, seed: Option<usize>, ) -> LadduResult<StochasticNLL>

Create a new StochasticNLL from this NLL.

pub fn activate<T: AsRef<str>>(&self, name: T)

Activate an Amplitude by tag, skipping missing entries.

pub fn activate_strict<T: AsRef<str>>(&self, name: T) -> LadduResult<()>

Activate an Amplitude by tag and return an error if it is missing.

pub fn activate_many<T: AsRef<str>>(&self, names: &[T])

Activate several Amplitudes by tag, skipping missing entries.

pub fn activate_many_strict<T: AsRef<str>>( &self, names: &[T], ) -> LadduResult<()>

Activate several Amplitudes by tag and return an error if any are missing.

pub fn activate_all(&self)

Activate all registered Amplitudes.

pub fn deactivate<T: AsRef<str>>(&self, name: T)

Deactivate an Amplitude by tag, skipping missing entries.

pub fn deactivate_strict<T: AsRef<str>>(&self, name: T) -> LadduResult<()>

Deactivate an Amplitude by tag and return an error if it is missing.

pub fn deactivate_many<T: AsRef<str>>(&self, names: &[T])

Deactivate several Amplitudes by tag, skipping missing entries.

pub fn deactivate_many_strict<T: AsRef<str>>( &self, names: &[T], ) -> LadduResult<()>

Deactivate several Amplitudes by tag and return an error if any are missing.

pub fn deactivate_all(&self)

Deactivate all registered Amplitudes.

pub fn isolate<T: AsRef<str>>(&self, name: T)

Isolate an Amplitude by tag (deactivate the rest), skipping missing entries.

pub fn isolate_strict<T: AsRef<str>>(&self, name: T) -> LadduResult<()>

Isolate an Amplitude by tag (deactivate the rest) and return an error if it is missing.

pub fn isolate_many<T: AsRef<str>>(&self, names: &[T])

Isolate several Amplitudes by tag (deactivate the rest), skipping missing entries.

pub fn isolate_many_strict<T: AsRef<str>>(&self, names: &[T]) -> LadduResult<()>

Isolate several Amplitudes by tag (deactivate the rest) and return an error if any are missing.

pub fn project_weights_local( &self, parameters: &[f64], mc_evaluator: Option<Evaluator>, ) -> LadduResult<Vec<f64>>

Project the stored Expression over the events in the Dataset stored by the Evaluator with the given values for free parameters to obtain weights for each Monte-Carlo event (non-MPI version).

Notes

This method is not intended to be called in analyses but rather in writing methods that have mpi-feature-gated versions. Most users will want to call NLL::project_weights instead.

pub fn project_weights( &self, parameters: &[f64], mc_evaluator: Option<Evaluator>, ) -> LadduResult<Vec<f64>>

Project the stored Expression over the events in the Dataset stored by the Evaluator with the given values for free parameters to obtain weights for each Monte-Carlo event. This method takes the real part of the given expression (discarding the imaginary part entirely, which does not matter if expressions are coherent sums wrapped in Expression::norm_sqr. Event weights are determined by the following formula:

\text{weight}(\vec{p}; e) = \text{weight}(e) \mathcal{L}(e) / N_{\text{MC}}

Note that $N_{\text{MC}}$ will always be the number of accepted Monte Carlo events, regardless of the mc_evaluator.

pub fn project_weights_and_gradients_local( &self, parameters: &[f64], mc_evaluator: Option<Evaluator>, ) -> LadduResult<(Vec<f64>, Vec<DVector<f64>>)>

Project the stored Expression over the events in the Dataset stored by the Evaluator with the given values for free parameters to obtain weights and gradients of those weights for each Monte-Carlo event (non-MPI version).

Notes

This method is not intended to be called in analyses but rather in writing methods that have mpi-feature-gated versions. Most users will want to call NLL::project_weights_and_gradients instead.

pub fn project_weights_and_gradients( &self, parameters: &[f64], mc_evaluator: Option<Evaluator>, ) -> LadduResult<(Vec<f64>, Vec<DVector<f64>>)>

Project the stored Expression over the events in the Dataset stored by the Evaluator with the given values for free parameters to obtain weights and gradients of those weights for each Monte-Carlo event. This method takes the real part of the given expression (discarding the imaginary part entirely, which does not matter if expressions are coherent sums wrapped in Expression::norm_sqr. Event weights are determined by the following formula:

\text{weight}(\vec{p}; e) = \text{weight}(e) \mathcal{L}(e) / N_{\text{MC}}

Note that $N_{\text{MC}}$ will always be the number of accepted Monte Carlo events, regardless of the mc_evaluator.

pub fn project_weights_subset_local<T: AsRef<str>>( &self, parameters: &[f64], names: &[T], mc_evaluator: Option<Evaluator>, ) -> LadduResult<Vec<f64>>

Project the model over one isolated amplitude subset in local execution, skipping missing amplitude tags.

pub fn project_weights_subset_local_strict<T: AsRef<str>>( &self, parameters: &[f64], names: &[T], mc_evaluator: Option<Evaluator>, ) -> LadduResult<Vec<f64>>

Project the model over one isolated amplitude subset in local execution and return an error if any requested amplitude tag is missing.

pub fn project_weights_subset<T: AsRef<str>>( &self, parameters: &[f64], names: &[T], mc_evaluator: Option<Evaluator>, ) -> LadduResult<Vec<f64>>

Project the model over one isolated amplitude subset, skipping missing amplitude names.

pub fn project_weights_subset_strict<T: AsRef<str>>( &self, parameters: &[f64], names: &[T], mc_evaluator: Option<Evaluator>, ) -> LadduResult<Vec<f64>>

Project the model over one isolated amplitude subset and return an error if any requested amplitude tag is missing.

pub fn project_weights_subsets_local<T: AsRef<str>>( &self, parameters: &[f64], subsets: &[Vec<T>], mc_evaluator: Option<Evaluator>, ) -> LadduResult<Vec<Vec<f64>>>

Project the model over multiple isolated amplitude subsets in local execution, skipping missing amplitude tags within each subset.

pub fn project_weights_subsets_local_strict<T: AsRef<str>>( &self, parameters: &[f64], subsets: &[Vec<T>], mc_evaluator: Option<Evaluator>, ) -> LadduResult<Vec<Vec<f64>>>

Project the model over multiple isolated amplitude subsets in local execution and return an error if any requested amplitude tag is missing.

pub fn project_weights_subsets<T: AsRef<str>>( &self, parameters: &[f64], subsets: &[Vec<T>], mc_evaluator: Option<Evaluator>, ) -> LadduResult<Vec<Vec<f64>>>

Project the model over multiple isolated amplitude subsets, skipping missing amplitude tags within each subset.

pub fn project_weights_subsets_strict<T: AsRef<str>>( &self, parameters: &[f64], subsets: &[Vec<T>], mc_evaluator: Option<Evaluator>, ) -> LadduResult<Vec<Vec<f64>>>

Project the model over multiple isolated amplitude subsets and return an error if any requested amplitude tag is missing.

pub fn project_weights_and_gradients_subset_local<T: AsRef<str>>( &self, parameters: &[f64], names: &[T], mc_evaluator: Option<Evaluator>, ) -> LadduResult<(Vec<f64>, Vec<DVector<f64>>)>

Project the model and parameter gradients over one isolated amplitude subset in local execution, skipping missing amplitude tags.

pub fn project_weights_and_gradients_subset_local_strict<T: AsRef<str>>( &self, parameters: &[f64], names: &[T], mc_evaluator: Option<Evaluator>, ) -> LadduResult<(Vec<f64>, Vec<DVector<f64>>)>

Project the model and parameter gradients over one isolated amplitude subset in local execution and return an error if any requested amplitude tag is missing.

pub fn project_weights_and_gradients_subset<T: AsRef<str>>( &self, parameters: &[f64], names: &[T], mc_evaluator: Option<Evaluator>, ) -> LadduResult<(Vec<f64>, Vec<DVector<f64>>)>

Project the model and parameter gradients over one isolated amplitude subset, skipping missing amplitude tags.

pub fn project_weights_and_gradients_subset_strict<T: AsRef<str>>( &self, parameters: &[f64], names: &[T], mc_evaluator: Option<Evaluator>, ) -> LadduResult<(Vec<f64>, Vec<DVector<f64>>)>

Project the model and parameter gradients over one isolated amplitude subset and return an error if any requested amplitude tag is missing.

Trait Implementations

impl Clone for NLL

fn clone(&self) -> NLL

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl CostFunction<MaybeThreadPool, LadduError> for NLL

fn evaluate( &self, parameters: &DVector<f64>, args: &MaybeThreadPool, ) -> LadduResult<f64>

The evaluation of the function at a point x with the given arguments/user data.

impl Gradient<MaybeThreadPool, LadduError> for NLL

fn gradient( &self, parameters: &DVector<f64>, args: &MaybeThreadPool, ) -> LadduResult<DVector<f64>>

The evaluation of the gradient at a point x with the given arguments/user data.

fn evaluate_with_gradient( &self, x: &Matrix<f64, Dyn, Const<1>, VecStorage<f64, Dyn, Const<1>>>, args: &U, ) -> Result<(f64, Matrix<f64, Dyn, Const<1>, VecStorage<f64, Dyn, Const<1>>>), E>

The evaluation of both the function and its gradient at a point x with the given arguments/user data.

fn hessian( &self, x: &Matrix<f64, Dyn, Const<1>, VecStorage<f64, Dyn, Const<1>>>, args: &U, ) -> Result<Matrix<f64, Dyn, Dyn, VecStorage<f64, Dyn, Dyn>>, E>

The evaluation of the hessian at a point x with the given arguments/user data.

fn gradient_with_hessian( &self, x: &Matrix<f64, Dyn, Const<1>, VecStorage<f64, Dyn, Const<1>>>, args: &U, ) -> Result<(Matrix<f64, Dyn, Const<1>, VecStorage<f64, Dyn, Const<1>>>, Matrix<f64, Dyn, Dyn, VecStorage<f64, Dyn, Dyn>>), E>

The evaluation of both the gradient and hessian at a point x with the given arguments/user data.

fn evaluate_with_gradient_and_hessian( &self, x: &Matrix<f64, Dyn, Const<1>, VecStorage<f64, Dyn, Const<1>>>, args: &U, ) -> Result<(f64, Matrix<f64, Dyn, Const<1>, VecStorage<f64, Dyn, Const<1>>>, Matrix<f64, Dyn, Dyn, VecStorage<f64, Dyn, Dyn>>), E>

The evaluation of the function, gradient, and hessian at a point x with the given arguments/user data.

impl LikelihoodTerm for NLL

fn evaluate(&self, parameters: &[f64]) -> LadduResult<f64>

Evaluate the term given some input parameters.

fn evaluate_gradient(&self, parameters: &[f64]) -> LadduResult<DVector<f64>>

Evaluate the gradient of the term given some input parameters.

fn fix_parameter(&self, name: &str, value: f64) -> LadduResult<()>

Fix a named parameter local to this term.

fn free_parameter(&self, name: &str) -> LadduResult<()>

Mark a named parameter local to this term as free.

fn rename_parameter(&self, old: &str, new: &str) -> LadduResult<()>

Rename a single parameter local to this term.

fn rename_parameters( &self, mapping: &HashMap<String, String>, ) -> LadduResult<()>

Rename multiple parameters local to this term.

fn parameter_map(&self) -> ParameterMap

Return the parameters owned by this term in local order.

fn update(&self)

A method called every step of any minimization/MCMC algorithm.

fn into_expression(self) -> LadduResult<LikelihoodExpression>

where Self: Sized + 'static,

Convenience helper to wrap a likelihood term into a LikelihoodExpression.

impl LogDensity<MaybeThreadPool, LadduError> for NLL

fn log_density( &self, parameters: &DVector<f64>, args: &MaybeThreadPool, ) -> LadduResult<f64>

The log of the evaluation of the density function at a point x with the given arguments/user data.