def fit_coeffs(method='simplex'):
method = method
dummy_data = np.zeros(100)
dummy_times = np.arange(100)
ui.load_arrays(1, dummy_times, dummy_data)
ui.set_method(method)
ui.get_method().config.update(SHERPA_CONFIGS.get(method, {}))
calc_model = CalcModel()
ui.load_user_model(calc_model, 'axo_mod') # sets global axo_mod
parnames = []
for row in range(N_ROWS):
for col in range(N_COLS):
parnames.append('adj_{}_{}'.format(row, col))
ui.add_user_pars('axo_mod', parnames)
ui.set_model(1, 'axo_mod')
calc_stat = CalcStat(axo_mod, M_2d, displ_x)
ui.load_user_stat('axo_stat', calc_stat, lambda x: np.ones_like(x))
ui.set_stat(axo_stat)
calc_model.set_calc_stat(calc_stat)
# Set frozen, min, and max attributes for each axo_mod parameter
for par in axo_mod.pars:
par.val = 0.0
par.min = -5
par.max = 5
ui.fit(1)
coeffs = np.array([(par.val) for pars in axo_mod.pars])
return coeffs
def fit_coeffs(method='simplex'):
method = method
dummy_data = np.zeros(100)
dummy_times = np.arange(100)
ui.load_arrays(1, dummy_times, dummy_data)
ui.set_method(method)
ui.get_method().config.update(SHERPA_CONFIGS.get(method, {}))
calc_model = CalcModel()
ui.load_user_model(calc_model, 'axo_mod') # sets global axo_mod
parnames = []
for row in range(N_ROWS):
for col in range(N_COLS):
parnames.append('adj_{}_{}'.format(row, col))
ui.add_user_pars('axo_mod', parnames)
ui.set_model(1, 'axo_mod')
calc_stat = CalcStat(axo_mod, M_2d, displ_x)
ui.load_user_stat('axo_stat', calc_stat, lambda x: np.ones_like(x))
ui.set_stat(axo_stat)
calc_model.set_calc_stat(calc_stat)
# Set frozen, min, and max attributes for each axo_mod parameter
for par in axo_mod.pars:
par.val = 0.0
par.min = -5
par.max = 5
ui.fit(1)
coeffs = np.array([(par.val) for pars in axo_mod.pars])
return coeffs
def match_wcs(wcs_img, sky_img, sky_ref, opt_alg='scipy'):
"""Adjust ``wcs_img`` (CRVAL{1,2} and CD{1,2}_{1,2}) using a rotation and linear
offset so that ``coords_img`` matches ``coords_ref``.
:param sky_img: list of (world_x, world_y) [aka RA, Dec] coords in input image
:param sky_ref: list of reference (world_x, world_y) coords to match
:param wcs_img: pywcs WCS object for input image
:returns: d_ra, d_dec, d_theta
"""
pix_img = wcs_img.wcs_sky2pix(sky_img, 1)
wcsmodel = WcsModel(wcs_img, sky_ref, pix_img)
y = np.array(pix_img).flatten()
if opt_alg == 'sherpa':
x = np.arange(len(y))
import sherpa.astro.ui as ui
ui.load_user_model(wcsmodel.calc_pix, 'wcsmod')
ui.add_user_pars('wcsmod', ['d_ra', 'd_dec', 'd_theta'])
wcsmod.d_ra = 0.0
wcsmod.d_dec = 0.0
wcsmod.d_theta = 0.0
ui.load_arrays(1, x, y, np.ones(len(y)))
ui.set_model(1, wcsmod)
ui.set_method('simplex')
ui.fit()
else:
import scipy.optimize
x0 = np.array([0.0, 0.0, 0.0])
d_ra, d_dec, d_theta = scipy.optimize.fmin(wcsmodel.calc_resid2, x0)
print 'Scipy fit values:', d_ra, d_dec, d_theta
return wcsmodel.wcs
def test_background():
tmpdir = tempfile.mkdtemp()
curdir = os.getcwd()
os.chdir(tmpdir)
kT_sim = 1.0
Z_sim = 0.0
norm_sim = 4.0e-2
nH_sim = 0.04
redshift = 0.01
exp_time = (200., "ks")
area = (1000., "cm**2")
wcs = create_dummy_wcs()
abs_model = WabsModel(nH_sim)
events = EventList.create_empty_list(exp_time, area, wcs)
spec_model = TableApecModel(0.05, 12.0, 5000, thermal_broad=False)
spec = spec_model.return_spectrum(kT_sim, Z_sim, redshift, norm_sim)
new_events = events.add_background(spec_model.ebins, spec, prng=prng,
absorb_model=abs_model)
new_events = ACIS_I(new_events, rebin=False, convolve_psf=False, prng=prng)
new_events.write_spectrum("background_evt.pi", clobber=True)
os.system("cp %s ." % new_events.parameters["ARF"])
os.system("cp %s ." % new_events.parameters["RMF"])
load_user_model(mymodel, "wapec")
add_user_pars("wapec", ["nH", "kT", "metallicity", "redshift", "norm"],
[0.01, 4.0, 0.2, redshift, norm_sim*0.8],
parmins=[0.0, 0.1, 0.0, -20.0, 0.0],
parmaxs=[10.0, 20.0, 10.0, 20.0, 1.0e9],
parfrozen=[False, False, False, True, False])
load_pha("background_evt.pi")
set_stat("cstat")
set_method("simplex")
ignore(":0.5, 8.0:")
set_model("wapec")
fit()
set_covar_opt("sigma", 1.6)
covar()
res = get_covar_results()
assert np.abs(res.parvals[0]-nH_sim) < res.parmaxes[0]
assert np.abs(res.parvals[1]-kT_sim) < res.parmaxes[1]
assert np.abs(res.parvals[2]-Z_sim) < res.parmaxes[2]
assert np.abs(res.parvals[3]-norm_sim) < res.parmaxes[3]
os.chdir(curdir)
shutil.rmtree(tmpdir)
def test_background():
tmpdir = tempfile.mkdtemp()
curdir = os.getcwd()
os.chdir(tmpdir)
kT_sim = 1.0
Z_sim = 0.0
norm_sim = 4.0e-2
nH_sim = 0.04
redshift = 0.01
exp_time = (200., "ks")
area = (1000., "cm**2")
fov = (10.0, "arcmin")
prng = 24
agen = ApecGenerator(0.05, 12.0, 5000, broadening=False)
spec = agen.get_spectrum(kT_sim, Z_sim, redshift, norm_sim)
spec.apply_foreground_absorption(norm_sim)
events = make_background(area, exp_time, fov, (30.0, 45.0), spec, prng=prng)
events.write_simput_file("bkgnd", overwrite=True)
instrument_simulator("bkgnd_simput.fits", "bkgnd_evt.fits",
exp_time, "sq_acisi_cy19", [30.0, 45.0],
overwrite=True, foreground=False, ptsrc_bkgnd=False,
instr_bkgnd=False,
prng=prng)
write_spectrum("bkgnd_evt.fits", "background_evt.pi", overwrite=True)
os.system("cp %s %s ." % (arf.filename, rmf.filename))
load_user_model(mymodel, "wapec")
add_user_pars("wapec", ["nH", "kT", "metallicity", "redshift", "norm"],
[0.01, 4.0, 0.2, redshift, norm_sim*0.8],
parmins=[0.0, 0.1, 0.0, -20.0, 0.0],
parmaxs=[10.0, 20.0, 10.0, 20.0, 1.0e9],
parfrozen=[False, False, False, True, False])
load_pha("background_evt.pi")
set_stat("cstat")
set_method("simplex")
ignore(":0.5, 8.0:")
set_model("wapec")
fit()
res = get_fit_results()
assert np.abs(res.parvals[0]-nH_sim)/nH_sim < 0.1
assert np.abs(res.parvals[1]-kT_sim)/kT_sim < 0.05
assert np.abs(res.parvals[2]-Z_sim) < 0.05
assert np.abs(res.parvals[3]-norm_sim)/norm_sim < 0.05
os.chdir(curdir)
shutil.rmtree(tmpdir)
def test_point_source():
tmpdir = tempfile.mkdtemp()
curdir = os.getcwd()
os.chdir(tmpdir)
nH_sim = 0.02
norm_sim = 1.0e-4
alpha_sim = 0.95
redshift = 0.02
exp_time = (100., "ks")
area = (3000., "cm**2")
spec = Spectrum.from_powerlaw(alpha_sim, redshift, norm_sim,
emin=0.1, emax=11.5, nbins=2000)
spec.apply_foreground_absorption(nH_sim, model="tbabs")
positions = [(30.01, 45.0)]
events = make_point_sources(area, exp_time, positions, (30.0, 45.0),
spec, prng=prng)
events.write_simput_file("ptsrc", overwrite=True)
instrument_simulator("ptsrc_simput.fits", "ptsrc_evt.fits",
exp_time, "sq_aciss_cy20", [30.0, 45.0],
overwrite=True, foreground=False, ptsrc_bkgnd=False,
instr_bkgnd=False,
prng=prng)
write_spectrum("ptsrc_evt.fits", "point_source_evt.pi", overwrite=True)
os.system("cp %s %s ." % (arf.filename, rmf.filename))
load_user_model(mymodel, "tplaw")
add_user_pars("tplaw", ["nH", "norm", "redshift", "alpha"],
[0.02, norm_sim*0.8, redshift, 0.9],
parmins=[0.0, 0.0, 0.0, 0.1],
parmaxs=[10.0, 1.0e9, 10.0, 10.0],
parfrozen=[True, False, True, False])
load_pha("point_source_evt.pi")
set_stat("cstat")
set_method("simplex")
ignore(":0.4, 9.0:")
set_model("tplaw")
fit()
res = get_fit_results()
assert np.abs(res.parvals[0]-norm_sim)/norm_sim < 0.05
assert np.abs(res.parvals[1]-alpha_sim)/alpha_sim < 0.05
os.chdir(curdir)
shutil.rmtree(tmpdir)
def test_point_source():
tmpdir = tempfile.mkdtemp()
curdir = os.getcwd()
os.chdir(tmpdir)
nH_sim = 0.02
norm_sim = 1.0e-4
alpha_sim = 0.95
redshift = 0.02
exp_time = (100., "ks")
area = (3000., "cm**2")
spec = Spectrum.from_powerlaw(alpha_sim, redshift, norm_sim,
emin=0.1, emax=11.5, nbins=2000)
spec.apply_foreground_absorption(nH_sim, model="tbabs")
positions = [(30.01, 45.0)]
events = make_point_sources(area, exp_time, positions, (30.0, 45.0),
spec, prng=prng)
events.write_simput_file("ptsrc", overwrite=True)
instrument_simulator("ptsrc_simput.fits", "ptsrc_evt.fits",
exp_time, "sq_aciss_cy19", [30.0, 45.0],
overwrite=True, foreground=False, ptsrc_bkgnd=False,
instr_bkgnd=False,
prng=prng)
write_spectrum("ptsrc_evt.fits", "point_source_evt.pi", overwrite=True)
os.system("cp %s %s ." % (arf.filename, rmf.filename))
load_user_model(mymodel, "tplaw")
add_user_pars("tplaw", ["nH", "norm", "redshift", "alpha"],
[0.02, norm_sim*0.8, redshift, 0.9],
parmins=[0.0, 0.0, 0.0, 0.1],
parmaxs=[10.0, 1.0e9, 10.0, 10.0],
parfrozen=[True, False, True, False])
load_pha("point_source_evt.pi")
set_stat("cstat")
set_method("simplex")
ignore(":0.4, 9.0:")
set_model("tplaw")
fit()
res = get_fit_results()
assert np.abs(res.parvals[0]-norm_sim)/norm_sim < 0.05
assert np.abs(res.parvals[1]-alpha_sim)/alpha_sim < 0.05
os.chdir(curdir)
shutil.rmtree(tmpdir)
def fit_adjuster_set(coeffs, adj_idxs, method='simplex'):
"""
Find best fit parameters for an arbitrary subset of adjustors
specified by the array ``adj_idxs``. The input ``coeffs`` are
the best-fit adjustor coefficients for the last iteration.
"""
import sherpa.astro.ui as ui
dummy_data = np.zeros(100)
dummy_times = np.arange(100)
ui.load_arrays(1, dummy_times, dummy_data)
ui.set_method(method)
ui.get_method().config.update(SHERPA_CONFIGS.get(method, {}))
calc_model = CalcModel()
ui.load_user_model(calc_model, 'axo_mod') # sets global axo_mod
parnames = []
for adj_idx in adj_idxs:
parnames.append('adj_{}'.format(adj_idx))
ui.add_user_pars('axo_mod', parnames)
ui.set_model(1, 'axo_mod')
coeffs = coeffs.copy() # Don't modify input coeffs
coeffs[coeffs < 0] = 0 # Don't allow negative coeffs
# Set frozen, min, and max attributes for each axo_mod parameter
for adj_idx, par in zip(adj_idxs, axo_mod.pars):
par.min = -1000
par.max = 1000
par.val = coeffs[adj_idx]
print 'Setting {} to {}'.format(adj_idx, par.val)
# Compute base adjusted displacements assuming all the fitted actuators
# have zero drive level.
coeffs[adj_idxs] = 0
base_adj_displ = M_2d.dot(coeffs)
m_2d = M_2d[:, adj_idxs].copy()
print m_2d.shape
calc_stat = CalcStat(base_adj_displ, m_2d, DISPL_X)
ui.load_user_stat('axo_stat', calc_stat, lambda x: np.ones_like(x))
ui.set_stat(axo_stat)
calc_model.set_calc_stat(calc_stat)
ui.fit(1)
# Update coeffs with the values determined in fitting
for adj_idx, par in zip(adj_idxs, axo_mod.pars):
coeffs[adj_idx] = abs(par.val)
return coeffs, ui.get_fit_results()
def test_user_model_stat_docs():
"""
This test reproduces the documentation shown at:
http://cxc.harvard.edu/sherpa4.4/statistics/#userstat
and:
http://cxc.harvard.edu/sherpa/threads/user_model/
I tried to be as faithful as possible to the original, although the examples in thedocs
are not completely self-contained, so some changes were necessary. I changed the numpy
reference, as it is imported as `np` here, and added a clean up of the environment
before doing anything.
For the model, the difference is that I am not importing the function from an
external module, plus the dataset is different.
Also, the stats docs do not perform a fit.
"""
def my_stat_func(data, model, staterror, syserror=None, weight=None):
# A simple function to replicate χ2
fvec = ((data - model) / staterror)**2
stat = fvec.sum()
return (stat, fvec)
def my_staterr_func(data):
# A simple staterror function
return np.sqrt(data)
def myline(pars, x):
return pars[0]*x + pars[1]
x = [1, 2, 3]
y = [4, 5, 6.01]
ui.clean()
ui.load_arrays(1, x, y)
ui.load_user_stat("mystat", my_stat_func, my_staterr_func)
ui.set_stat(eval('mystat'))
ui.load_user_model(myline, "myl")
ui.add_user_pars("myl", ["m", "b"])
ui.set_model(eval('myl'))
ui.fit()
assert ui.get_par("myl.m").val == approx(1, abs=0.01)
assert ui.get_par("myl.b").val == approx(3, abs=0.01)
def plaw_fit(alpha_sim):
tmpdir = tempfile.mkdtemp()
curdir = os.getcwd()
os.chdir(tmpdir)
nH_sim = 0.02
norm_sim = 1.0e-4
redshift = 0.01
exp_time = 5.0e4
area = 40000.0
inst_name = "hdxi"
spec = Spectrum.from_powerlaw(alpha_sim, redshift, norm_sim)
spec.apply_foreground_absorption(nH_sim)
e = spec.generate_energies(exp_time, area)
pt_src = PointSourceModel(30.0, 45.0, e.size)
write_photon_list("plaw_model",
"plaw_model",
e.flux,
pt_src.ra,
pt_src.dec,
e,
clobber=True)
instrument_simulator("plaw_model_simput.fits",
"plaw_model_evt.fits",
exp_time,
inst_name, [30.0, 45.0],
astro_bkgnd=None,
instr_bkgnd_scale=0.0)
inst = get_instrument_from_registry(inst_name)
arf = AuxiliaryResponseFile(inst["arf"])
rmf = RedistributionMatrixFile(inst["rmf"])
os.system("cp %s ." % arf.filename)
os.system("cp %s ." % rmf.filename)
write_spectrum("plaw_model_evt.fits", "plaw_model_evt.pha", clobber=True)
load_user_model(mymodel, "wplaw")
add_user_pars("wplaw", ["nH", "norm", "redshift", "alpha"],
[0.01, norm_sim * 0.8, redshift, 0.9],
parmins=[0.0, 0.0, 0.0, 0.1],
parmaxs=[10.0, 1.0e9, 10.0, 10.0],
parfrozen=[False, False, True, False])
load_pha("plaw_model_evt.pha")
set_stat("cstat")
set_method("simplex")
ignore(":0.5, 9.0:")
set_model("wplaw")
fit()
set_covar_opt("sigma", 1.645)
covar()
res = get_covar_results()
assert np.abs(res.parvals[0] - nH_sim) < res.parmaxes[0]
assert np.abs(res.parvals[1] - norm_sim) < res.parmaxes[1]
assert np.abs(res.parvals[2] - alpha_sim) < res.parmaxes[2]
os.chdir(curdir)
shutil.rmtree(tmpdir)
def test_user_model_fits_table(self):
ui.load_user_model(self.func, 'mdl', self.singletbl)
ui.load_user_model(self.func, 'mdl', self.doubletbl)
def plaw_fit(alpha_sim):
tmpdir = tempfile.mkdtemp()
curdir = os.getcwd()
os.chdir(tmpdir)
bms = BetaModelSource()
ds = bms.ds
def _hard_emission(field, data):
return YTQuantity(1.0e-18, "s**-1*keV**-1")*data["density"]*data["cell_volume"]/mp
ds.add_field(("gas", "hard_emission"), function=_hard_emission, units="keV**-1*s**-1")
nH_sim = 0.02
abs_model = WabsModel(nH_sim)
A = YTQuantity(2000., "cm**2")
exp_time = YTQuantity(2.0e5, "s")
redshift = 0.01
sphere = ds.sphere("c", (100.,"kpc"))
plaw_model = PowerLawSourceModel(1.0, 0.01, 11.0, "hard_emission",
alpha_sim, prng=prng)
photons = PhotonList.from_data_source(sphere, redshift, A, exp_time,
plaw_model)
D_A = photons.parameters["FiducialAngularDiameterDistance"]
dist_fac = 1.0/(4.*np.pi*D_A*D_A*(1.+redshift)**3).in_cgs()
norm_sim = float((sphere["hard_emission"]).sum()*dist_fac.in_cgs())*(1.+redshift)
events = photons.project_photons("z", absorb_model=abs_model,
prng=bms.prng,
no_shifting=True)
events = ACIS_I(events, rebin=False, convolve_psf=False, prng=bms.prng)
events.write_spectrum("plaw_model_evt.pi", clobber=True)
os.system("cp %s ." % events.parameters["ARF"])
os.system("cp %s ." % events.parameters["RMF"])
load_user_model(mymodel, "wplaw")
add_user_pars("wplaw", ["nH", "norm", "redshift", "alpha"],
[0.01, norm_sim*1.1, redshift, 0.9],
parmins=[0.0, 0.0, 0.0, 0.1],
parmaxs=[10.0, 1.0e9, 10.0, 10.0],
parfrozen=[False, False, True, False])
load_pha("plaw_model_evt.pi")
set_stat("cstat")
set_method("simplex")
ignore(":0.6, 7.0:")
set_model("wplaw")
fit()
set_covar_opt("sigma", 1.645)
covar()
res = get_covar_results()
assert np.abs(res.parvals[0]-nH_sim) < res.parmaxes[0]
assert np.abs(res.parvals[1]-norm_sim) < res.parmaxes[1]
assert np.abs(res.parvals[2]-alpha_sim) < res.parmaxes[2]
os.chdir(curdir)
shutil.rmtree(tmpdir)
def test_ui_user_model_fits_table(setup_files):
ui.load_user_model(identity, 'mdl', setup_files.singletbl)
ui.load_user_model(identity, 'mdl', setup_files.doubletbl)
import numpy as np
import sherpa.astro.ui as ui
from bb import BoxBOD, report_results
# Load data
ui.load_arrays(1, BoxBOD.x, BoxBOD.y, np.ones_like(BoxBOD.x))
# @todo: It is possible to give no staterror, but I'm not sure
# what Sherpa does then. fr.statval is no longer the correct chi2.
# Set up the model and load it as a Sherpa model
def boxbod_func(pars, x):
b1, b2 = pars
return BoxBOD.model(x, b1, b2)
ui.load_user_model(boxbod_func, "boxbod")
ui.add_user_pars("boxbod", ["b1", "b2"])
bb = boxbod
ui.set_model(bb)
bb.b1, bb.b2 = BoxBOD.p0[0], BoxBOD.p0[1]
# Perform fit
ui.set_stat('chi2datavar')
#ui.set_method('levmar') # ['levmar', 'moncar', 'neldermead', 'simplex']
ui.set_method_opt('xtol', 1e-10)
ui.fit() # Compute best-fit parameters
ui.set_covar_opt('eps', 1e-5) # @todo: Why does this parameter have no effect
ui.covariance() # Compute covariance matrix (i.e. errors)
#ui.conf() # Compute profile errors
#ui.show_all() # Print a very nice summary of your session to less
# Report results
def test_user_model_fits_table(self):
ui.load_user_model(self.func, 'mdl', self.singletbl)
ui.load_user_model(self.func, 'mdl', self.doubletbl)
def plaw_fit(alpha_sim, prng=None):
tmpdir = tempfile.mkdtemp()
curdir = os.getcwd()
os.chdir(tmpdir)
bms = BetaModelSource()
ds = bms.ds
if prng is None:
prng = bms.prng
def _hard_emission(field, data):
return YTQuantity(
1.0e-18,
"s**-1*keV**-1") * data["density"] * data["cell_volume"] / mp
ds.add_field(("gas", "hard_emission"),
function=_hard_emission,
units="keV**-1*s**-1")
nH_sim = 0.02
A = YTQuantity(2000., "cm**2")
exp_time = YTQuantity(2.0e5, "s")
redshift = 0.01
sphere = ds.sphere("c", (100., "kpc"))
plaw_model = PowerLawSourceModel(1.0,
0.01,
11.0,
"hard_emission",
alpha_sim,
prng=prng)
photons = PhotonList.from_data_source(sphere, redshift, A, exp_time,
plaw_model)
D_A = photons.parameters["fid_d_a"]
dist_fac = 1.0 / (4. * np.pi * D_A * D_A * (1. + redshift)**3).in_cgs()
norm_sim = float(
(sphere["hard_emission"]).sum() * dist_fac.in_cgs()) * (1. + redshift)
events = photons.project_photons("z", [30., 45.],
absorb_model="wabs",
nH=nH_sim,
prng=bms.prng,
no_shifting=True)
events.write_simput_file("plaw", overwrite=True)
instrument_simulator("plaw_simput.fits",
"plaw_evt.fits",
exp_time,
"sq_acisi_cy19", [30.0, 45.0],
overwrite=True,
foreground=False,
ptsrc_bkgnd=False,
instr_bkgnd=False,
prng=prng)
write_spectrum("plaw_evt.fits", "plaw_model_evt.pi", overwrite=True)
os.system("cp %s %s ." % (arf.filename, rmf.filename))
load_user_model(mymodel, "wplaw")
add_user_pars("wplaw", ["nH", "norm", "redshift", "alpha"],
[0.01, norm_sim * 1.1, redshift, 0.9],
parmins=[0.0, 0.0, 0.0, 0.1],
parmaxs=[10.0, 1.0e9, 10.0, 10.0],
parfrozen=[False, False, True, False])
load_pha("plaw_model_evt.pi")
set_stat("cstat")
set_method("simplex")
ignore(":0.6, 7.0:")
set_model("wplaw")
fit()
res = get_fit_results()
assert np.abs(res.parvals[0] - nH_sim) / nH_sim < 0.1
assert np.abs(res.parvals[1] - norm_sim) / norm_sim < 0.05
assert np.abs(res.parvals[2] - alpha_sim) / alpha_sim < 0.05
os.chdir(curdir)
shutil.rmtree(tmpdir)
self.min_parvals = self.parvals
return fit_stat, np.ones_like(self.displ)
# def fit(method='levmar'):
method = "simplex"
dummy_data = np.zeros(100)
dummy_times = np.arange(100)
ui.load_arrays(1, dummy_times, dummy_data)
ui.set_method(method)
ui.get_method().config.update(SHERPA_CONFIGS.get(method, {}))
calc_model = CalcModel()
ui.load_user_model(calc_model, "axo_mod") # sets global axo_mod
parnames = []
for row in range(N_ROWS):
for col in range(N_COLS):
parnames.append("adj_{}_{}".format(row, col))
ui.add_user_pars("axo_mod", parnames)
ui.set_model(1, "axo_mod")
calc_stat = CalcStat(axo_mod, M_2d, displ_x)
ui.load_user_stat("axo_stat", calc_stat, lambda x: np.ones_like(x))
ui.set_stat(axo_stat)
calc_model.set_calc_stat(calc_stat)
# Set frozen, min, and max attributes for each axo_mod parameter
for par in axo_mod.pars:
def test_user_model_ascii_table(self):
ui.load_user_model(self.func, 'mdl', self.singledat)
ui.load_user_model(self.func, 'mdl', self.doubledat)
def do_beta_model(source, v_field, em_field, axis="z",
prng=None):
tmpdir = tempfile.mkdtemp()
curdir = os.getcwd()
os.chdir(tmpdir)
if prng is None:
prng = source.prng
ds = source.ds
A = 30000.
exp_time = 1.0e4
redshift = 0.05
nH_sim = 0.02
sphere = ds.sphere("c", (0.5, "Mpc"))
kT_sim = source.kT
Z_sim = source.Z
thermal_model = ThermalSourceModel("apec", 0.1, 11.5, 20000,
Zmet=Z_sim, prng=prng)
photons = PhotonList.from_data_source(sphere, redshift, A, exp_time,
thermal_model)
D_A = photons.parameters["fid_d_a"]
norm_sim = sphere.quantities.total_quantity(em_field)
norm_sim *= 1.0e-14/(4*np.pi*D_A*D_A*(1.+redshift)*(1.+redshift))
norm_sim = float(norm_sim.in_cgs())
v1, v2 = sphere.quantities.weighted_variance(v_field, em_field)
if isinstance(axis, string_types):
if axis == "z":
fac = 1.0
else:
fac = 0.0
else:
axis /= np.sqrt(np.dot(axis, axis))
fac = np.dot(axis, [0.0, 0.0, 1.0])
sigma_sim = fac*float(v1.in_units("km/s"))
mu_sim = -fac*float(v2.in_units("km/s"))
events = photons.project_photons(axis, [30.0, 45.0], absorb_model="tbabs",
nH=nH_sim, prng=prng)
events.write_simput_file("beta_model", overwrite=True)
instrument_simulator("beta_model_simput.fits", "beta_model_evt.fits",
exp_time, "mucal", [30.0, 45.0],
overwrite=True, foreground=False, ptsrc_bkgnd=False,
instr_bkgnd=False,
prng=prng)
write_spectrum("beta_model_evt.fits", "beta_model_evt.pi", overwrite=True)
os.system("cp %s %s ." % (arf.filename, rmf.filename))
load_user_model(mymodel, "tbapec")
add_user_pars("tbapec", ["nH", "kT", "metallicity", "redshift", "norm", "velocity"],
[0.02, 4.0, 0.2, 0.04, norm_sim*0.8, 300.0],
parmins=[0.0, 0.1, 0.0, -200.0, 0.0, 0.0],
parmaxs=[10.0, 20.0, 10.0, 200.0, 1.0e9, 20000.0],
parfrozen=[True, False, False, False, False, False])
load_pha("beta_model_evt.pi")
set_stat("cstat")
set_method("levmar")
ignore(":0.6, 8.0:")
set_model("tbapec")
fit()
res = get_fit_results()
redshift_sim = (1.0+mu_sim/ckms)*(1.0+redshift) - 1.0
assert np.abs(res.parvals[0]-kT_sim)/kT_sim < 0.05
assert np.abs(res.parvals[1]-Z_sim)/Z_sim < 0.05
assert np.abs(res.parvals[2]-redshift_sim)/redshift_sim < 0.05
assert np.abs(res.parvals[3]-norm_sim) < 0.05
assert np.abs(res.parvals[4]-sigma_sim) < 30.0
os.chdir(curdir)
shutil.rmtree(tmpdir)
def do_beta_model(source, v_field, em_field):
tmpdir = tempfile.mkdtemp()
curdir = os.getcwd()
os.chdir(tmpdir)
ds = source.ds
A = 3000.
exp_time = 1.0e5
redshift = 0.05
nH_sim = 0.02
apec_model = TableApecModel(0.1, 11.5, 20000, thermal_broad=False)
abs_model = TBabsModel(nH_sim)
sphere = ds.sphere("c", (0.5, "Mpc"))
kT_sim = source.kT
Z_sim = source.Z
thermal_model = ThermalSourceModel(apec_model,
Zmet=Z_sim,
prng=source.prng)
photons = PhotonList.from_data_source(sphere, redshift, A, exp_time,
thermal_model)
D_A = photons.parameters["FiducialAngularDiameterDistance"]
norm_sim = sphere.quantities.total_quantity(em_field)
norm_sim *= 1.0e-14 / (4 * np.pi * D_A * D_A * (1. + redshift) *
(1. + redshift))
norm_sim = float(norm_sim.in_cgs())
v1, v2 = sphere.quantities.weighted_variance(v_field, em_field)
sigma_sim = float(v1.in_units("km/s"))
mu_sim = -float(v2.in_units("km/s"))
events = photons.project_photons("z",
absorb_model=abs_model,
prng=source.prng)
events = ACIS_I(events, rebin=False, convolve_psf=False, prng=source.prng)
events.write_spectrum("beta_model_evt.pi", clobber=True)
os.system("cp %s ." % events.parameters["ARF"])
os.system("cp %s ." % events.parameters["RMF"])
load_user_model(mymodel, "tbapec")
add_user_pars("tbapec", ["nH", "kT", "metallicity", "redshift", "norm"],
[0.01, 4.0, 0.2, redshift, norm_sim * 0.8],
parmins=[0.0, 0.1, 0.0, -20.0, 0.0],
parmaxs=[10.0, 20.0, 10.0, 20.0, 1.0e9],
parfrozen=[False, False, False, True, False])
load_pha("beta_model_evt.pi")
set_stat("cstat")
set_method("simplex")
ignore(":0.5, 8.0:")
set_model("tbapec")
fit()
set_covar_opt("sigma", 1.645)
covar()
res = get_covar_results()
assert np.abs(res.parvals[0] - nH_sim) < res.parmaxes[0]
assert np.abs(res.parvals[1] - kT_sim) < res.parmaxes[1]
assert np.abs(res.parvals[2] - Z_sim) < res.parmaxes[2]
assert np.abs(res.parvals[3] - norm_sim) < res.parmaxes[3]
os.chdir(curdir)
shutil.rmtree(tmpdir)
def test_vapec_beta_model():
bms = BetaModelSource()
tmpdir = tempfile.mkdtemp()
curdir = os.getcwd()
os.chdir(tmpdir)
prng = 45
ds = bms.ds
A = 30000.
exp_time = 1.0e4
redshift = 0.05
nH_sim = 0.02
sphere = ds.sphere("c", (0.5, "Mpc"))
kT_sim = bms.kT
Z_sim = bms.Z
O_sim = bms.O
Ca_sim = bms.Ca
var_elem = {"O": ("stream", "oxygen"),
"Ca": ("stream", "calcium")}
thermal_model = ThermalSourceModel("apec", 0.1, 11.5, 20000,
var_elem=var_elem,
Zmet=("gas","metallicity"),
prng=prng)
photons = PhotonList.from_data_source(sphere, redshift, A, exp_time,
thermal_model)
D_A = photons.parameters["fid_d_a"]
norm_sim = sphere.quantities.total_quantity("emission_measure")
norm_sim *= 1.0e-14/(4*np.pi*D_A*D_A*(1.+redshift)*(1.+redshift))
norm_sim = float(norm_sim.in_cgs())
events = photons.project_photons("z", [30.0, 45.0], absorb_model="tbabs",
nH=nH_sim, prng=prng, no_shifting=True)
new_events = Lynx_Calorimeter(events, prng=prng)
os.system("cp %s %s ." % (arf.filename, rmf.filename))
new_events.write_channel_spectrum("var_abund_beta_model_evt.pha", overwrite=True)
load_user_model(mymodel_var, "tbapec")
add_user_pars("tbapec", ["nH", "kT", "abund", "redshift", "norm", "O", "Ca"],
[nH_sim, 4.0, Z_sim, redshift, norm_sim*0.8, 0.3, 0.5],
parmins=[0.0, 0.1, 0.0, -20.0, 0.0, 0.0, 0.0],
parmaxs=[10.0, 20.0, 10.0, 20.0, 1.0e9, 10.0, 10.0],
parfrozen=[True, False, True, True, False, False, False])
load_pha("var_abund_beta_model_evt.pha")
set_stat("cstat")
set_method("levmar")
ignore(":0.6, 8.0:")
set_model("tbapec")
fit()
res = get_fit_results()
assert np.abs(res.parvals[0]-kT_sim)/kT_sim < 0.05
assert np.abs(res.parvals[1]-norm_sim)/norm_sim < 0.05
assert np.abs(res.parvals[2]-O_sim)/O_sim < 0.05
assert np.abs(res.parvals[3]-Ca_sim)/Ca_sim < 0.15
os.chdir(curdir)
shutil.rmtree(tmpdir)
def test_ui_user_model_ascii_table(setup_files):
ui.load_user_model(identity, 'mdl', setup_files.singledat)
ui.load_user_model(identity, 'mdl', setup_files.doubledat)
def test_background():
tmpdir = tempfile.mkdtemp()
curdir = os.getcwd()
os.chdir(tmpdir)
kT_sim = 1.0
Z_sim = 0.0
norm_sim = 4.0e-2
nH_sim = 0.04
redshift = 0.01
exp_time = (200., "ks")
area = (1000., "cm**2")
fov = (10.0, "arcmin")
prng = 24
agen = ApecGenerator(0.05, 12.0, 5000, broadening=False)
spec = agen.get_spectrum(kT_sim, Z_sim, redshift, norm_sim)
spec.apply_foreground_absorption(norm_sim)
events = make_background(area,
exp_time,
fov, (30.0, 45.0),
spec,
prng=prng)
events.write_simput_file("bkgnd", overwrite=True)
instrument_simulator("bkgnd_simput.fits",
"bkgnd_evt.fits",
exp_time,
"sq_acisi_cy19", [30.0, 45.0],
overwrite=True,
foreground=False,
ptsrc_bkgnd=False,
instr_bkgnd=False,
prng=prng)
write_spectrum("bkgnd_evt.fits", "background_evt.pi", overwrite=True)
os.system("cp %s %s ." % (arf.filename, rmf.filename))
load_user_model(mymodel, "wapec")
add_user_pars("wapec", ["nH", "kT", "metallicity", "redshift", "norm"],
[0.01, 4.0, 0.2, redshift, norm_sim * 0.8],
parmins=[0.0, 0.1, 0.0, -20.0, 0.0],
parmaxs=[10.0, 20.0, 10.0, 20.0, 1.0e9],
parfrozen=[False, False, False, True, False])
load_pha("background_evt.pi")
set_stat("cstat")
set_method("simplex")
ignore(":0.5, 8.0:")
set_model("wapec")
fit()
res = get_fit_results()
assert np.abs(res.parvals[0] - nH_sim) / nH_sim < 0.1
assert np.abs(res.parvals[1] - kT_sim) / kT_sim < 0.05
assert np.abs(res.parvals[2] - Z_sim) < 0.05
assert np.abs(res.parvals[3] - norm_sim) / norm_sim < 0.05
os.chdir(curdir)
shutil.rmtree(tmpdir)
def test_user_model_ascii_table(self):
ui.load_user_model(self.func, 'mdl', self.singledat)
ui.load_user_model(self.func, 'mdl', self.doubledat)
def test_341():
"""
The original reporter of bug #341 had a special implementation that should be captured
by this test. The implementation has a proxy model that takes care of updating the actual
model when it is evaluated. During a recent refactoring of the Stat and Fit code
(PR #287) a regression was introduced by short-circuiting the evaluation of the model.
"""
class ExampleModel(object):
""" Class to define model
"""
def __init__(self, x, y):
self.x = np.array(x)
self.y = np.array(y)
self.parvals = [1, 2]
self.parnames = ("m", "b")
def calc_stat(self):
return float(np.sum(np.abs(self.y - self.model())))
def model(self):
return self.parvals[0] * self.x + self.parvals[1]
class CalcModel(object):
""" Class to update model parameters
"""
def __init__(self, model):
self.model = model
def __call__(self, pars, x):
self.model.parvals = pars
return np.ones_like(x)
class CalcStat(object):
""" Class to determine fit statistic
"""
def __init__(self, model):
self.model = model
def __call__(self, _data, _model, *args, **kwargs):
fit_stat = self.model.calc_stat()
return fit_stat, np.ones(1)
xdata = [1, 2, 3]
ydata = [4, 5, 6]
newmodel = ExampleModel(xdata, ydata)
dummy_data = np.zeros(1)
dummy_times = np.arange(1)
ui.load_arrays(1, dummy_times, dummy_data)
method = 'simplex'
ui.set_method(method)
ui.load_user_model(CalcModel(newmodel), 'simplemodel')
ui.add_user_pars('simplemodel', newmodel.parnames)
ui.set_model(1, 'simplemodel')
calc_stat = CalcStat(newmodel)
ui.load_user_stat('customstat', calc_stat, lambda x: np.ones_like(x))
ui.set_stat(eval('customstat'))
ui.fit(1)
assert ui.get_par("simplemodel.m").val == approx(1, abs=0.00001)
assert ui.get_par("simplemodel.b").val == approx(3, abs=0.00001)
def test_point_source():
tmpdir = tempfile.mkdtemp()
curdir = os.getcwd()
os.chdir(tmpdir)
nH_sim = 0.02
norm_sim = 1.0e-4
alpha_sim = 0.95
redshift = 0.02
exp_time = (100., "ks")
area = (3000., "cm**2")
wcs = create_dummy_wcs()
ebins = np.linspace(0.1, 11.5, 2001)
emid = 0.5*(ebins[1:]+ebins[:-1])
spec = norm_sim*(emid*(1.0+redshift))**(-alpha_sim)
de = np.diff(ebins)[0]
abs_model = TBabsModel(nH_sim)
events = EventList.create_empty_list(exp_time, area, wcs)
positions = [(30.01, 45.0)]
new_events = events.add_point_sources(positions, ebins, spec, prng=prng,
absorb_model=abs_model)
new_events = ACIS_S(new_events, prng=prng)
scalex = float(np.std(new_events['xpix'])*sigma_to_fwhm*new_events.parameters["dtheta"])
scaley = float(np.std(new_events['ypix'])*sigma_to_fwhm*new_events.parameters["dtheta"])
psf_scale = ACIS_S.psf_scale
assert (scalex - psf_scale)/psf_scale < 0.01
assert (scaley - psf_scale)/psf_scale < 0.01
new_events.write_spectrum("point_source_evt.pi", clobber=True)
os.system("cp %s ." % new_events.parameters["ARF"])
os.system("cp %s ." % new_events.parameters["RMF"])
load_user_model(mymodel, "tplaw")
add_user_pars("tplaw", ["nH", "norm", "redshift", "alpha"],
[0.01, norm_sim*0.8, redshift, 0.9],
parmins=[0.0, 0.0, 0.0, 0.1],
parmaxs=[10.0, 1.0e9, 10.0, 10.0],
parfrozen=[False, False, True, False])
load_pha("point_source_evt.pi")
set_stat("cstat")
set_method("simplex")
ignore(":0.5, 9.0:")
set_model("tplaw")
fit()
set_covar_opt("sigma", 1.6)
covar()
res = get_covar_results()
assert np.abs(res.parvals[0]-nH_sim) < res.parmaxes[0]
assert np.abs(res.parvals[1]-norm_sim/de) < res.parmaxes[1]
assert np.abs(res.parvals[2]-alpha_sim) < res.parmaxes[2]
os.chdir(curdir)
shutil.rmtree(tmpdir)
self.min_parvals = self.parvals
return fit_stat, np.ones_like(self.displ)
# def fit(method='levmar'):
method = 'simplex'
dummy_data = np.zeros(100)
dummy_times = np.arange(100)
ui.load_arrays(1, dummy_times, dummy_data)
ui.set_method(method)
ui.get_method().config.update(SHERPA_CONFIGS.get(method, {}))
calc_model = CalcModel()
ui.load_user_model(calc_model, 'axo_mod') # sets global axo_mod
parnames = []
for row in range(N_ROWS):
for col in range(N_COLS):
parnames.append('adj_{}_{}'.format(row, col))
ui.add_user_pars('axo_mod', parnames)
ui.set_model(1, 'axo_mod')
calc_stat = CalcStat(axo_mod, M_2d, displ_x)
ui.load_user_stat('axo_stat', calc_stat, lambda x: np.ones_like(x))
ui.set_stat(axo_stat)
calc_model.set_calc_stat(calc_stat)
# Set frozen, min, and max attributes for each axo_mod parameter
for par in axo_mod.pars:
