LightCurveTemplateTemporalModel#

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

Bases: gammapy.modeling.models.temporal.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.5 MJD
Start time: 59000.5 MJD
End time: 61862.5 MJD
Norm min: 0.01551196351647377
Norm max: 1.0

Compute norm at a given time:

>>> t = Time(59001.195, format="mjd")
>>> light_curve.evaluate(t)
array(0.02287888)

Compute mean norm in a given time interval:

>>> from astropy.time import Time
>>> 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)
array([0.0074388942, 0.0071144081, 0.0068115544])

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 (`Parameters`)
`reference_time`	Reference time in mjd
`t_ref`	A model parameter.
`tag`
`type`

Methods Summary

`__call__`(time[, energy])	Evaluate model
`copy`(**kwargs)	A deep copy.
`evaluate`(time[, t_ref, energy])	Evaluate the model at given coordinates.
`freeze`()	Freeze all parameters
`from_dict`(data)
`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 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 dict 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 (Parameters)

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 of 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.
is_normbool: Whether the parameter represents the flux norm of the model.

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

type#

Methods Documentation

__call__(time, energy=None)#

Evaluate model

Parameters

timeTime: Time object
energyQuantity: Energy (optional)

Returns

valuesQuantity: Model values

copy(**kwargs)#: A deep copy.

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

Evaluate the model at given coordinates.

Parameters

time: `~astropy.time.Time`: array of times where the model is evaluated;
t_ref: `~gammapy.modeling.Parameter`: Reference time for the model;
energy: `~astropy.units.Quantity`: array of energies where the model is evaluated;

Returns

valuesQuantity: Model values

freeze()#: Freeze all parameters

classmethod from_dict(data)[source]#

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: Name of input file

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: Oversampling factor to be used for numerical integration.

Returns

normfloat: Integrated flux norm on the given time intervals

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

Plot Temporal Model.

Parameters

time_rangeTime: times to plot the model
axAxes, optional: Axis to plot on
n_pointsint: Number of bins to plot model
energyquantity: energies to compute the model at for energy dependent models, optional
**kwargsdict: Keywords forwarded to errorbar
Returns
——-
axAxes, optional: axis

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: Time step used for sampling of the temporal model.
random_state{int, ‘random-seed’, ‘global-rng’, RandomState}: Defines random number generator initialisation. Passed to get_random_state.

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='table')[source]#: Create dict 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
formatstr, either “table” or “map”: if format is table, it is serialised as an astropy Table if map, then it is serialised as a RegionNDMap
overwritebool: Overwrite file on disk if present