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 minimize( &self, settings: MinimizationSettings<Self>, ) -> Result<MinimizationSummary, LadduError>

Minimize the NLL with the algorithm given in the MinimizationSettings.

Errors

This method may return an error if there was any problem constructing thread pools or evaluating the underlying model.

pub fn mcmc( &self, settings: MCMCSettings<Self>, ) -> Result<MCMCSummary, LadduError>

Run an MCMC sampling algorithm over the NLL with the given MCMCSettings.

Errors

This method may return an error if there was any problem constructing thread pools or evaluating the underlying model.

impl NLL

pub fn new( model: &Model, ds_data: &Arc<Dataset>, ds_accmc: &Arc<Dataset>, ) -> Box<Self>

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 to_stochastic( &self, batch_size: usize, seed: Option<usize>, ) -> StochasticNLL

Create a new StochasticNLL from this NLL.

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

Activate an Amplitude by name.

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

Activate several Amplitudes by name.

pub fn activate_all(&self)

Activate all registered Amplitudes.

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

Dectivate an Amplitude by name.

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

Deactivate several Amplitudes by name.

pub fn deactivate_all(&self)

Deactivate all registered Amplitudes.

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

Isolate an Amplitude by name (deactivate the rest).

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

Isolate several Amplitudes by name (deactivate the rest).

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

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: &[Float], mc_evaluator: Option<Evaluator>, ) -> Vec<Float>

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: &[Float], mc_evaluator: Option<Evaluator>, ) -> (Vec<Float>, Vec<DVector<Float>>)

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: &[Float], mc_evaluator: Option<Evaluator>, ) -> (Vec<Float>, Vec<DVector<Float>>)

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: AsRef<str>>( &self, parameters: &[Float], names: &[T], mc_evaluator: Option<Evaluator>, ) -> Result<Vec<Float>, LadduError>

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: AsRef<str>>( &self, parameters: &[Float], names: &[T], mc_evaluator: Option<Evaluator>, ) -> Result<Vec<Float>, LadduError>

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: AsRef<str>>( &self, parameters: &[Float], names: &[T], mc_evaluator: Option<Evaluator>, ) -> Result<(Vec<Float>, Vec<DVector<Float>>), LadduError>

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: AsRef<str>>( &self, parameters: &[Float], names: &[T], mc_evaluator: Option<Evaluator>, ) -> Result<(Vec<Float>, Vec<DVector<Float>>), LadduError>

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.

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<Float>, args: &MaybeThreadPool, ) -> Result<Float, LadduError>

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<Float>, args: &MaybeThreadPool, ) -> Result<DVector<Float>, LadduError>

The evaluation of the 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.

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: &[Float]) -> Float

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: &[Float]) -> DVector<Float>

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.

fn update(&self)

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

impl LogDensity<MaybeThreadPool, LadduError> for NLL

fn log_density( &self, parameters: &DVector<Float>, args: &MaybeThreadPool, ) -> Result<Float, LadduError>

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