pint.templates.lcenorm.ENormAngles

class pint.templates.lcenorm.ENormAngles(norms, slope=None, slope_free=None, **kwargs)

Bases: NormAngles

norms – a tuple or array with the amplitudes of a set of components; their sum must be <= 1.

Methods

add_component([norm])	Add a component and return resulting object.
copy()
delete_component(index)	Remove a component and return resulting object.
dict_string()	Round down to avoid input errors w/ normalization.
eval_string()	Return a string that can be evaluated to instantiate a nearly- identical object.
get_bounds([free])	Angles are always [0,pi/2).
get_errors([free, propagate])	Get errors on components.
get_free_mask()	Return a mask with True if parameters are free, else False.
get_parameter_names([free])
get_parameters([free])
get_total()	Return the amplitude of all norms.
gradient(log10_ens[, free])	Return a matrix giving the value of the partial derivative of the ith normalization with respect to the jth angle, i.e.
hessian([log10_ens, free])	Return a matrix giving the value of the 2nd partial derivative of the ith normalization with respect to the jth and kth angles,
init()
is_energy_dependent()
num_parameters([free])
reorder_components(indices)
sanity_checks([eps])
set_errors(errs)	errs an array with the 1-sigma error estimates with shape equal to the number of free parameters.
set_parameters(p[, free])
set_single_norm(index, val)
set_total(val)	Set overall normalization of the represented components.

get_free_mask()

Return a mask with True if parameters are free, else False.

get_bounds(free=True)

Angles are always [0,pi/2).

set_errors(errs)

errs an array with the 1-sigma error estimates with shape equal to the number of free parameters.

get_errors(free=True, propagate=True)

Get errors on components. If specified, propagate errors from the internal angle parameters to the external normalizations.

gradient(log10_ens, free=True)

Return a matrix giving the value of the partial derivative of the ith normalization with respect to the jth angle, i.e.

M_ij = dn_i/dphi_j

This is the relevant quantity because it is the angles that are actually fit for, so this allows the application of the chain rule.

Because of the way the normalizations are defined, the ith normalization only depends on the (i+1)th first angles, so the upper half of M_ij is zero (see break statement below).

For taking higher derivatives, it is convenient to express the derivative as so: -d(cos^2(x)) = d(sin^2(x)) = sin(2x) So that any non-zero derivative can be expressed by taking the norm, dividing by sin^2/cos^2 as appropriate, and multiplying by +/- sin(2x). Then higher derivatives simply pop out a factor of +/-2 and toggle sin/cos.

__call__(log10_ens=3)

Return the squared value of the Cartesian coordinates.

E.g., for a 4-sphere, return x0^2 = sin^2(a)*cos^2(b) x1^2 = sin^2(a)*sin^2(b)*cos^2(c) x2^2 = sin^2(a)*sin^2(b)*sin^2(c)*cos^2(d) x3^2 = sin^2(a)*sin^2(b)*sin^2(c)*sin^2(d)

Recall that the normalization is also given as an angle, s.t. the vector lies within the unit sphere.

These values are guaranteed to satisfy the constraint of a sum <= unity and so are suitable for normalizations of a light curve.

NB this version should work with both scalar (log10_ens=3) and vector (log10_ens an array) versions. The shape is [nparam] for scalar and [nparam, nenergy] for vector.

add_component(norm=0.1)

Add a component and return resulting object.

The normalization is specified as a fraction of the current pulsed normalization, such that the resulting NormAngles or ENormAngles object will have the same overall pulsed fraction at the pivot en.

delete_component(index)

Remove a component and return resulting object.

Pulsed normalization is preserved, and NormAngles or ENormAngles is return as appropriate.

dict_string()

Round down to avoid input errors w/ normalization.

eval_string()

Return a string that can be evaluated to instantiate a nearly- identical object.

get_total()

Return the amplitude of all norms.

hessian(log10_ens=3, free=False)

Return a matrix giving the value of the 2nd partial derivative of the ith normalization with respect to the jth and kth angles,

M_ijk = dn2_i/dphi_j/dphi_k

See above notes for gradient. In general, the cases are

j < k <= i; just calculate as gradient, getting two sin(2x) terms j = k <= i; in this case, pick up a single 2*cos(2x) instead

set_total(val)

Set overall normalization of the represented components.