Struct BreitWigner

pub struct BreitWigner { /* private fields */ }

A relativistic Breit-Wigner Amplitude, parameterized as follows:

I_{\ell}(m; m_0, \Gamma_0, m_1, m_2) =  \frac{1}{\pi}\frac{m_0 \Gamma_0 B_{\ell}(m, m_1, m_2)}{(m_0^2 - m^2) - \imath m_0 \Gamma}

where

\Gamma = \Gamma_0 \frac{m_0}{m} \frac{q(m, m_1, m_2)}{q(m_0, m_1, m_2)} \left(\frac{B_{\ell}(m, m_1, m_2)}{B_{\ell}(m_0, m_1, m_2)}\right)^2

is the relativistic width correction, $q(m_a, m_b, m_c)$ is the breakup momentum of a particle with mass $m_a$ decaying into two particles with masses $m_b$ and $m_c$, $B_{\ell}(m_a, m_b, m_c)$ is the Blatt-Weisskopf barrier factor for the same decay assuming particle $a$ has angular momentum $\ell$, $m_0$ is the mass of the resonance, $\Gamma_0$ is the nominal width of the resonance, $m_1$ and $m_2$ are the masses of the decay products, and $m$ is the “input” mass.

Implementations

impl BreitWigner

pub fn new( name: &str, mass: ParameterLike, width: ParameterLike, l: usize, daughter_1_mass: &Mass, daughter_2_mass: &Mass, resonance_mass: &Mass, ) -> Box<BreitWigner>

Construct a BreitWigner with the given name, mass, width, and angular momentum (l). This uses the given resonance_mass as the “input” mass and two daughter masses of the decay products to determine phase-space and Blatt-Weisskopf factors.

Trait Implementations

impl Amplitude for BreitWigner

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 compute( &self, parameters: &Parameters<'_>, event: &Event, _cache: &Cache, ) -> Complex<f64>

This method constitutes the main machinery of an Amplitude, returning the actual calculated value for a particular Event and set of Parameters. See those structs, as well as Cache, for documentation on their available methods. For the most part, Events can be interacted with via Variables, while Parameters and the Cache are more like key-value storage accessed by ParameterIDs and several different types of cache IDs.

fn compute_gradient( &self, parameters: &Parameters<'_>, event: &Event, 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 particular Event and set of Parameters. See those structs, as well as Cache, for documentation on their available methods. For the most part, Events can be interacted with via Variables, while Parameters and the Cache are more like 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 precompute(&self, event: &Event, 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 the data in an Event, not on any free parameters in the fit. This method is opt-in since it is not required to make a functioning Amplitude.

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

Evaluates Amplitude::precompute over ever Event in a Dataset.

fn central_difference_with_indices( &self, indices: &[usize], parameters: &Parameters<'_>, event: &Event, 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.

impl Clone for BreitWigner

fn clone(&self) -> BreitWigner

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'de> Deserialize<'de> for BreitWigner

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for BreitWigner

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.