LightCurveTemplateTemporalModel#

class gammapy.modeling.models.LightCurveTemplateTemporalModel(map, t_ref=None, filename=None, method=None, values_scale=None)[source]#

Bases: TemporalModel

Temporal light curve model.

The lightcurve is given at specific times (and optionally energies) as a norm It can be serialised either as an astropy table or a RegionNDMap

The norm is supposed to be a unit-less multiplicative factor in the model, to be multiplied with a spectral model.

The model does linear interpolation for times between the given (time, energy, norm) values.

When the temporal model is energy-dependent, the default interpolation scheme is linear with a log scale for the values. The interpolation method and scale values can be changed with the method and values_scale arguments.

For more information see Light curve temporal model.

Examples

Read an example light curve object:

>>> from gammapy.modeling.models import LightCurveTemplateTemporalModel
>>> path = '$GAMMAPY_DATA/tests/models/light_curve/lightcrv_PKSB1222+216.fits'
>>> light_curve = LightCurveTemplateTemporalModel.read(path)

Show basic information about the lightcurve:

>>> print(light_curve)
LightCurveTemplateTemporalModel model summary:
 Reference time: 59000.49919925926 MJD
 Start time: 58999.99919925926 MJD
 End time: 61862.99919925926 MJD
 Norm min: 0.01551196351647377
Norm max: 1.0

Compute norm at a given time:

>>> from astropy.time import Time
>>> t = Time(59001.195, format="mjd")
>>> light_curve.evaluate(t)
<Quantity [0.02288737]>

Compute mean norm in a given time interval:

>>> import astropy.units as u
>>> t_r = Time(59000.5, format='mjd')
>>> t_min = t_r + [1, 4, 8] * u.d
>>> t_max = t_r + [1.5, 6, 9] * u.d
>>> light_curve.integral(t_min, t_max)
<Quantity [0.00375698, 0.0143724 , 0.00688029]>

Attributes Summary

`covariance`
`default_parameters`
`frozen`	Frozen status of a model, True if all parameters are frozen.
`is_energy_dependent`	Whether the model is energy dependent.
`parameters`	Parameters as a `Parameters` object.
`parameters_unique_names`
`reference_time`	Reference time in MJD.
`t_ref`	A model parameter.
`tag`
`type`

Methods Summary

`__call__`(time[, energy])	Evaluate model.
`copy`(**kwargs)	Deep copy.
`evaluate`(time[, t_ref, energy])	Evaluate the model at given coordinates.
`freeze`()	Freeze all parameters.
`from_dict`(data)	Create a temporal model from a dictionary.
`from_parameters`(parameters, **kwargs)	Create model from parameter list.
`from_table`(table[, filename])	Create a template model from an astropy table.
`integral`(t_min, t_max[, oversampling_factor])	Evaluate the integrated flux within the given time intervals.
`plot`(time_range[, ax, n_points, energy])	Plot the temporal model.
`read`(filename[, format])	Read a template model.
`reassign`(datasets_names, new_datasets_names)	Reassign a model from one dataset to another.
`sample_time`(n_events, t_min, t_max[, ...])	Sample arrival times of events.
`time_sum`(t_min, t_max)	Total time between t_min and t_max.
`to_dict`([full_output, format])	Create dictionary for YAML serialisation.
`to_table`()	Convert model to an astropy table.
`unfreeze`()	Restore parameters frozen status to default.
`write`(filename[, format, overwrite])	Write a model to disk as per the specified format.

Attributes Documentation

covariance#

default_parameters = <gammapy.modeling.parameter.Parameters object>#

frozen#: Frozen status of a model, True if all parameters are frozen.

is_energy_dependent#: Whether the model is energy dependent.

parameters#: Parameters as a Parameters object.

parameters_unique_names#

reference_time#: Reference time in MJD.

t_ref#

A model parameter.

Note that the parameter value has been split into a factor and scale like this:

value = factor x scale

Users should interact with the value, quantity or min and max properties and consider the fact that there is a factor` and scale an implementation detail.

That was introduced for numerical stability in parameter and error estimation methods, only in the Gammapy optimiser interface do we interact with the factor, factor_min and factor_max properties, i.e. the optimiser “sees” the well-scaled problem.

Parameters:

namestr: Name.
valuefloat or Quantity: Value.
scalefloat, optional: Scale (sometimes used in fitting).
unitUnit or str, optional: Unit.
minfloat, optional: Minimum (sometimes used in fitting).
maxfloat, optional: Maximum (sometimes used in fitting).
frozenbool, optional: Frozen (used in fitting).
errorfloat: Parameter error.
scan_minfloat: Minimum value for the parameter scan. Overwrites scan_n_sigma.
scan_maxfloat: Minimum value for the parameter scan. Overwrites scan_n_sigma.
scan_n_values: int: Number of values to be used for the parameter scan.
scan_n_sigmaint: Number of sigmas to scan.
scan_values: `numpy.array`: Scan values. Overwrites all the scan keywords before.
scale_method{‘scale10’, ‘factor1’, None}: Method used to set factor and scale.
interp{“lin”, “sqrt”, “log”}: Parameter scaling to use for the scan.
priorPrior: Prior set on the parameter.

tag = ['LightCurveTemplateTemporalModel', 'template']#

type#

Methods Documentation

__call__(time, energy=None)#

Evaluate model.

Parameters:

timeTime: Time object.
energyQuantity, optional: Energy. Default is None.

Returns:

valuesQuantity: Model values.

copy(**kwargs)#: Deep copy.

evaluate(time, t_ref=None, energy=None)[source]#

Evaluate the model at given coordinates.

Parameters:

time: `~astropy.time.Time`: Time.
t_ref: `~gammapy.modeling.Parameter`, optional: Reference time for the model. Default is None.
energy: `~astropy.units.Quantity`, optional: Energy. Default is None.

Returns:

valuesQuantity: Model values.

freeze()#: Freeze all parameters.

classmethod from_dict(data)[source]#

Create a temporal model from a dictionary.

Parameters:

datadict: Dictionary containing the model parameters.
**kwargsdict: Keyword arguments passed to from_parameters.

classmethod from_parameters(parameters, **kwargs)#

Create model from parameter list.

Parameters:

parametersParameters: Parameters for init.

Returns:

modelModel: Model instance.

classmethod from_table(table, filename=None)[source]#

Create a template model from an astropy table.

Parameters:

tableTable: Table containing the template model.
filenamestr, optional: Name of input file. Default is None.

Returns:

modelLightCurveTemplateTemporalModel: Light curve template model.

integral(t_min, t_max, oversampling_factor=100, **kwargs)[source]#

Evaluate the integrated flux within the given time intervals.

Parameters:

t_min: `~astropy.time.Time`: Start times of observation.
t_max: `~astropy.time.Time`: Stop times of observation.
oversampling_factorint, optional: Oversampling factor to be used for numerical integration. Default is 100.

Returns:

normfloat: Integrated flux norm on the given time intervals.

plot(time_range, ax=None, n_points=100, energy=None, **kwargs)[source]#

Plot the temporal model.

Parameters:

time_rangeTime: Times to plot the model.
axAxes, optional: Axis to plot on. Default is None.
n_pointsint, optional: Number of bins to plot model. Default is 100.
energyquantity, optional: Energies to compute the model at for energy dependent models. Default is None.
**kwargsdict: Keywords forwarded to errorbar.
Returns
——-
axAxes, optional: Matplotlib axes.

classmethod read(filename, format='table')[source]#

Read a template model.

Parameters:

filenamestr: Name of file to read.
format{“table”, “map”}: Format of the input file.

Returns:

modelLightCurveTemplateTemporalModel: Light curve template model.

reassign(datasets_names, new_datasets_names)#

Reassign a model from one dataset to another.

Parameters:

datasets_namesstr or list: Name of the datasets where the model is currently defined.
new_datasets_namesstr or list: Name of the datasets where the model should be defined instead. If multiple names are given the two list must have the save length, as the reassignment is element-wise.

Returns:

modelModel: Reassigned model.

sample_time(n_events, t_min, t_max, t_delta='1 s', random_state=0)#

Sample arrival times of events.

Parameters:

n_eventsint: Number of events to sample.
t_minTime: Start time of the sampling.
t_maxTime: Stop time of the sampling.
t_deltaQuantity, optional: Time step used for sampling of the temporal model. Default is 1 s.
random_state{int, ‘random-seed’, ‘global-rng’, RandomState}: Defines random number generator initialisation. Passed to get_random_state. Default is 0.

Returns:

timeQuantity: Array with times of the sampled events.

static time_sum(t_min, t_max)#

Total time between t_min and t_max.

Parameters:

t_min, t_maxTime: Lower and upper bound of integration range.

Returns:

time_sumTimeDelta: Summed time in the intervals.

to_dict(full_output=False, format=None)[source]#: Create dictionary for YAML serialisation.

to_table()[source]#: Convert model to an astropy table.

unfreeze()#: Restore parameters frozen status to default.

write(filename, format='table', overwrite=False)[source]#

Write a model to disk as per the specified format.

Parameters:

filenamestr: Name of output file.
format{“table” or “map”}: If format is “table”, it is serialised as a Table. If “map”, then it is serialised as a RegionNDMap. Default is “table”.
overwritebool, optional: Overwrite existing file. Default is False.