def test_spectrum_like_with_background_model():
energies = np.logspace(1, 3, 51)
low_edge = energies[:-1]
high_edge = energies[1:]
sim_K = 1E-1
sim_kT = 20.
# get a blackbody source function
source_function = Blackbody(K=sim_K, kT=sim_kT)
# power law background function
background_function = Powerlaw(K=5, index=-1.5, piv=100.)
spectrum_generator = SpectrumLike.from_function(
'fake',
source_function=source_function,
background_function=background_function,
energy_min=low_edge,
energy_max=high_edge)
background_plugin = SpectrumLike.from_background('background',
spectrum_generator)
bb = Blackbody()
pl = Powerlaw()
pl.piv = 100
bkg_ps = PointSource('bkg', 0, 0, spectral_shape=pl)
bkg_model = Model(bkg_ps)
jl_bkg = JointLikelihood(bkg_model, DataList(background_plugin))
_ = jl_bkg.fit()
plugin_bkg_model = SpectrumLike('full',
spectrum_generator.observed_spectrum,
background=background_plugin)
pts = PointSource('mysource', 0, 0, spectral_shape=bb)
model = Model(pts)
# MLE fitting
jl = JointLikelihood(model, DataList(plugin_bkg_model))
result = jl.fit()
K_variates = jl.results.get_variates('mysource.spectrum.main.Blackbody.K')
kT_variates = jl.results.get_variates(
'mysource.spectrum.main.Blackbody.kT')
assert np.all(
np.isclose([K_variates.average, kT_variates.average], [sim_K, sim_kT],
rtol=0.5))
def test_spectrum_like_with_background_model():
energies = np.logspace(1, 3, 51)
low_edge = energies[:-1]
high_edge = energies[1:]
sim_K = 1E-1
sim_kT = 20.
# get a blackbody source function
source_function = Blackbody(K=sim_K, kT=sim_kT)
# power law background function
background_function = Powerlaw(K=5, index=-1.5, piv=100.)
spectrum_generator = SpectrumLike.from_function('fake',
source_function=source_function,
background_function=background_function,
energy_min=low_edge,
energy_max=high_edge)
background_plugin = SpectrumLike.from_background('background',spectrum_generator)
bb = Blackbody()
pl = Powerlaw()
pl.piv = 100
bkg_ps = PointSource('bkg',0,0,spectral_shape=pl)
bkg_model = Model(bkg_ps)
jl_bkg = JointLikelihood(bkg_model,DataList(background_plugin))
_ = jl_bkg.fit()
plugin_bkg_model = SpectrumLike('full',spectrum_generator.observed_spectrum,background=background_plugin)
pts = PointSource('mysource', 0, 0, spectral_shape=bb)
model = Model(pts)
# MLE fitting
jl = JointLikelihood(model, DataList(plugin_bkg_model))
result = jl.fit()
K_variates = jl.results.get_variates('mysource.spectrum.main.Blackbody.K')
kT_variates = jl.results.get_variates('mysource.spectrum.main.Blackbody.kT')
assert np.all(np.isclose([K_variates.mean(), kT_variates.mean()], [sim_K, sim_kT], rtol=0.5))
def test_spectrum_constructor_no_background():
ebounds = ChannelSet.from_list_of_edges(np.array([0,1,2,3,4,5]))
obs_spectrum = BinnedSpectrum(counts=np.ones(len(ebounds)),exposure=1,ebounds=ebounds, is_poisson=True)
assert np.all(obs_spectrum.counts == obs_spectrum.rates)
specLike = SpectrumLike('fake', observation=obs_spectrum, background=None)
specLike.__repr__()
def test_spectrum_constructor_no_background():
ebounds = ChannelSet.from_list_of_edges(np.array([0, 1, 2, 3, 4, 5]))
obs_spectrum = BinnedSpectrum(counts=np.ones(len(ebounds)),
exposure=1,
ebounds=ebounds,
is_poisson=True)
assert np.all(obs_spectrum.counts == obs_spectrum.rates)
specLike = SpectrumLike("fake", observation=obs_spectrum, background=None)
specLike.__repr__()
def spectrum_addition(obs_spectrum_1,obs_spectrum_2,obs_spectrum_incompatible,addition,addition_proof):
obs_spectrum = addition(obs_spectrum_1, obs_spectrum_2)
addition_proof(obs_spectrum_1, obs_spectrum_2, obs_spectrum)
assert obs_spectrum_1.exposure + obs_spectrum_2.exposure == obs_spectrum.exposure
assert np.all(obs_spectrum.counts == obs_spectrum.rates * obs_spectrum.exposure)
specLike = SpectrumLike('fake', observation=obs_spectrum, background=None)
assert obs_spectrum.count_errors is None or obs_spectrum.count_errors.__class__ == np.ndarray
specLike.__repr__()
def spectrum_addition(obs_spectrum_1, obs_spectrum_2,
obs_spectrum_incompatible, addition, addition_proof):
obs_spectrum = addition(obs_spectrum_1, obs_spectrum_2)
addition_proof(obs_spectrum_1, obs_spectrum_2, obs_spectrum)
assert obs_spectrum_1.exposure + obs_spectrum_2.exposure == obs_spectrum.exposure
assert np.all(obs_spectrum.counts == obs_spectrum.rates *
obs_spectrum.exposure)
specLike = SpectrumLike('fake', observation=obs_spectrum, background=None)
assert obs_spectrum.count_errors is None or obs_spectrum.count_errors.__class__ == np.ndarray
specLike.__repr__()
def test_spectrumlike_fit():
energies = np.logspace(1, 3, 51)
low_edge = energies[:-1]
high_edge = energies[1:]
sim_K = 1e-1
sim_kT = 20.0
# get a blackbody source function
source_function = Blackbody(K=sim_K, kT=sim_kT)
# power law background function
background_function = Powerlaw(K=1, index=-1.5, piv=100.0)
spectrum_generator = SpectrumLike.from_function(
"fake",
source_function=source_function,
background_function=background_function,
energy_min=low_edge,
energy_max=high_edge,
)
bb = Blackbody()
pts = PointSource("mysource", 0, 0, spectral_shape=bb)
model = Model(pts)
# MLE fitting
jl = JointLikelihood(model, DataList(spectrum_generator))
result = jl.fit()
K_variates = jl.results.get_variates("mysource.spectrum.main.Blackbody.K")
kT_variates = jl.results.get_variates(
"mysource.spectrum.main.Blackbody.kT")
assert np.all(
np.isclose([K_variates.average, kT_variates.average], [sim_K, sim_kT],
atol=1))
def test_spectrumlike_fit():
energies = np.logspace(1, 3, 51)
low_edge = energies[:-1]
high_edge = energies[1:]
sim_K = 1E-1
sim_kT = 20.
# get a blackbody source function
source_function = Blackbody(K=sim_K, kT=sim_kT)
# power law background function
background_function = Powerlaw(K=1, index=-1.5, piv=100.)
spectrum_generator = SpectrumLike.from_function('fake',
source_function=source_function,
background_function=background_function,
energy_min=low_edge,
energy_max=high_edge)
bb = Blackbody()
pts = PointSource('mysource', 0, 0, spectral_shape=bb)
model = Model(pts)
# MLE fitting
jl = JointLikelihood(model, DataList(spectrum_generator))
result = jl.fit()
K_variates = jl.results.get_variates('mysource.spectrum.main.Blackbody.K')
kT_variates = jl.results.get_variates('mysource.spectrum.main.Blackbody.kT')
assert np.all(np.isclose([K_variates.mean(), kT_variates.mean()], [sim_K, sim_kT], atol=1 ))
def test_spectrum_constructor():
ebounds = ChannelSet.from_list_of_edges(np.array([1, 2, 3, 4, 5, 6]))
pl = Powerlaw()
ps = PointSource("fake", 0, 0, spectral_shape=pl)
model = Model(ps)
obs_spectrum = BinnedSpectrum(counts=np.ones(len(ebounds)),
exposure=1,
ebounds=ebounds,
is_poisson=True)
bkg_spectrum = BinnedSpectrum(counts=np.ones(len(ebounds)),
exposure=1,
ebounds=ebounds,
is_poisson=True)
assert np.all(obs_spectrum.counts == obs_spectrum.rates)
assert np.all(bkg_spectrum.counts == bkg_spectrum.rates)
specLike = SpectrumLike("fake",
observation=obs_spectrum,
background=bkg_spectrum)
specLike.set_model(model)
specLike.get_model()
specLike.get_simulated_dataset()
specLike.rebin_on_background(min_number_of_counts=1e-1)
specLike.remove_rebinning()
specLike.significance
specLike.significance_per_channel
obs_spectrum = BinnedSpectrum(
counts=np.ones(len(ebounds)),
count_errors=np.ones(len(ebounds)),
exposure=1,
ebounds=ebounds,
is_poisson=False,
)
bkg_spectrum = BinnedSpectrum(counts=np.ones(len(ebounds)),
exposure=1,
ebounds=ebounds,
is_poisson=True)
with pytest.raises(NotImplementedError):
specLike = SpectrumLike("fake",
observation=obs_spectrum,
background=bkg_spectrum)
# gaussian source only
obs_spectrum = BinnedSpectrum(
counts=np.ones(len(ebounds)),
count_errors=np.ones(len(ebounds)),
exposure=1,
ebounds=ebounds,
)
specLike = SpectrumLike("fake", observation=obs_spectrum, background=None)
specLike.set_model(model)
specLike.get_model()
specLike.get_simulated_dataset()
with pytest.raises(AssertionError):
specLike.rebin_on_background(min_number_of_counts=1e-1)
def test_all_statistics():
energies = np.logspace(1, 3, 51)
low_edge = energies[:-1]
high_edge = energies[1:]
# get a blackbody source function
source_function = Blackbody(K=9e-2, kT=20)
# power law background function
background_function = Powerlaw(K=1, index=-1.5, piv=100.0)
pts = PointSource("mysource", 0, 0, spectral_shape=source_function)
model = Model(pts)
# test Poisson no bkg
spectrum_generator = SpectrumLike.from_function(
"fake",
source_function=source_function,
energy_min=low_edge,
energy_max=high_edge,
)
spectrum_generator.set_model(model)
spectrum_generator.get_log_like()
# test Poisson w/ Poisson bkg
spectrum_generator = SpectrumLike.from_function(
"fake",
source_function=source_function,
background_function=background_function,
energy_min=low_edge,
energy_max=high_edge,
)
spectrum_generator.set_model(model)
spectrum_generator.get_log_like()
spectrum_generator._background_counts = -np.ones_like(
spectrum_generator._background_counts)
with pytest.raises(NegativeBackground):
spectrum_generator._probe_noise_models()
# test Poisson w/ ideal bkg
spectrum_generator.background_noise_model = "ideal"
spectrum_generator.get_log_like()
# test Poisson w/ gauss bkg
# test Poisson w/ Poisson bkg
spectrum_generator = SpectrumLike.from_function(
"fake",
source_function=source_function,
background_function=background_function,
background_errors=0.1 * background_function(low_edge),
energy_min=low_edge,
energy_max=high_edge,
)
spectrum_generator.set_model(model)
spectrum_generator.get_log_like()
# test Gaussian w/ no bkg
spectrum_generator = SpectrumLike.from_function(
"fake",
source_function=source_function,
source_errors=0.5 * source_function(low_edge),
energy_min=low_edge,
energy_max=high_edge,
)
spectrum_generator.set_model(model)
spectrum_generator.get_log_like()
def test_spectrum_like_with_background_model():
energies = np.logspace(1, 3, 51)
low_edge = energies[:-1]
high_edge = energies[1:]
sim_K = 1e-1
sim_kT = 20.0
# get a blackbody source function
source_function = Blackbody(K=sim_K, kT=sim_kT)
# power law background function
background_function = Powerlaw(K=5, index=-1.5, piv=100.0)
spectrum_generator = SpectrumLike.from_function(
"fake",
source_function=source_function,
background_function=background_function,
energy_min=low_edge,
energy_max=high_edge,
)
background_plugin = SpectrumLike.from_background("background",
spectrum_generator)
bb = Blackbody()
pl = Powerlaw()
pl.piv = 100
bkg_ps = PointSource("bkg", 0, 0, spectral_shape=pl)
bkg_model = Model(bkg_ps)
jl_bkg = JointLikelihood(bkg_model, DataList(background_plugin))
_ = jl_bkg.fit()
plugin_bkg_model = SpectrumLike("full",
spectrum_generator.observed_spectrum,
background=background_plugin)
pts = PointSource("mysource", 0, 0, spectral_shape=bb)
model = Model(pts)
# MLE fitting
jl = JointLikelihood(model, DataList(plugin_bkg_model))
result = jl.fit()
K_variates = jl.results.get_variates("mysource.spectrum.main.Blackbody.K")
kT_variates = jl.results.get_variates(
"mysource.spectrum.main.Blackbody.kT")
assert np.all(
np.isclose([K_variates.average, kT_variates.average], [sim_K, sim_kT],
rtol=0.5))
## test with ogiplike
with within_directory(__example_dir):
ogip = OGIPLike("test_ogip",
observation="test.pha{1}",
background=background_plugin)
def test_assigning_source_name():
energies = np.logspace(1, 3, 51)
low_edge = energies[:-1]
high_edge = energies[1:]
sim_K = 1e-1
sim_kT = 20.0
# get a blackbody source function
source_function = Blackbody(K=sim_K, kT=sim_kT)
# power law background function
background_function = Powerlaw(K=1, index=-1.5, piv=100.0)
spectrum_generator = SpectrumLike.from_function(
"fake",
source_function=source_function,
background_function=background_function,
energy_min=low_edge,
energy_max=high_edge,
)
# good name setting
bb = Blackbody()
pts = PointSource("good_name", 0, 0, spectral_shape=bb)
model = Model(pts)
# before setting model
spectrum_generator.assign_to_source("good_name")
jl = JointLikelihood(model, DataList(spectrum_generator))
_ = jl.fit()
# after setting model
pts = PointSource("good_name", 0, 0, spectral_shape=bb)
model = Model(pts)
spectrum_generator = SpectrumLike.from_function(
"fake",
source_function=source_function,
background_function=background_function,
energy_min=low_edge,
energy_max=high_edge,
)
jl = JointLikelihood(model, DataList(spectrum_generator))
spectrum_generator.assign_to_source("good_name")
# after with bad name
spectrum_generator = SpectrumLike.from_function(
"fake",
source_function=source_function,
background_function=background_function,
energy_min=low_edge,
energy_max=high_edge,
)
jl = JointLikelihood(model, DataList(spectrum_generator))
with pytest.raises(RuntimeError):
spectrum_generator.assign_to_source("bad_name")
# before with bad name
spectrum_generator = SpectrumLike.from_function(
"fake",
source_function=source_function,
background_function=background_function,
energy_min=low_edge,
energy_max=high_edge,
)
spectrum_generator.assign_to_source("bad_name")
with pytest.raises(RuntimeError):
jl = JointLikelihood(model, DataList(spectrum_generator))
# multisource model
spectrum_generator = SpectrumLike.from_function(
"fake",
source_function=source_function,
background_function=background_function,
energy_min=low_edge,
energy_max=high_edge,
)
ps1 = PointSource("ps1", 0, 0, spectral_shape=Blackbody())
ps2 = PointSource("ps2", 0, 0, spectral_shape=Powerlaw())
model = Model(ps1, ps2)
model.ps2.spectrum.main.Powerlaw.K.fix = True
model.ps2.spectrum.main.Powerlaw.index.fix = True
spectrum_generator.assign_to_source("ps1")
dl = DataList(spectrum_generator)
jl = JointLikelihood(model, dl)
_ = jl.fit()
def to_spectrumlike(self,
from_bins=False,
start=None,
stop=None,
interval_name='_interval',
extract_measured_background=False):
"""
Create plugin(s) from either the current active selection or the time bins.
If creating from an event list, the
bins are from create_time_bins. If using a pre-time binned time series, the bins are those
native to the data. Start and stop times can be used to control which bins are used.
:param from_bins: choose to create plugins from the time bins
:param start: optional start time of the bins
:param stop: optional stop time of the bins
:param extract_measured_background: Use the selected background rather than a polynomial fit to the background
:param interval_name: the name of the interval
:return: SpectrumLike plugin(s)
"""
# we can use either the modeled or the measured background. In theory, all the information
# in the background spectrum should propagate to the likelihood
if extract_measured_background:
this_background_spectrum = self._measured_background_spectrum
else:
this_background_spectrum = self._background_spectrum
# this is for a single interval
if not from_bins:
assert self._observed_spectrum is not None, 'Must have selected an active time interval'
assert isinstance(
self._observed_spectrum, BinnedSpectrum
), 'You are attempting to create a SpectrumLike plugin from the wrong data type'
if this_background_spectrum is None:
custom_warnings.warn(
'No background selection has been made. This plugin will contain no background!'
)
if self._response is None:
return SpectrumLike(name=self._name,
observation=self._observed_spectrum,
background=this_background_spectrum,
verbose=self._verbose,
tstart=self._tstart,
tstop=self._tstop)
else:
return DispersionSpectrumLike(
name=self._name,
observation=self._observed_spectrum,
background=this_background_spectrum,
verbose=self._verbose,
tstart=self._tstart,
tstop=self._tstop)
else:
# this is for a set of intervals.
assert self._time_series.bins is not None, 'This time series does not have any bins!'
# save the original interval if there is one
old_interval = copy.copy(self._active_interval)
old_verbose = copy.copy(self._verbose)
# we will keep it quiet to keep from being annoying
self._verbose = False
list_of_speclikes = []
# get the bins from the time series
# for event lists, these are from created bins
# for binned spectra sets, these are the native bines
these_bins = self._time_series.bins # type: TimeIntervalSet
if start is not None:
assert stop is not None, 'must specify a start AND a stop time'
if stop is not None:
assert stop is not None, 'must specify a start AND a stop time'
these_bins = these_bins.containing_interval(start,
stop,
inner=False)
# loop through the intervals and create spec likes
with progress_bar(len(these_bins), title='Creating plugins') as p:
for i, interval in enumerate(these_bins):
self.set_active_time_interval(interval.to_string())
assert isinstance(
self._observed_spectrum, BinnedSpectrum
), 'You are attempting to create a SpectrumLike plugin from the wrong data type'
if extract_measured_background:
this_background_spectrum = self._measured_background_spectrum
else:
this_background_spectrum = self._background_spectrum
if this_background_spectrum is None:
custom_warnings.warn(
'No bakckground selection has been made. This plugin will contain no background!'
)
try:
if self._response is None:
sl = SpectrumLike(
name="%s%s%d" % (self._name, interval_name, i),
observation=self._observed_spectrum,
background=this_background_spectrum,
verbose=self._verbose,
tstart=self._tstart,
tstop=self._tstop)
else:
sl = DispersionSpectrumLike(
name="%s%s%d" % (self._name, interval_name, i),
observation=self._observed_spectrum,
background=this_background_spectrum,
verbose=self._verbose,
tstart=self._tstart,
tstop=self._tstop)
list_of_speclikes.append(sl)
except (NegativeBackground):
custom_warnings.warn(
'Something is wrong with interval %s. skipping.' %
interval)
p.increase()
# restore the old interval
if old_interval is not None:
self.set_active_time_interval(*old_interval)
else:
self._active_interval = None
self._verbose = old_verbose
return list_of_speclikes
def test_spectrum_constructor():
ebounds = ChannelSet.from_list_of_edges(np.array([0,1,2,3,4,5]))
pl = Powerlaw()
ps = PointSource('fake',0,0,spectral_shape=pl)
model = Model(ps)
obs_spectrum = BinnedSpectrum(counts=np.ones(len(ebounds)),exposure=1,ebounds=ebounds, is_poisson=True)
bkg_spectrum = BinnedSpectrum(counts=np.ones(len(ebounds)),exposure=1,ebounds=ebounds, is_poisson=True)
assert np.all(obs_spectrum.counts == obs_spectrum.rates)
assert np.all(bkg_spectrum.counts == bkg_spectrum.rates)
specLike = SpectrumLike('fake', observation=obs_spectrum, background=bkg_spectrum)
specLike.set_model(model)
specLike.get_model()
specLike.get_simulated_dataset()
specLike.rebin_on_background(min_number_of_counts=1E-1)
specLike.remove_rebinning()
specLike.significance
specLike.significance_per_channel
obs_spectrum = BinnedSpectrum(counts=np.ones(len(ebounds)), count_errors=np.ones(len(ebounds)),exposure=1, ebounds=ebounds, is_poisson=False)
bkg_spectrum = BinnedSpectrum(counts=np.ones(len(ebounds)), exposure=1, ebounds=ebounds, is_poisson=True)
with pytest.raises(NotImplementedError):
specLike = SpectrumLike('fake', observation=obs_spectrum, background=bkg_spectrum)
# gaussian source only
obs_spectrum = BinnedSpectrum(counts=np.ones(len(ebounds)), count_errors=np.ones(len(ebounds)), exposure=1,
ebounds=ebounds)
specLike = SpectrumLike('fake', observation=obs_spectrum, background=None)
specLike.set_model(model)
specLike.get_model()
specLike.get_simulated_dataset()
with pytest.raises(AssertionError):
specLike.rebin_on_background(min_number_of_counts=1E-1)
def test_all_statistics():
energies = np.logspace(1, 3, 51)
low_edge = energies[:-1]
high_edge = energies[1:]
# get a blackbody source function
source_function = Blackbody(K=9E-2, kT=20)
# power law background function
background_function = Powerlaw(K=1, index=-1.5, piv=100.)
pts = PointSource('mysource', 0, 0, spectral_shape=source_function)
model = Model(pts)
# test Poisson no bkg
spectrum_generator = SpectrumLike.from_function('fake',
source_function=source_function,
energy_min=low_edge,
energy_max=high_edge)
spectrum_generator.set_model(model)
spectrum_generator.get_log_like()
# test Poisson w/ Poisson bkg
spectrum_generator = SpectrumLike.from_function('fake',
source_function=source_function,
background_function=background_function,
energy_min=low_edge,
energy_max=high_edge)
spectrum_generator.set_model(model)
spectrum_generator.get_log_like()
spectrum_generator._background_counts = -np.ones_like(spectrum_generator._background_counts)
with pytest.raises(NegativeBackground):
spectrum_generator._probe_noise_models()
# test Poisson w/ ideal bkg
spectrum_generator.background_noise_model = 'ideal'
spectrum_generator.get_log_like()
# test Poisson w/ gauss bkg
# test Poisson w/ Poisson bkg
spectrum_generator = SpectrumLike.from_function('fake',
source_function=source_function,
background_function=background_function,
background_errors=0.1 * background_function(low_edge),
energy_min=low_edge,
energy_max=high_edge)
spectrum_generator.set_model(model)
spectrum_generator.get_log_like()
# test Gaussian w/ no bkg
spectrum_generator = SpectrumLike.from_function('fake',
source_function=source_function,
source_errors=0.5 * source_function(low_edge),
energy_min=low_edge,
energy_max=high_edge)
spectrum_generator.set_model(model)
spectrum_generator.get_log_like()
def test_assigning_source_name():
energies = np.logspace(1, 3, 51)
low_edge = energies[:-1]
high_edge = energies[1:]
sim_K = 1E-1
sim_kT = 20.
# get a blackbody source function
source_function = Blackbody(K=sim_K, kT=sim_kT)
# power law background function
background_function = Powerlaw(K=1, index=-1.5, piv=100.)
spectrum_generator = SpectrumLike.from_function('fake',
source_function=source_function,
background_function=background_function,
energy_min=low_edge,
energy_max=high_edge)
# good name setting
bb = Blackbody()
pts = PointSource('good_name', 0, 0, spectral_shape=bb)
model = Model(pts)
# before setting model
spectrum_generator.assign_to_source('good_name')
jl = JointLikelihood(model, DataList(spectrum_generator))
_ = jl.fit()
# after setting model
pts = PointSource('good_name', 0, 0, spectral_shape=bb)
model = Model(pts)
spectrum_generator = SpectrumLike.from_function('fake',
source_function=source_function,
background_function=background_function,
energy_min=low_edge,
energy_max=high_edge)
jl = JointLikelihood(model, DataList(spectrum_generator))
spectrum_generator.assign_to_source('good_name')
# after with bad name
spectrum_generator = SpectrumLike.from_function('fake',
source_function=source_function,
background_function=background_function,
energy_min=low_edge,
energy_max=high_edge)
jl = JointLikelihood(model, DataList(spectrum_generator))
with pytest.raises(AssertionError):
spectrum_generator.assign_to_source('bad_name')
# before with bad name
spectrum_generator = SpectrumLike.from_function('fake',
source_function=source_function,
background_function=background_function,
energy_min=low_edge,
energy_max=high_edge)
spectrum_generator.assign_to_source('bad_name')
with pytest.raises(AssertionError):
jl = JointLikelihood(model, DataList(spectrum_generator))
#multisource model
spectrum_generator = SpectrumLike.from_function('fake',
source_function=source_function,
background_function=background_function,
energy_min=low_edge,
energy_max=high_edge)
ps1 = PointSource('ps1', 0, 0, spectral_shape=Blackbody())
ps2 = PointSource('ps2', 0, 0, spectral_shape=Powerlaw())
model = Model(ps1, ps2)
model.ps2.spectrum.main.Powerlaw.K.fix = True
model.ps2.spectrum.main.Powerlaw.index.fix = True
spectrum_generator.assign_to_source('ps1')
dl = DataList(spectrum_generator)
jl = JointLikelihood(model, dl)
_ = jl.fit()
