def fit(self):
dummy_data = np.zeros(1)
dummy_times = np.arange(1)
ui.load_arrays(1, dummy_times, dummy_data)
ui.set_method(self.method)
ui.get_method().config.update(sherpa_configs.get(self.method, {}))
ui.load_user_model(CalcModel(self.model), 'xijamod') # sets global xijamod
ui.add_user_pars('xijamod', self.model.parnames)
ui.set_model(1, 'xijamod')
calc_stat = CalcStat(self.model, self.child_pipe, self.maxiter)
ui.load_user_stat('xijastat', calc_stat, lambda x: np.ones_like(x))
ui.set_stat(xijastat)
# Set frozen, min, and max attributes for each xijamod parameter
for par in self.model.pars:
xijamod_par = getattr(xijamod, par.full_name)
xijamod_par.val = par.val
xijamod_par.frozen = par.frozen
xijamod_par.min = par.min
xijamod_par.max = par.max
if any(not par.frozen for par in self.model.pars):
try:
ui.fit(1)
calc_stat.message['status'] = 'finished'
fit_logger.info('Fit finished normally')
except FitTerminated as err:
calc_stat.message['status'] = 'terminated'
fit_logger.warning('Got FitTerminated exception {}'.format(err))
self.child_pipe.send(calc_stat.message)
def fit_sbp():
ui.set_model(sbp)
ui.thaw(sbp)
ui.freeze(sbp.x_r)
ui.freeze(sbp.gamma1)
ui.fit()
def test_proton_model():
"""
test import
"""
from ..sherpa_models import PionDecay
model = PionDecay()
model.ampl = 1e36
model.index = 2.1
# point calc
output = model.calc([p.val for p in model.pars], energies)
# integrated
output = model.calc([p.val for p in model.pars], elo, xhi=ehi)
# test as well ECPL
model.cutoff = 1000
# Perform a fit to fake data
ui.load_arrays(1, energies, test_spec_points, test_err_points)
ui.set_model(model)
ui.guess()
# Actual fit is too slow for tests
# ui.fit()
# test with integrated data
ui.load_arrays(1, elo, ehi, test_spec_int, test_err_int, ui.Data1DInt)
ui.set_model(model)
ui.guess()
def fit_pix_values(t_ccd, esec, id=1):
logger = logging.getLogger("sherpa")
logger.setLevel(logging.WARN)
data_id = id
ui.clean()
ui.set_method('simplex')
ui.load_user_model(dark_scale_model, 'model')
ui.add_user_pars('model', ['scale', 'dark_t_ref'])
ui.set_model(data_id, 'model')
ui.load_arrays(
data_id,
np.array(t_ccd),
np.array(esec),
)
ui.set_staterror(data_id, 30 * np.ones(len(t_ccd)))
model.scale.val = 0.588
model.scale.min = 0.3
model.scale.max = 1.0
model.dark_t_ref.val = 500
ui.freeze(model.scale)
# If more than 5 degrees in the temperature range,
# thaw and fit for model.scale. Else just use/return
# the fit of dark_t_ref
if np.max(t_ccd) - np.min(t_ccd) > 2:
# Fit first for dark_t_ref
ui.fit(data_id)
ui.thaw(model.scale)
ui.fit(data_id)
return ui.get_fit_results(), ui.get_model(data_id)
def fit(self, method='simplex'):
"""Initiate a fit of the model using Sherpa.
:param method: Method to be used to fit the model (e.g. simplex, levmar, or moncar)
"""
dummy_data = np.zeros(1)
dummy_times = np.arange(1)
ui.load_arrays(1, dummy_times, dummy_data)
ui.set_method(method)
ui.get_method().config.update(sherpa_configs.get(method, {}))
ui.load_user_model(CalcModel(self.model, self.fit_logger),
'xijamod') # sets global xijamod
ui.add_user_pars('xijamod', self.model.parnames)
ui.set_model(1, 'xijamod')
calc_stat = CalcStat(self.model, self.fit_logger)
ui.load_user_stat('xijastat', calc_stat, lambda x: np.ones_like(x))
ui.set_stat(xijastat)
# Set frozen, min, and max attributes for each xijamod parameter
for par in self.model.pars:
xijamod_par = getattr(xijamod, par.full_name)
xijamod_par.val = par.val
xijamod_par.frozen = par.frozen
xijamod_par.min = par.min
xijamod_par.max = par.max
ui.fit(1)
self.save_snapshot(fit_stat=calc_stat.min_fit_stat, method=method)
def fit(self):
dummy_data = np.zeros(1)
dummy_times = np.arange(1)
ui.load_arrays(1, dummy_times, dummy_data)
ui.set_method(self.method)
ui.get_method().config.update(sherpa_configs.get(self.method, {}))
ui.load_user_model(CalcModel(self.model), 'xijamod') # sets global xijamod
ui.add_user_pars('xijamod', self.model.parnames)
ui.set_model(1, 'xijamod')
calc_stat = CalcStat(self.model, self.child_pipe)
ui.load_user_stat('xijastat', calc_stat, lambda x: np.ones_like(x))
ui.set_stat(xijastat)
# Set frozen, min, and max attributes for each xijamod parameter
for par in self.model.pars:
xijamod_par = getattr(xijamod, par.full_name)
xijamod_par.val = par.val
xijamod_par.frozen = par.frozen
xijamod_par.min = par.min
xijamod_par.max = par.max
if any(not par.frozen for par in self.model.pars):
try:
ui.fit(1)
calc_stat.message['status'] = 'finished'
logging.debug('Fit finished normally')
except FitTerminated as err:
calc_stat.message['status'] = 'terminated'
logging.debug('Got FitTerminated exception {}'.format(err))
self.child_pipe.send(calc_stat.message)
def _fit_poly(fit_data, evt_times, degree, data_id=0):
"""
Given event data transformed into Y or Z angle positions, and a degree of the desired
fit polynomial, fit a polynomial to the data.
:param fit_data: event y or z angle position data
:param evt_times: times of event/fit_data
:param degree: degree of polynomial to use for the fit model
:param data_id: sherpa dataset id to use for the fit
:returns: (sherpa model plot, sherpa model)
"""
# Set initial value for fit data position error
init_error = 1
ui.clean()
ui.load_arrays(data_id, evt_times - evt_times[0], fit_data,
np.zeros_like(fit_data) + init_error)
v2("Fitting a line to the data to get reduced stat errors")
# First just fit a line to get reduced errors on this set
ui.polynom1d.line
ui.set_model(data_id, 'line')
ui.thaw('line.c1')
ui.fit(data_id)
fit = ui.get_fit_results()
calc_error = init_error * np.sqrt(fit.rstat)
ui.set_staterror(data_id, calc_error)
# Then fit the specified model
v2("Fitting a polynomial of degree {} to the data".format(degree))
ui.polynom1d.fitpoly
ui.freeze('fitpoly')
# Thaw the coefficients requested by the degree of the desired polynomial
ui.thaw('fitpoly.c0')
fitpoly.c0.val = 0
for deg in range(1, 1 + degree):
ui.thaw("fitpoly.c{}".format(deg))
ui.set_model(data_id, 'fitpoly')
ui.fit(data_id)
# Let's screw up Y on purpose
if data_id == 0:
fitpoly.c0.val = 0
fitpoly.c1.val = 7.5e-05
fitpoly.c2.val = -1.0e-09
fitpoly.c3.val = 0
fitpoly.c4.val = 0
mp = ui.get_model_plot(data_id)
model = ui.get_model(data_id)
return mp, model
def setUp(self):
self._old_logger_level = logger.getEffectiveLevel()
logger.setLevel(logging.ERROR)
ui.clean()
self.ascii = self.make_path('sim.poisson.1.dat')
self.wrong_stat_msg = "Fit statistic must be cash, cstat or wstat, not {}"
self.wstat_err_msg = "No background data has been supplied. Use cstat"
self.no_covar_msg = "covariance has not been performed"
self.fail_msg = "Call should not have succeeded"
self.right_stats = {'cash', 'cstat', 'wstat'}
self.model = PowLaw1D("p1")
ui.load_data(self.ascii)
ui.set_model(self.model)
def setUp(self):
self._old_logger_level = logger.getEffectiveLevel()
logger.setLevel(logging.ERROR)
ui.clean()
self.ascii = self.make_path('sim.poisson.1.dat')
self.wrong_stat_msg = "Fit statistic must be cash, cstat or wstat, not {}"
self.wstat_err_msg = "No background data has been supplied. Use cstat"
self.no_covar_msg = "covariance has not been performed"
self.fail_msg = "Call should not have succeeded"
self.right_stats = {'cash', 'cstat', 'wstat'}
self.model = PowLaw1D("p1")
ui.load_data(self.ascii)
ui.set_model(self.model)
def ccd_bias(bias):
"""
Calculate the mean and width of a gaussian fit to the bias
histogram.
`bias` is a numpy array.
"""
import sherpa.ui as ui
from numpy import histogram, arange
values, bins = histogram(bias, bins=arange(bias.min(),bias.max()+1))
ui.load_arrays(1, bins[:-1],values)
ui.set_model(ui.gauss1d.g1)
g1.pos = bias.mean()
g1.fwhm = bias.std()
ui.fit()
return g1
def fit_model(
model,
comm=None,
method='simplex',
config=None,
nofit=None,
freeze_pars=freeze_pars,
thaw_pars=[],
):
dummy_data = np.zeros(1)
dummy_times = np.arange(1)
ui.load_arrays(1, dummy_times, dummy_data)
ui.set_method(method)
ui.get_method().config.update(config or sherpa_configs.get(method, {}))
ui.load_user_model(CalcModel(model, comm), 'xijamod')
ui.add_user_pars('xijamod', model.parnames)
ui.set_model(1, 'xijamod')
fit_parnames = set()
for parname, parval in zip(model.parnames, model.parvals):
getattr(xijamod, parname).val = parval
fit_parnames.add(parname)
if any([re.match(x + '$', parname) for x in freeze_pars]):
fit_logger.info('Freezing ' + parname)
ui.freeze(getattr(xijamod, parname))
fit_parnames.remove(parname)
if any([re.match(x + '$', parname) for x in thaw_pars]):
fit_logger.info('Thawing ' + parname)
ui.thaw(getattr(xijamod, parname))
fit_parnames.add(parname)
if 'tau' in parname:
getattr(xijamod, parname).min = 0.1
calc_stat = CalcStat(model, comm)
ui.load_user_stat('xijastat', calc_stat, lambda x: np.ones_like(x))
ui.set_stat(xijastat)
if fit_parnames and not nofit:
ui.fit(1)
else:
model.calc()
def fit_model(model,
comm=None,
method='simplex',
config=None,
nofit=None,
freeze_pars=freeze_pars,
thaw_pars=[],
):
dummy_data = np.zeros(1)
dummy_times = np.arange(1)
ui.load_arrays(1, dummy_times, dummy_data)
ui.set_method(method)
ui.get_method().config.update(config or sherpa_configs.get(method, {}))
ui.load_user_model(CalcModel(model, comm), 'xijamod')
ui.add_user_pars('xijamod', model.parnames)
ui.set_model(1, 'xijamod')
fit_parnames = set()
for parname, parval in zip(model.parnames, model.parvals):
getattr(xijamod, parname).val = parval
fit_parnames.add(parname)
if any([re.match(x + '$', parname) for x in freeze_pars]):
fit_logger.info('Freezing ' + parname)
ui.freeze(getattr(xijamod, parname))
fit_parnames.remove(parname)
if any([re.match(x + '$', parname) for x in thaw_pars]):
fit_logger.info('Thawing ' + parname)
ui.thaw(getattr(xijamod, parname))
fit_parnames.add(parname)
if 'tau' in parname:
getattr(xijamod, parname).min = 0.1
calc_stat = CalcStat(model, comm)
ui.load_user_stat('xijastat', calc_stat, lambda x: np.ones_like(x))
ui.set_stat(xijastat)
if fit_parnames and not nofit:
ui.fit(1)
else:
model.calc()
def test_electron_models():
"""
test import
"""
from ..sherpa_models import InverseCompton, Synchrotron, Bremsstrahlung
for modelclass in [InverseCompton, Synchrotron, Bremsstrahlung]:
model = modelclass()
model.ampl = 1e-8
model.index = 2.1
print(model)
# point calc
output = model.calc([p.val for p in model.pars], energies)
# test as well ECPL
model.cutoff = 100
# integrated
output = model.calc([p.val for p in model.pars], elo, xhi=ehi)
if modelclass is InverseCompton:
# Perform a fit to fake data
ui.load_arrays(1, energies, test_spec_points, test_err_points)
ui.set_model(model)
ui.guess()
ui.fit()
# add FIR and NIR components and test verbose
model.uNIR.set(1.0)
model.uFIR.set(1.0)
model.verbose.set(1)
# test with integrated data
ui.load_arrays(1, elo, ehi, test_spec_int, test_err_int,
ui.Data1DInt)
ui.set_model(model)
ui.guess()
ui.fit()
def fit_pix_values(t_ccd, esec, id=1):
logger = logging.getLogger("sherpa")
logger.setLevel(logging.WARN)
data_id = id
ui.clean()
ui.set_method("simplex")
ui.load_user_model(dark_scale_model, "model")
ui.add_user_pars("model", ["scale", "dark_t_ref"])
ui.set_model(data_id, "model")
ui.load_arrays(data_id, np.array(t_ccd), np.array(esec), 0.1 * np.ones(len(t_ccd)))
model.scale.val = 0.70
model.dark_t_ref.val = 500
ui.freeze(model.scale)
# If more than 5 degrees in the temperature range,
# thaw and fit for model.scale. Else just use/return
# the fit of dark_t_ref
ui.fit(data_id)
ui.thaw(model.scale)
ui.fit(data_id)
return ui.get_fit_results(), ui.get_model(data_id)
def _fit_poly(fit_data, evt_times, degree, data_id=0):
"""
Given event data transformed into Y or Z angle positions, and a degree of the desired
fit polynomial, fit a polynomial to the data.
:param fit_data: event y or z angle position data
:param evt_times: times of event/fit_data
:param degree: degree of polynomial to use for the fit model
:param data_id: sherpa dataset id to use for the fit
:returns: (sherpa model plot, sherpa model)
"""
# Set initial value for fit data position error
init_error = 1
ui.clean()
ui.load_arrays(data_id, evt_times - evt_times[0], fit_data,
np.zeros_like(fit_data) + init_error)
v2("Fitting a line to the data to get reduced stat errors")
# First just fit a line to get reduced errors on this set
ui.polynom1d.line
ui.set_model(data_id, 'line')
ui.thaw('line.c1')
ui.fit(data_id)
fit = ui.get_fit_results()
calc_error = init_error * np.sqrt(fit.rstat)
ui.set_staterror(data_id, calc_error)
# Then fit the specified model
v2("Fitting a polynomial of degree {} to the data".format(degree))
ui.polynom1d.fitpoly
ui.freeze('fitpoly')
# Thaw the coefficients requested by the degree of the desired polynomial
ui.thaw('fitpoly.c0')
fitpoly.c0.val = 0
for deg in range(1, 1 + degree):
ui.thaw("fitpoly.c{}".format(deg))
ui.set_model(data_id, 'fitpoly')
ui.fit(data_id)
mp = ui.get_model_plot(data_id)
model = ui.get_model(data_id)
return mp, model
def fit_gauss_sbp():
g1 = ui.gauss1d.g1
ui.set_model(sbp + g1)
ui.set_method('simplex')
g1.fwhm = 5.0
g1.pos = 7.0
g1.ampl = 30000.
ui.freeze(sbp.gamma1)
ui.freeze(sbp.gamma2)
ui.freeze(sbp.x_b)
ui.freeze(sbp.x_r)
ui.freeze(g1.fwhm)
ui.freeze(g1.pos)
ui.thaw(g1.ampl)
ui.fit()
ui.thaw(g1.fwhm)
ui.thaw(g1.pos)
ui.fit()
ui.thaw(sbp)
ui.freeze(sbp.x_r)
ui.fit()
def test_add_model(self):
ui.add_model(UserModel)
ui.set_model("usermodel.user1")
line[line <= 0] = 1e-7
line[line >= 1] = 1 - 1e-7
return line
#axplot = {}
#ftype = 'obc_bad'
for ftype in failures:
fail_mask = failures[ftype]
data_id = figmap[ftype]
ui.set_method('simplex')
ui.load_user_model(lim_line, '%s_mod' % ftype)
ui.add_user_pars('%s_mod' % ftype, ['m', 'b'])
ui.set_model(data_id, '%s_mod' % ftype)
ui.load_arrays(data_id, times, failures[ftype])
fmod = ui.get_model_component('%s_mod' % ftype)
fmod.b.min = 0
fmod.b.max = 1
fmod.m.min = 0
fmod.m.max = 0.5
fmod.b.val = 1e-7
ui.load_user_stat("loglike", llh, my_err)
ui.set_stat(loglike)
# the tricky part here is that the "model" is the probability polynomial
# we've defined evaluated at the data x values.
def run_fits(obsids, ax, user_pars=None,
fixed_pars=None, guess_pars=None, label='model',
per_obs_dir='per_obs_nfits',
outdir=None, redo=False):
if len(obsids) == 0:
print "No obsids, nothing to fit"
return None
if user_pars is None:
user_pars = USER_PARS
if not os.path.exists(per_obs_dir):
os.makedirs(per_obs_dir)
obsfits = []
for obsid in obsids:
outdir = os.path.join(per_obs_dir, 'obs{:05d}'.format(obsid))
if not os.path.exists(outdir):
os.makedirs(outdir)
model_file = os.path.join(outdir, '{}.pkl'.format(label))
if os.path.exists(model_file) and not redo:
#logger.warn('Using previous fit found in %s' % model_file)
print model_file
mod_pick = open(model_file, 'r')
modelfit = cPickle.load( mod_pick )
mod_pick.close()
obsfits.append(modelfit)
continue
modelfit = {'label': obsid}
ui.clean()
data_id = 0
obsdir = "%s/obs%05d" % (DATADIR, obsid)
tf = open(os.path.join(obsdir,'tilt.pkl'), 'r')
tilt = cPickle.load(tf)
tf.close()
pf = open(os.path.join(obsdir, 'pos.pkl'), 'r')
pos = cPickle.load(pf)
pf.close()
pos_data = pos[ax]
point_error = 5
pos_data_mean = np.mean(pos_data)
ui.set_method('simplex')
# Fit a line to get more reasonable errors
init_staterror = np.zeros(len(pos_data))+point_error
ui.load_arrays(data_id,
pos['time']-pos['time'][0],
pos_data-np.mean(pos_data),
init_staterror)
ui.polynom1d.ypoly
ui.set_model(data_id, 'ypoly')
ui.thaw(ypoly.c0, ypoly.c1)
ui.fit(data_id)
fit = ui.get_fit_results()
calc_staterror = init_staterror * np.sqrt(fit.rstat)
ui.set_staterror(data_id, calc_staterror)
# Confirm those errors
ui.fit(data_id)
fit = ui.get_fit_results()
if ( abs(fit.rstat-1) > .2):
raise ValueError('Reduced statistic not close to 1 for error calc')
# Load up data to do the real model fit
fit_times = pos['time']
tm_func = tilt_model(tilt,
fit_times,
user_pars=user_pars)
ui.get_data(data_id).name = str(obsid)
ui.load_user_model(tm_func, 'tiltm%d' % data_id)
ui.add_user_pars('tiltm%d' % data_id, user_pars)
ui.set_method('simplex')
ui.set_model(data_id, 'tiltm%d' % (data_id))
ui.set_par('tiltm%d.diam' % data_id, 0)
if fixed_pars is not None and ax in fixed_pars:
for par in fixed_pars[ax]:
ui.set_par('tiltm{}.{}'.format(0, par), fixed_pars[ax][par])
ui.freeze('tiltm{}.{}'.format(0, par))
if guess_pars is not None and ax in guess_pars:
for par in guess_pars[ax]:
ui.set_par('tiltm{}.{}'.format(0, par), guess_pars[ax][par])
ui.show_all()
# Fit the tilt model
ui.fit(data_id)
fitres = ui.get_fit_results()
ui.confidence(data_id)
myconf = ui.get_confidence_results()
# save_fits(ax=ax, fit=fitres, conf=myconf, outdir=outdir)
# plot_fits(ids,outdir=os.path.join(outdir,'fit_plots'))
axmod = dict(fit=fitres, conf=myconf)
for idx, modpar in enumerate(myconf.parnames):
par = modpar.lstrip('tiltm0.')
axmod[par] = ui.get_par('tiltm0.%s' % par).val
axmod["{}_parmax".format(par)] = myconf.parmaxes[idx]
axmod["{}_parmin".format(par)] = myconf.parmins[idx]
modelfit[ax] = axmod
mod_pick = open(model_file, 'w')
cPickle.dump( modelfit, mod_pick)
mod_pick.close()
obsfits.append(modelfit)
plot_fits([dict(obsid=obsid, data_id=data_id, ax=ax)],
posdir=obsdir,
outdir=outdir)
return obsfits
wp_min = np.min(warm_frac)
warm_frac = warm_frac - wp_min
def scaled_warm_frac(pars, x):
scaled = pars[1] + warm_frac * pars[0]
return scaled
data_id = 1
ui.set_method("simplex")
ui.set_stat("chi2datavar")
# ui.set_stat('leastsq')
# ui.load_user_stat("chi2custom", my_chi2, my_err)
# ui.set_stat(chi2custom)
ui.load_user_model(scaled_warm_frac, "model")
ui.add_user_pars("model", ["scale", "offset"])
ui.set_model(data_id, "model")
ui.load_arrays(data_id, np.array(times), np.array(bad_frac))
fmod = ui.get_model_component("model")
fmod.scale.min = 1e-9
max_err = np.max([data[range_type][mag][ok]["err_high"], data[range_type][mag][ok]["err_low"]], axis=0)
ui.set_staterror(data_id, max_err)
ui.fit(data_id)
f = ui.get_fit_results()
scale = f.rstat ** 0.5
ui.set_staterror(data_id, max_err * scale)
ui.fit()
f = ui.get_fit_results()
if f.rstat > 3:
raise ValueError
ui.confidence()
conf = ui.get_confidence_results()
def test_add_model(self):
ui.add_model(UserModel)
ui.set_model('usermodel.user1')
class AstropyToSherpa(object):
def __init__(self, model):
self.model = model
def __call__(self, pars, x):
self.model.parameters[:] = pars
return self.model(x)
ap_model = (models.Gaussian1D(amplitude=1.2, mean=0.9, stddev=0.5) +
models.Gaussian1D(amplitude=2.0, mean=-0.9, stddev=0.75))
err = 0.02
x = np.arange(-3, 3, .1)
y = ap_model(x) + err * np.random.uniform(size=len(x))
sh_model = AstropyToSherpa(ap_model)
ui.load_arrays(1, x, y, err * np.ones_like(x))
ui.load_user_model(sh_model, 'sherpa_model')
ui.add_user_pars('sherpa_model', ap_model.param_names, ap_model.parameters)
ui.set_model(1, 'sherpa_model')
ui.fit(1)
ui.plot_fit(1)
print()
print('Params from astropy model: {}'.format(ap_model.parameters))
plt.show()
def run_fits(obsids,
ax,
user_pars=None,
fixed_pars=None,
guess_pars=None,
label='model',
per_obs_dir='per_obs_nfits',
outdir=None,
redo=False):
if len(obsids) == 0:
print "No obsids, nothing to fit"
return None
if user_pars is None:
user_pars = USER_PARS
if not os.path.exists(per_obs_dir):
os.makedirs(per_obs_dir)
obsfits = []
for obsid in obsids:
outdir = os.path.join(per_obs_dir, 'obs{:05d}'.format(obsid))
if not os.path.exists(outdir):
os.makedirs(outdir)
model_file = os.path.join(outdir, '{}.pkl'.format(label))
if os.path.exists(model_file) and not redo:
#logger.warn('Using previous fit found in %s' % model_file)
print model_file
mod_pick = open(model_file, 'r')
modelfit = cPickle.load(mod_pick)
mod_pick.close()
obsfits.append(modelfit)
continue
modelfit = {'label': obsid}
ui.clean()
data_id = 0
obsdir = "%s/obs%05d" % (DATADIR, obsid)
tf = open(os.path.join(obsdir, 'tilt.pkl'), 'r')
tilt = cPickle.load(tf)
tf.close()
pf = open(os.path.join(obsdir, 'pos.pkl'), 'r')
pos = cPickle.load(pf)
pf.close()
pos_data = pos[ax]
point_error = 5
pos_data_mean = np.mean(pos_data)
ui.set_method('simplex')
# Fit a line to get more reasonable errors
init_staterror = np.zeros(len(pos_data)) + point_error
ui.load_arrays(data_id, pos['time'] - pos['time'][0],
pos_data - np.mean(pos_data), init_staterror)
ui.polynom1d.ypoly
ui.set_model(data_id, 'ypoly')
ui.thaw(ypoly.c0, ypoly.c1)
ui.fit(data_id)
fit = ui.get_fit_results()
calc_staterror = init_staterror * np.sqrt(fit.rstat)
ui.set_staterror(data_id, calc_staterror)
# Confirm those errors
ui.fit(data_id)
fit = ui.get_fit_results()
if (abs(fit.rstat - 1) > .2):
raise ValueError('Reduced statistic not close to 1 for error calc')
# Load up data to do the real model fit
fit_times = pos['time']
tm_func = tilt_model(tilt, fit_times, user_pars=user_pars)
ui.get_data(data_id).name = str(obsid)
ui.load_user_model(tm_func, 'tiltm%d' % data_id)
ui.add_user_pars('tiltm%d' % data_id, user_pars)
ui.set_method('simplex')
ui.set_model(data_id, 'tiltm%d' % (data_id))
ui.set_par('tiltm%d.diam' % data_id, 0)
if fixed_pars is not None and ax in fixed_pars:
for par in fixed_pars[ax]:
ui.set_par('tiltm{}.{}'.format(0, par), fixed_pars[ax][par])
ui.freeze('tiltm{}.{}'.format(0, par))
if guess_pars is not None and ax in guess_pars:
for par in guess_pars[ax]:
ui.set_par('tiltm{}.{}'.format(0, par), guess_pars[ax][par])
ui.show_all()
# Fit the tilt model
ui.fit(data_id)
fitres = ui.get_fit_results()
ui.confidence(data_id)
myconf = ui.get_confidence_results()
# save_fits(ax=ax, fit=fitres, conf=myconf, outdir=outdir)
# plot_fits(ids,outdir=os.path.join(outdir,'fit_plots'))
axmod = dict(fit=fitres, conf=myconf)
for idx, modpar in enumerate(myconf.parnames):
par = modpar.lstrip('tiltm0.')
axmod[par] = ui.get_par('tiltm0.%s' % par).val
axmod["{}_parmax".format(par)] = myconf.parmaxes[idx]
axmod["{}_parmin".format(par)] = myconf.parmins[idx]
modelfit[ax] = axmod
mod_pick = open(model_file, 'w')
cPickle.dump(modelfit, mod_pick)
mod_pick.close()
obsfits.append(modelfit)
plot_fits([dict(obsid=obsid, data_id=data_id, ax=ax)],
posdir=obsdir,
outdir=outdir)
return obsfits
# coding: utf-8
import sherpa.ui as ui
from sherpa.models.template import KNNInterpolator
ui.load_data("custom_interp", "load_template_interpolator-bb_data.dat")
ui.load_template_interpolator('knn', KNNInterpolator, k=2, order=1)
ui.load_template_model('bb1', "bb_index.dat", template_interpolator_name='knn')
ui.set_model("custom_interp", "bb1")
ui.freeze("bb1.dummy")
ui.fit("custom_interp")
def test_ui_add_model(clean_ui, setup_ui):
ui.add_model(UserModel)
ui.set_model('usermodel.user1')
line = pars[0] * x + pars[1]
line[line <= 0] = 1e-7
line[line >= 1] = 1 - 1e-7
return line
#axplot = {}
#ftype = 'obc_bad'
for ftype in failures:
fail_mask = failures[ftype]
data_id = figmap[ftype]
ui.set_method('simplex')
ui.load_user_model(lim_line, '%s_mod' % ftype)
ui.add_user_pars('%s_mod' % ftype, ['m', 'b'])
ui.set_model(data_id, '%s_mod' % ftype)
ui.load_arrays(data_id,
times,
failures[ftype])
fmod = ui.get_model_component('%s_mod' % ftype)
fmod.b.min = 0
fmod.b.max = 1
fmod.m.min = 0
fmod.m.max = 0.5
fmod.b.val=1e-7
ui.load_user_stat("loglike", llh, my_err)
for ftype in fail_types:
filename = "by%s_data_%s.txt" % (trend_type, ftype)
rates = asciitable.read(filename)
data_id = fail_types[ftype]
ui.set_method('simplex')
ui.load_arrays(data_id,
rates['time'],
rates['rate'])
ui.set_staterror(data_id,
rates['err'])
ftype_poly = ui.polynom1d(ftype)
ui.set_model(data_id, ftype_poly)
ui.thaw(ftype_poly.c0)
ui.thaw(ftype_poly.c1)
ui.notice(DateTime(trend_date_start).frac_year)
ui.fit(data_id)
ui.notice()
myfit = ui.get_fit_results()
axplot = ui.get_model_plot(data_id)
if myfit.succeeded:
b = ftype_poly.c1.val * DateTime(trend_date_start).frac_year + ftype_poly.c0.val
m = ftype_poly.c1.val
rep_file = open('%s_fitfile.json' % ftype, 'w')
rep_file.write(json.dumps(dict(time0=DateTime(trend_date_start).frac_year,
datestart=trend_date_start,
datestop=data_stop,
bin=trend_type,
def setup_covar(make_data_path):
print("A")
ui.load_data(make_data_path('sim.poisson.1.dat'))
ui.set_model(PowLaw1D("p1"))
# coding: utf-8
import sherpa.ui as ui
ui.load_data("default_interp", "bb_data.dat")
ui.load_template_model('bb1', "bb_index.dat")
ui.load_template_model('bb2', "bb_index.dat")
ui.set_model("default_interp", bb1+bb2)
ui.freeze("bb1.dummy")
ui.freeze("bb2.dummy")
ui.fit("default_interp")
# coding: utf-8
import sherpa.ui as ui
ui.load_data("default_interp", "load_template_with_interpolation-bb_data.dat")
ui.load_template_model('bb1', "bb_index.dat")
ui.set_model("default_interp", bb1)
ui.set_method('gridsearch')
ui.set_method_opt('sequence', ui.get_model_component('bb1').parvals)
ui.fit("default_interp")
warm_frac = data[range_type][mag][ok]['n{}'.format(limit)]
extent = np.max(warm_frac) - np.min(warm_frac)
wp_min = np.min(warm_frac)
warm_frac = warm_frac - wp_min
def scaled_warm_frac(pars, x):
scaled = pars[1] + warm_frac * pars[0]
return scaled
data_id = 1
ui.set_method('simplex')
ui.set_stat('chi2datavar')
#ui.set_stat('leastsq')
#ui.load_user_stat("chi2custom", my_chi2, my_err)
#ui.set_stat(chi2custom)
ui.load_user_model(scaled_warm_frac, 'model')
ui.add_user_pars('model', ['scale', 'offset'])
ui.set_model(data_id, 'model')
ui.load_arrays(data_id,
np.array(times),
np.array(bad_frac))
fmod = ui.get_model_component('model')
fmod.scale.min = 1e-9
fmod.offset.val = 0
ui.freeze(fmod.offset)
max_err = np.max([err_high, err_low], axis=0)
ui.set_staterror(data_id, max_err)
ui.fit(data_id)
f = ui.get_fit_results()
scale = f.rstat ** .5
ui.set_staterror(data_id, max_err * scale)
ui.fit()
f = ui.get_fit_results()
