Struct Voigt 

pub struct Voigt { /* private fields */ }

A Voigt line-shape Amplitude.

The normalized profile is

V(m; m_0, \Gamma, \sigma) =
\frac{\operatorname{Re}[w(z)]}{\sigma \sqrt{2\pi}},
\qquad
z = \frac{m - m_0 + i\Gamma/2}{\sigma\sqrt{2}},

where $w(z)$ is the Faddeeva function. Here $\Gamma$ is the Lorentzian full width at half maximum and $\sigma$ is the Gaussian resolution width. This amplitude returns $\sqrt{V}$ so its norm-squared is the normalized Voigt profile.

Implementations

impl Voigt

pub fn new( name: &str, mass: Parameter, width: Parameter, sigma: Parameter, resonance_mass: &Mass, ) -> Result<Expression, LadduError>

Construct a Voigt with the given name, mass, width, and Gaussian sigma.

This uses the given resonance_mass as the input mass. width is the Lorentzian full width at half maximum and sigma is the Gaussian resolution width.

Trait Implementations

impl Amplitude for Voigt

fn register( &mut self, resources: &mut Resources, ) -> Result<AmplitudeID, LadduError>

This method should be used to tell the Resources manager about all of the free parameters and cached values used by this Amplitude. It should end by returning an AmplitudeID, which can be obtained from the Resources::register_amplitude method.

fn semantic_key(&self) -> Option<AmplitudeSemanticKey>

Optional semantic identity key for same-name deduplication.

fn real_valued_hint(&self) -> bool

Optional hint that this amplitude always evaluates to a purely real complex value.

fn bind(&mut self, metadata: &DatasetMetadata) -> Result<(), LadduError>

Bind this Amplitude to a concrete Dataset by using the provided metadata to wire up Variables or other dataset-specific state. This will be invoked when a Expression is loaded with data, after register has already succeeded. The default implementation is a no-op for amplitudes that do not depend on metadata.

fn precompute(&self, event: &NamedEventView<'_>, cache: &mut Cache)

This method can be used to do some critical calculations ahead of time and store them in a Cache. These values can only depend on event data, not on any free parameters in the fit. This method is opt-in since it is not required to make a functioning Amplitude.

fn compute(&self, parameters: &Parameters, cache: &Cache) -> Complex<f64>

This method constitutes the main machinery of an Amplitude, returning the actual calculated value for a particular set of Parameters and event Cache.

fn compute_gradient( &self, parameters: &Parameters, cache: &Cache, gradient: &mut Matrix<Complex<f64>, Dyn, Const<1>, VecStorage<Complex<f64>, Dyn, Const<1>>>, )

This method yields the gradient of a particular Amplitude at a point specified by a set of Parameters. See those structs, as well as Cache, for documentation on their available methods. For the most part, Parameters and the Cache are key-value storage accessed by ParameterIDs and several different types of cache IDs. If the analytic version of the gradient is known, this method can be overwritten to improve performance for some derivative-using methods of minimization. The default implementation calculates a central finite difference across all parameters, regardless of whether or not they are used in the Amplitude.

fn dependence_hint(&self) -> ExpressionDependence

Optional dependence hint used by expression-IR diagnostics/planning.

fn precompute_all(&self, dataset: &Dataset, resources: &mut Resources)

Evaluate Amplitude::precompute over columnar event views in a Dataset.

fn central_difference_with_indices( &self, indices: &[usize], parameters: &Parameters, cache: &Cache, gradient: &mut Matrix<Complex<f64>, Dyn, Const<1>, VecStorage<Complex<f64>, Dyn, Const<1>>>, )

A helper function to implement a central difference only on indices which correspond to free parameters in the Amplitude. For example, if an Amplitude contains free parameters registered to indices 1, 3, and 5 of the its internal parameters array, then running this with those indices will compute a central finite difference derivative for those coordinates only, since the rest can be safely assumed to be zero.

fn into_expression(self) -> Result<Expression, LadduError>

where Self: Sized + 'static,

Convenience helper to wrap an amplitude into an Expression.

impl Clone for Voigt

fn clone(&self) -> Voigt

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'de> Deserialize<'de> for Voigt

fn deserialize<__D>( __deserializer: __D, ) -> Result<Voigt, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Voigt

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.