Struct NLL

pub struct NLL {
    pub data_evaluator: Evaluator,
    pub accmc_evaluator: Evaluator,
}

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( model: &Model, ds_data: &Arc<Dataset>, ds_accmc: &Arc<Dataset>, ) -> Box<NLL>

Construct an NLL from a Model and two Datasets (data and Monte Carlo). This is the equivalent of the Model::load method, but for two Datasets and a different method of evaluation.

pub fn activate<T>(&self, name: T) -> Result<(), LadduError>

where T: AsRef<str>,

Activate an Amplitude by name.

pub fn activate_many<T>(&self, names: &[T]) -> Result<(), LadduError>

where T: AsRef<str>,

Activate several Amplitudes by name.

pub fn activate_all(&self)

Activate all registered Amplitudes.

pub fn deactivate<T>(&self, name: T) -> Result<(), LadduError>

where T: AsRef<str>,

Dectivate an Amplitude by name.

pub fn deactivate_many<T>(&self, names: &[T]) -> Result<(), LadduError>

where T: AsRef<str>,

Deactivate several Amplitudes by name.

pub fn deactivate_all(&self)

Deactivate all registered Amplitudes.

pub fn isolate<T>(&self, name: T) -> Result<(), LadduError>

where T: AsRef<str>,

Isolate an Amplitude by name (deactivate the rest).

pub fn isolate_many<T>(&self, names: &[T]) -> Result<(), LadduError>

where T: AsRef<str>,

Isolate several Amplitudes by name (deactivate the rest).

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

Project the stored Model 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 instead.

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

Project the stored Model 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_gradient_local( &self, parameters: &[f64], mc_evaluator: Option<Evaluator>, ) -> (Vec<f64>, Vec<Matrix<f64, Dyn, Const<1>, VecStorage<f64, Dyn, Const<1>>>>)

Project the stored Model 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_gradient instead.

pub fn project_gradient( &self, parameters: &[f64], mc_evaluator: Option<Evaluator>, ) -> (Vec<f64>, Vec<Matrix<f64, Dyn, Const<1>, VecStorage<f64, Dyn, Const<1>>>>)

Project the stored Model 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_with_local<T>( &self, parameters: &[f64], names: &[T], mc_evaluator: Option<Evaluator>, ) -> Result<Vec<f64>, LadduError>

where T: AsRef<str>,

Project the stored Model 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 differs from the standard NLL::project in that it first isolates the selected Amplitudes by name, but returns the NLL to its prior state after calculation (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_with instead.

pub fn project_with<T>( &self, parameters: &[f64], names: &[T], mc_evaluator: Option<Evaluator>, ) -> Result<Vec<f64>, LadduError>

where T: AsRef<str>,

Project the stored Model 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 differs from the standard NLL::project in that it first isolates the selected Amplitudes by name, but returns the NLL to its prior state after calculation.

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_gradient_with_local<T>( &self, parameters: &[f64], names: &[T], mc_evaluator: Option<Evaluator>, ) -> Result<(Vec<f64>, Vec<Matrix<f64, Dyn, Const<1>, VecStorage<f64, Dyn, Const<1>>>>), LadduError>

where T: AsRef<str>,

Project the stored Model 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 differs from the standard NLL::project_gradient in that it first isolates the selected Amplitudes by name, but returns the NLL to its prior state after calculation (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_with instead.

pub fn project_gradient_with<T>( &self, parameters: &[f64], names: &[T], mc_evaluator: Option<Evaluator>, ) -> Result<(Vec<f64>, Vec<Matrix<f64, Dyn, Const<1>, VecStorage<f64, Dyn, Const<1>>>>), LadduError>

where T: AsRef<str>,

Project the stored Model 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 differs from the standard NLL::project_gradient in that it first isolates the selected Amplitudes by name, but returns the NLL to its prior state after calculation.

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.

impl NLL

pub fn minimize( &self, p0: &[f64], bounds: Option<Vec<(f64, f64)>>, options: Option<MinimizerOptions>, ) -> Result<Status, LadduError>

Minimizes the negative log-likelihood using the L-BFGS-B algorithm (by default), a limited-memory quasi-Newton minimizer which supports bounded optimization.

pub fn mcmc<T>( &self, p0: T, n_steps: usize, options: Option<MCMCOptions>, rng: Rng, ) -> Result<Ensemble, LadduError>

where T: AsRef<[Matrix<f64, Dyn, Const<1>, VecStorage<f64, Dyn, Const<1>>>]>,

Perform Markov Chain Monte Carlo sampling on this NLL. By default, this uses the ESS sampler.

pub fn swarm( &self, swarm: Swarm, options: Option<SwarmOptions>, rng: Rng, ) -> Result<Swarm, LadduError>

Perform Particle Swarm Optimization on this NLL.

Trait Implementations

impl Clone for NLL

fn clone(&self) -> NLL

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Function<ThreadPool, LadduError> for NLL

fn evaluate( &self, parameters: &[f64], thread_pool: &mut ThreadPool, ) -> Result<f64, LadduError>

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

fn gradient( &self, parameters: &[f64], thread_pool: &mut ThreadPool, ) -> Result<Matrix<f64, Dyn, Const<1>, VecStorage<f64, Dyn, Const<1>>>, LadduError>

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

fn evaluate_bounded( &self, x: &[f64], bounds: Option<&Vec<Bound>>, user_data: &mut U, ) -> Result<f64, E>

The evaluation of the function at a point x with the given arguments/user data. This function assumes x is an internal, unbounded vector, but performs a coordinate transform to bound x when evaluating the function.

fn gradient_bounded( &self, x: &[f64], bounds: Option<&Vec<Bound>>, user_data: &mut U, ) -> Result<Matrix<f64, Dyn, Const<1>, VecStorage<f64, Dyn, Const<1>>>, E>

The evaluation of the gradient at a point x with the given arguments/user data. This function assumes x is an internal, unbounded vector, but performs a coordinate transform to bound x when evaluating the function.

fn hessian( &self, x: &[f64], user_data: &mut 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 hessian_bounded( &self, x: &[f64], bounds: Option<&Vec<Bound>>, user_data: &mut 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. This function assumes x is an internal, unbounded vector, but performs a coordinate transform to bound x when evaluating the function.

impl LikelihoodTerm for NLL

fn parameters(&self) -> Vec<String>

Get the list of parameter names in the order they appear in the NLL::evaluate method.

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

Evaluate the stored Model over the events in the Dataset stored by the Evaluator with the given values for free parameters. 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. The result is given by the following formula:

NLL(\vec{p}) = -2 \left(\sum_{e \in \text{Data}} \text{weight}(e) \ln(\mathcal{L}(e)) - \frac{1}{N_{\text{MC}_A}} \sum_{e \in \text{MC}_A} \text{weight}(e) \mathcal{L}(e) \right)

fn evaluate_gradient( &self, parameters: &[f64], ) -> Matrix<f64, Dyn, Const<1>, VecStorage<f64, Dyn, Const<1>>>

Evaluate the gradient of the stored Model over the events in the Dataset stored by the Evaluator with the given values for free parameters. 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.