Struct ExtendedLogLikelihood

pub struct ExtendedLogLikelihood<F: Field + 'static> {
    pub data_manager: Manager<F>,
    pub mc_manager: Manager<F>,
}

The ExtendedLogLikelihood stores two Managers, one for data and one for a Monte-Carlo dataset used for acceptance correction. These should probably have the same Manager in practice, but this is left to the user.

Fields

data_manager: Manager<F>

Manager for data

mc_manager: Manager<F>

Manager for Monte-Carlo

Implementations

impl<F: Field> ExtendedLogLikelihood<F>

pub const fn new(data_manager: Manager<F>, mc_manager: Manager<F>) -> Self

Create a new ExtendedLogLikelihood from a data and Monte-Carlo Managers.

pub fn evaluate(&self, parameters: &[F]) -> Result<F, RustitudeError>

Evaluate the ExtendedLogLikelihood over the Dataset with the given free parameters.

Errors

This method will return a RustitudeError if the amplitude calculation fails. See Model::compute for more information.

pub fn evaluate_indexed( &self, parameters: &[F], indices_data: &[usize], indices_mc: &[usize], ) -> Result<F, RustitudeError>

Evaluate the ExtendedLogLikelihood over the Dataset with the given free parameters.

This method allows the user to supply two lists of indices and will only evaluate events at those indices. This can be used to evaluate only a subset of events or to resample events with replacement, such as in a bootstrap.

Errors

This method will return a RustitudeError if the amplitude calculation fails. See Model::compute for more information.

pub fn par_evaluate(&self, parameters: &[F]) -> Result<F, RustitudeError>

Evaluate the ExtendedLogLikelihood over the Dataset with the given free parameters.

This method also allows the user to input a maximum number of threads to use in the calculation, as it uses a parallel loop over events.

Errors

This method will return a RustitudeError if the amplitude calculation fails. See Model::compute for more information.

pub fn par_evaluate_indexed( &self, parameters: &[F], indices_data: &[usize], indices_mc: &[usize], ) -> Result<F, RustitudeError>

Evaluate the ExtendedLogLikelihood over the Dataset with the given free parameters.

This method allows the user to supply two lists of indices and will only evaluate events at those indices. This can be used to evaluate only a subset of events or to resample events with replacement, such as in a bootstrap.

This method also allows the user to input a maximum number of threads to use in the calculation, as it uses a parallel loop over events.

Errors

This method will return a RustitudeError if the amplitude calculation fails. See Model::compute for more information.

pub fn intensity( &self, parameters: &[F], dataset_mc: &Dataset<F>, ) -> Result<Vec<F>, RustitudeError>

Evaluate the normalized intensity function over the given Monte-Carlo Dataset with the given free parameters. This is intended to be used to plot a model over the dataset, usually with the generated or accepted Monte-Carlo as the input.

Errors

This method will return a RustitudeError if the amplitude calculation fails. See Model::compute for more information.

pub fn intensity_indexed( &self, parameters: &[F], dataset_mc: &Dataset<F>, indices_data: &[usize], indices_mc: &[usize], ) -> Result<Vec<F>, RustitudeError>

Evaluate the normalized intensity function over the given Monte-Carlo Dataset with the given free parameters. This is intended to be used to plot a model over the dataset, usually with the generated or accepted Monte-Carlo as the input.

This method allows the user to supply a list of indices and will only evaluate events at those indices. This can be used to evaluate only a subset of events or to resample events with replacement, such as in a bootstrap.

Errors

This method will return a RustitudeError if the amplitude calculation fails. See Model::compute for more information.

pub fn par_intensity( &self, parameters: &[F], dataset_mc: &Dataset<F>, ) -> Result<Vec<F>, RustitudeError>

Evaluate the normalized intensity function over the given Dataset with the given free parameters. This is intended to be used to plot a model over the dataset, usually with the generated or accepted Monte-Carlo as the input.

This method also allows the user to input a maximum number of threads to use in the calculation, as it uses a parallel loop over events.

Errors

This method will return a RustitudeError if the amplitude calculation fails. See Model::compute for more information.

pub fn par_intensity_indexed( &self, parameters: &[F], dataset_mc: &Dataset<F>, indices_data: &[usize], indices_mc: &[usize], ) -> Result<Vec<F>, RustitudeError>

Evaluate the normalized intensity function over the given Monte-Carlo Dataset with the given free parameters. This is intended to be used to plot a model over the dataset, usually with the generated or accepted Monte-Carlo as the input.

This method allows the user to supply a list of indices and will only evaluate events at those indices. This can be used to evaluate only a subset of events or to resample events with replacement, such as in a bootstrap.

This method also allows the user to input a maximum number of threads to use in the calculation, as it uses a parallel loop over events.

Errors

This method will return a RustitudeError if the amplitude calculation fails. See Model::compute for more information.

pub fn get_amplitude( &self, amplitude_name: &str, ) -> Result<Amplitude<F>, RustitudeError>

Get a copy of an Amplitude in the Model by name.

Errors

This method will return a RustitudeError if there is no amplitude found with the given name in the parent Model. See Model::get_amplitude for more information.

pub fn get_parameter( &self, amplitude_name: &str, parameter_name: &str, ) -> Result<Parameter<F>, RustitudeError>

Get a copy of a Parameter in a Model by name and the name of the parent Amplitude.

Errors

This method will return a RustitudeError if there is no parameter found with the given name in the parent Model. It will also first check if the given amplitude exists, and this method can also fail in the same way (see Model::get_amplitude and Model::get_parameter).

pub fn print_parameters(&self)

Print the free parameters in the Model. See Model::print_parameters for more information.

pub fn free_parameters(&self) -> Vec<Parameter<F>>

Returns a Vec<Parameter<F>> containing the free parameters in the data Manager.

See Model::free_parameters for more information.

pub fn fixed_parameters(&self) -> Vec<Parameter<F>>

Returns a Vec<Parameter<F>> containing the fixed parameters in the data Manager.

See Model::fixed_parameters for more information.

pub fn constrain( &mut self, amplitude_1: &str, parameter_1: &str, amplitude_2: &str, parameter_2: &str, ) -> Result<(), RustitudeError>

Constrain two parameters by name, reducing the number of free parameters by one.

Errors

This method will fail if any of the given amplitude or parameter names don’t correspond to a valid amplitude-parameter pair. See Model::constrain for more information.

pub fn fix( &mut self, amplitude: &str, parameter: &str, value: F, ) -> Result<(), RustitudeError>

Fix a parameter by name to the given value.

Errors

This method will fail if the given amplitude-parameter pair does not exist. See Model::fix for more information.

pub fn free( &mut self, amplitude: &str, parameter: &str, ) -> Result<(), RustitudeError>

Free a fixed parameter by name.

Errors

This method will fail if the given amplitude-parameter pair does not exist. See Model::free for more information.

pub fn set_bounds( &mut self, amplitude: &str, parameter: &str, bounds: (F, F), ) -> Result<(), RustitudeError>

Set the bounds of a parameter by name.

Errors

This method will fail if the given amplitude-parameter pair does not exist. See Model::set_bounds for more information.

pub fn set_initial( &mut self, amplitude: &str, parameter: &str, initial: F, ) -> Result<(), RustitudeError>

Set the initial value of a parameter by name.

Errors

This method will fail if the given amplitude-parameter pair does not exist. See Model::set_initial for more information.

pub fn get_bounds(&self) -> Vec<(F, F)>

Get a list of bounds for all free parameters in the Model. See Model::get_bounds for more information.

pub fn get_initial(&self) -> Vec<F>

Get a list of initial values for all free parameters in the Model. See Model::get_initial for more information.

pub fn get_n_free(&self) -> usize

Get the number of free parameters in the Model See Model::get_n_free for more information.

pub fn activate(&mut self, amplitude: &str) -> Result<(), RustitudeError>

Activate an Amplitude by name. See Model::activate for more information.

Errors

This function will return a RustitudeError::AmplitudeNotFoundError if the given amplitude is not present in the Model.

pub fn activate_all(&mut self)

Activates all Amplitudes by name. See Model::activate_all for more information.

pub fn isolate(&mut self, amplitudes: Vec<&str>) -> Result<(), RustitudeError>

Activate only the specified Amplitudes while deactivating the rest. See Model::isolate for more information.

Errors

This function will return a RustitudeError::AmplitudeNotFoundError if a given amplitude is not present in the Model.

pub fn deactivate(&mut self, amplitude: &str) -> Result<(), RustitudeError>

Deactivate an Amplitude by name. See Model::deactivate for more information.

Errors

This function will return a RustitudeError::AmplitudeNotFoundError if the given amplitude is not present in the Model.

pub fn deactivate_all(&mut self)

Deactivates all Amplitudes by name. See Model::deactivate_all for more information.

Trait Implementations

impl<F: Clone + Field + 'static> Clone for ExtendedLogLikelihood<F>

fn clone(&self) -> ExtendedLogLikelihood<F>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<F: Field> Debug for ExtendedLogLikelihood<F>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<F: Field> Display for ExtendedLogLikelihood<F>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<F: Field + Field> Function<F, (), RustitudeError> for ExtendedLogLikelihood<F>

fn evaluate( &self, x: &DVector<F>, _args: Option<&()>, ) -> Result<F, RustitudeError>

Evaluates the function at the given point.

fn gradient( &self, x: &Matrix<F, Dyn, Const<1>, VecStorage<F, Dyn, Const<1>>>, args: Option<&A>, ) -> Result<Matrix<F, Dyn, Const<1>, VecStorage<F, Dyn, Const<1>>>, E>

Computes the gradient of the function at the given point using central finite differences.

fn gradient_and_hessian( &self, x: &Matrix<F, Dyn, Const<1>, VecStorage<F, Dyn, Const<1>>>, args: Option<&A>, ) -> Result<(Matrix<F, Dyn, Const<1>, VecStorage<F, Dyn, Const<1>>>, Matrix<F, Dyn, Dyn, VecStorage<F, Dyn, Dyn>>), E>

Computes both the gradient and the Hessian matrix of the function at the given point.