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()